DEV Community: May Meow

AoC25 Day 8: Playground

May Meow — Mon, 08 Dec 2025 12:51:03 +0000

Day 8 was basically a geometric Kruskal party. Every junction box is a point in 3D space, and connecting two points merges their electrical circuits. Part 1 stops after the 1000 closest connections; Part 2 runs until everything is fused into one mega-circuit.

Part 1 – Wiring the Closest Circuits

To figure out what the three largest circuits look like after 1000 tiny wires, I treated the boxes as a complete graph and let a Disjoint Set Union keep track of circuit sizes.

Parse & Build Edges. Read every x,y,z triple, build all pairwise edges, and store squared distances to avoid slow square roots.
Sort the Edge List. Sorting puts the shortest edges first, exactly what Kruskal’s algorithm needs.
Union the First 1000. Feed the first 1000 edges (or fewer if the graph is smaller) into the DSU. Every successful union merges two circuits and accumulates their sizes.
Multiply the Top Three. Collect every component size left inside the DSU, sort descending, and multiply the three largest counts for the answer.

Complexity. Building and sorting the (n(n-1)/2) edges costs (O(n^2 \log n)) time and (O(n^2)) memory. DSU operations are effectively constant per edge.

Part 2 – Finding the Final Wire

Now the Elves wanted to know which single connection finally ties the whole playground together and how long that wire needs to be along the X axis.

Reuse the Sorted Edges. No new parsing tricks—just march through the same edge list again.
Track Components. I let the DSU expose a components counter. Each successful union decrements it.
Stop at One Circuit. As soon as components drops to 1, the current edge is the decisive connection. I stash that pair of indices.
BigInt Output. Multiply the X coordinates of that pair using BigInt so even absurd coordinates stay accurate.

Complexity. Same (O(n^2 \log n)) time and (O(n^2)) space as Part 1, though we usually terminate well before exhausting every edge because a spanning tree only needs (n-1) successful unions.

Takeaways

Both parts piggyback on the same sorted edge list; changing the stopping condition gives two different answers almost for free.
Tracking component sizes solved Part 1, while tracking the component count solved Part 2—two tiny tweaks to the DSU internals.
BigInt support in Node makes it painless to return huge coordinate products without worrying about overflow.

Solutions

const fs = require('fs');
const path = require('path');

const inputPath = process.argv[2] ?? path.join(__dirname, 'input.txt');
const CONNECTION_LIMIT = 1000;

function readPoints(filePath) {
    const raw = fs.readFileSync(filePath, 'utf8').trim();
    if (!raw) {
        return [];
    }

    return raw.split(/\r?\n/).map((line) => line.split(',').map((value) => Number(value.trim())));
}

class DisjointSet {
    constructor(size) {
        this.parent = Array.from({ length: size }, (_, index) => index);
        this.rank = Array(size).fill(0);
        this.componentSize = Array(size).fill(1);
    }

    find(node) {
        if (this.parent[node] !== node) {
            this.parent[node] = this.find(this.parent[node]);
        }
        return this.parent[node];
    }

    union(a, b) {
        let rootA = this.find(a);
        let rootB = this.find(b);
        if (rootA === rootB) {
            return false;
        }

        if (this.rank[rootA] < this.rank[rootB]) {
            [rootA, rootB] = [rootB, rootA];
        }

        this.parent[rootB] = rootA;
        this.componentSize[rootA] += this.componentSize[rootB];

        if (this.rank[rootA] === this.rank[rootB]) {
            this.rank[rootA] += 1;
        }

        return true;
    }
}

function buildEdges(points) {
    const edges = [];
    for (let i = 0; i < points.length; i += 1) {
        for (let j = i + 1; j < points.length; j += 1) {
            const dx = points[i][0] - points[j][0];
            const dy = points[i][1] - points[j][1];
            const dz = points[i][2] - points[j][2];
            const distanceSquared = dx * dx + dy * dy + dz * dz;
            edges.push({ distanceSquared, a: i, b: j });
        }
    }
    edges.sort((left, right) => left.distanceSquared - right.distanceSquared);
    return edges;
}

function productOfLargestThree(dsu) {
    const sizesByRoot = new Map();
    for (let i = 0; i < dsu.parent.length; i += 1) {
        const root = dsu.find(i);
        sizesByRoot.set(root, (sizesByRoot.get(root) ?? 0) + 1);
    }

    const sorted = Array.from(sizesByRoot.values()).sort((a, b) => b - a);
    while (sorted.length < 3) {
        sorted.push(1);
    }
    return sorted.slice(0, 3).reduce((product, size) => product * size, 1);
}

function main() {
    if (!fs.existsSync(inputPath)) {
        console.error(`Input file not found: ${inputPath}`);
        process.exitCode = 1;
        return;
    }

    const points = readPoints(inputPath);
    if (points.length === 0) {
        console.log('0');
        return;
    }

    const edges = buildEdges(points);
    const dsu = new DisjointSet(points.length);
    const pairsToConnect = Math.min(CONNECTION_LIMIT, edges.length);

    for (let i = 0; i < pairsToConnect; i += 1) {
        const { a, b } = edges[i];
        dsu.union(a, b);
    }

    const answer = productOfLargestThree(dsu);
    console.log(answer.toString());
}

main();

const fs = require('fs');
const path = require('path');

const inputPath = process.argv[2] ?? path.join(__dirname, 'input.txt');

function readPoints(filePath) {
    const raw = fs.readFileSync(filePath, 'utf8').trim();
    if (!raw) {
        return [];
    }

    return raw.split(/\r?\n/).map((line) => line.split(',').map((value) => Number(value.trim())));
}

class DisjointSet {
    constructor(size) {
        this.parent = Array.from({ length: size }, (_, index) => index);
        this.rank = Array(size).fill(0);
        this.components = size;
    }

    find(node) {
        if (this.parent[node] !== node) {
            this.parent[node] = this.find(this.parent[node]);
        }
        return this.parent[node];
    }

    union(a, b) {
        let rootA = this.find(a);
        let rootB = this.find(b);
        if (rootA === rootB) {
            return false;
        }

        if (this.rank[rootA] < this.rank[rootB]) {
            [rootA, rootB] = [rootB, rootA];
        }

        this.parent[rootB] = rootA;
            if (this.rank[rootA] === this.rank[rootB]) {
            this.rank[rootA] += 1;
        }

        this.components -= 1;
        return true;
    }
}

function buildEdges(points) {
    const edges = [];
    for (let i = 0; i < points.length; i += 1) {
        for (let j = i + 1; j < points.length; j += 1) {
            const dx = points[i][0] - points[j][0];
            const dy = points[i][1] - points[j][1];
            const dz = points[i][2] - points[j][2];
            const distanceSquared = dx * dx + dy * dy + dz * dz;
            edges.push({ distanceSquared, a: i, b: j });
        }
    }
    edges.sort((left, right) => left.distanceSquared - right.distanceSquared);
    return edges;
}

function productOfXCoordinates(points, indexA, indexB) {
    const xA = BigInt(points[indexA][0]);
    const xB = BigInt(points[indexB][0]);
    return xA * xB;
}

function main() {
    if (!fs.existsSync(inputPath)) {
        console.error(`Input file not found: ${inputPath}`);
        process.exitCode = 1;
        return;
    }

    const points = readPoints(inputPath);
    if (points.length <= 1) {
        console.log('0');
        return;
    }

    const edges = buildEdges(points);
    const dsu = new DisjointSet(points.length);
    let lastConnection = null;

    for (const edge of edges) {
        if (dsu.union(edge.a, edge.b)) {
            lastConnection = edge;
            if (dsu.components === 1) {
                break;
            }
        }
    }

    if (!lastConnection) {
        console.error('Unable to connect all junction boxes.');
        process.exitCode = 1;
        return;
    }

    const product = productOfXCoordinates(points, lastConnection.a, lastConnection.b);
    console.log(product.toString());
}

main();

AoC25 Day 1: Secret Entrance

May Meow — Sun, 07 Dec 2025 15:20:23 +0000

For Day 1 I had to open a safe with a dial numbered 0–99. Here’s how both halves of the puzzle fell.

Part 1 – Counting end-of-rotation zeros

The dial starts at 50 and each instruction looks like L68 or R48. I only needed to know how many times the dial ended on 0 after finishing each rotation.

Implementation notes:

Parse every instruction once.
Track the current dial position; rotate by converting L to negative steps and R to positive steps.
Apply the delta with (position + delta) mod 100 keeping values non-negative.
Increment the answer whenever the resulting position equals 0.

This runs in O(n) with n rotations and needs only a handful of integers.

const fs = require('fs');
const path = require('path');

const DIAL_SIZE = 100;
const START_POSITION = 50;

const inputPath = process.argv[2] ?? path.join(__dirname, 'input.txt');

function readLines(filePath) {
    try {
        const raw = fs.readFileSync(filePath, 'utf8');
        return raw
        .split(/\r?\n/)
        .map((line) => line.trim())
        .filter((line) => line.length > 0);
    } catch (error) {
        throw new Error(`Unable to read input file: ${filePath}`);
    }
}

function rotate(position, instruction) {
    const direction = instruction[0];
    const distance = Number(instruction.slice(1));

    if (!Number.isFinite(distance)) {
        throw new Error(`Invalid distance in instruction: ${instruction}`);
    }

    if (direction !== 'L' && direction !== 'R') {
        throw new Error(`Invalid direction in instruction: ${instruction}`);
    }

    const delta = direction === 'L' ? -distance : distance;
    const next = (position + delta) % DIAL_SIZE;
    return (next + DIAL_SIZE) % DIAL_SIZE; // ensure non-negative
}

function countZeroStops(instructions) {
    let position = START_POSITION;
    let zeroCount = 0;

    for (const instruction of instructions) {
        position = rotate(position, instruction);
        if (position === 0) {
        zeroCount += 1;
        }
    }

    return zeroCount;
}

function main() {
    const instructions = readLines(inputPath);
    if (instructions.length === 0) {
        console.log('0');
        return;
    }

    const result = countZeroStops(instructions);
    console.log(result.toString());
}

main();

Part 2 – Counting every click that lands on zero

The “method 0x434C49434B” twist meant counting every individual click that passes through 0, even mid-rotation. A rotation of R1000 from 50 hits 0 ten times. I handled this with simple arithmetic:

Given the current position and direction, compute how many clicks it takes to reach the next zero (stepsUntilZero).
If the rotation distance is shorter, no zeros occur; otherwise count one for that first hit plus an additional floor((distance - firstHit)/100) for every full revolution afterwards.
Sum those counts and still update the final position with the same rotation logic from Part 1.

The whole solver stays O(n) but now also detects long runs efficiently without simulating each click.

const fs = require('fs');
const path = require('path');

const DIAL_SIZE = 100;
const START_POSITION = 50;

const inputPath = process.argv[2] ?? path.join(__dirname, 'input.txt');

function readLines(filePath) {
    try {
        const raw = fs.readFileSync(filePath, 'utf8');
        return raw
        .split(/\r?\n/)
        .map((line) => line.trim())
        .filter((line) => line.length > 0);
    } catch (error) {
        throw new Error(`Unable to read input file: ${filePath}`);
    }
}

function rotate(position, instruction) {
    const direction = instruction[0];
    const distance = Number(instruction.slice(1));

    if (!Number.isFinite(distance)) {
        throw new Error(`Invalid distance in instruction: ${instruction}`);
    }

    if (direction !== 'L' && direction !== 'R') {
        throw new Error(`Invalid direction in instruction: ${instruction}`);
    }

    const delta = direction === 'L' ? -distance : distance;
    const next = (position + delta) % DIAL_SIZE;
    return (next + DIAL_SIZE) % DIAL_SIZE;
}

function positiveMod(value, mod) {
    return ((value % mod) + mod) % mod;
}

function stepsUntilZero(position, direction) {
    const remainder = positiveMod(position, DIAL_SIZE);
    if (remainder === 0) {
        return DIAL_SIZE;
    }
    if (direction === 'R') {
        return DIAL_SIZE - remainder;
    }
    return remainder;
}

function countZeroClicksForRotation(position, direction, distance) {
    if (distance <= 0) {
        return 0;
    }

    const firstHit = stepsUntilZero(position, direction);
    if (firstHit > distance) {
        return 0;
    }

    return 1 + Math.floor((distance - firstHit) / DIAL_SIZE);
}

function countZeroClicks(instructions) {
    let position = START_POSITION;
    let zeroCount = 0;

    for (const instruction of instructions) {
        const direction = instruction[0];
        const distance = Number(instruction.slice(1));

        zeroCount += countZeroClicksForRotation(position, direction, distance);
        position = rotate(position, instruction);
    }

    return zeroCount;
}

function main() {
    const instructions = readLines(inputPath);
    if (instructions.length === 0) {
        console.log('0');
        return;
    }

    const result = countZeroClicks(instructions);
    console.log(result.toString());
}

main();

🔐 Using Environment Variables a Little More Securely

May Meow — Tue, 06 Feb 2024 19:51:13 +0000

Storing credentials in text files is not such a smart idea. A few days ago I found a post somewhere on reddit where people were discussing a more secure way to use environmental variables for restic. (By default they are stored as plain text).

When I tried to look for a solution for this, I found another post where people talked that you can customise restic code and build it yourself. But who wants to do that?

I wanted something more general. And came up with this. If you are on Windows you can use the Data Protection API more info here.

The data is then encrypted with a machine key. You just have to store that encrypted data somewhere. (for example in the registry)

Encrypting and decrypting data

In this example I am using DataProtectionScope.LocalMachine, which means the data can be decrypted by any process running on the same machine where the data was encrypted.

Another options is to use DataProtectionScope.CurrentUser, which means only the process running under the user who encrypted the data can decrypt it.

Your data can be encrypted like this

 byte[] encryptedData = ProtectedData.Protect(
        System.Text.Encoding.UTF8.GetBytes(value),
        optionalEntropy: null,
        scope: DataProtectionScope.LocalMachine
        );

    string encryptedString = Convert.ToBase64String( encryptedData );

and decrypted as easy as this

byte[] encryptedData = Convert.FromBase64String(encryptedString);
    byte[] decyptedData = ProtectedData.Unprotect(
            encryptedData,
            optionalEntropy: null,
            scope:  DataProtectionScope.LocalMachine
            );

Using data as environment variable

Now that you know how to encrypt, store and read data, you can use it as an environment variable when invoking external binary.

Environment.SetEnvironmentVariable("VAR1", var1);

and because you want to use environment variables, change UseShellExecute to false, which means that the process you are starting will not use the operating system shell to start the process. Instead, it will start the process directly. This allows you to redirect the input, output and error streams of the process.

if UseShellExecute is set to true, the new process will start in a new shell, and it will not have access to the environment variables set in the parent process.

ProcessStartInfo psi = new ProcessStartInfo
{
    FileName = batFilePath,
    RedirectStandardError = true,
    RedirectStandardOutput = true,
-    UseShellExecute = false,
+    UseShellExecute = false,
    CreateNoWindow = true,
};

start new process for your application

using (Process process = new Process { StartInfo = psi})
{
    process.Start();
    string output = process.StandardOutput.ReadToEnd();

    process.WaitForExit();

    Console.WriteLine("Microsoft Data protection API example");
    Console.WriteLine("---> " +  output);
}

For testing purposes you can create bat file like that:

@echo off
echo The value of MY_VARIABLE is: %VAR1%

If you run it as a standalone, you will not seed the variable value as this is only set under the process that your bat file is running from.

The above solution displays output after the process has finished. This is not ideal for time-consuming processes from which you want to see output. A possible solution could be as follows

using (Process process = new Process { StartInfo = psi})
{
+   process.OutputDataReceived += (sender, args) => Console.WriteLine("---> " + args.Data);

    process.Start();
+   process.BeginOutputReadLine();
+   process.BeginErrorReadLine();
-    string output = process.StandardOutput.ReadToEnd();

+   Task processTask = Task.Run(() => process.WaitForExit());
+   await processTask;
-    process.WaitForExit();

-    Console.WriteLine("Microsoft Data protection API example");
-    Console.WriteLine("---> " +  output);
}

This is a bit more secure solution at least better than storing them just like that into text file.

However remember that the data encrypted with DataProtectionScope.LocalMachine scope can be accessed aby anyone who can use your computer.

And if you decide to use DataProtectionScope.CurrentUser, it is probably a good idea to create another password protected user which will only be used to run your binary and/or provide an admin account to the necessary minimum of people.

Originally publised at my blog

SPF, DKIM and DMARC

May Meow — Fri, 31 Mar 2023 08:47:50 +0000

These are all email authentication protocols that are used to protect email domains from "spoofing" and "phishing" attacks.

SPF (Sender Policy Framework)

It is a protocol that allows a domain owner to specify which server is allowed to send emails on behalf of his domain. For example, this helps prevent spammers from using spoofed addresses by verifying that the email came from an authorized server.

Is configured as TXT record in domain DNS.

DKIM (DomainKeys Identified Mail)

It is a protocol that adds a digital signature to an email message. This protocol allows the recipient server to verify that the message was sent by an authorised server and that it was not tampered with during transmission.

The sent email is signed with a private key and the public key is published in the DNS records of the sending server's domain.

When the recipient's email server receives the signed email, it retrieves the public key from the sender's DNS records and uses it to verify the signature. If the signature is valid, it confirms that the email was not corrupted during transmission and that it was signed by an authorized sender.

This protocol must be configured in DNS records and also on the sending server.

DMARC (Domain-based Message Authentication, Reporting & Conformance)

This protocol builds on the SPF and DKIM protocols and allows the domain owner to specify how e-mail servers should handle e-mails that fail the SPF or DKIM check.

DMARC allows the domain owner to receive reports on how their domain is being used for email and also to specify the action to be taken on messages that fail verification, such as marking them as spam or rejecting them altogether.

DNARC policies are published by the domain owner in the DNS records of the domain in question.

How does it all work together?

Take spoofing attacks, this is an attack where the attacker modifies the header of an email or other piece of electronic communication to make it appear to come from a source other than the actual sender, so that the recipient thinks the message is legitimate.

SPF: The email server first checks the sender's DNS records to see if the IP address of the sending mail server is authorized to send email on behalf of this domain. If the server is not authorized, the email will likely be marked as spam or rejected altogether
DKIM: If the sending mail server has passed the SPF record check and is therefore authorized to send messages, a DKIM signature check follows. If the signature is valid, it confirms that the email has not been altered during transmission and that the sender is authorized to send emails on behalf of this domain.
DMARC: Finally, the recipient's email server still checks the DMARC policy of the sender's domain to determine what actions to take with respect to the email it received. If the DMARC policy specifies that failed SPF/DKIM verification should result in the email being rejected or marked as SPAM, the recipient's email server will take that action.

What if the sender's DNS does not contain DNS, DKIM and DMARC?

Without an SPF record, it is more difficult for email servers to verify the authenticity of emails sent from a given domain, which can lead to a higher risk of spam and phishing emails being delivered to recipients.

Without a DKIM record, emails sent from a domain will not be signed with a digital signature that can be used to verify their authenticity, making it easier for attackers to forge emails and carry out phishing attacks.

Finally, without a DMARC record, the domain owner will not be able to determine the policy on how receiving mail servers should handle emails that fail SPF and DKIM checks. This may result in legitimate emails being marked as spam or rejected, or malicious emails being delivered to recipients.

Thank's for reading!

Photo by FLY:D on Unsplash

Using reCAPTCHA with PHP and Javascript

May Meow — Sun, 18 Dec 2022 08:36:08 +0000

I had to update the page of one of my clients to use some verification before guests can submit the form because they receive many unwanted messages from there. One of the ways is using reCAPTCHA and making guests solve puzzles before they can submit the form.

Prepare

To implement reCAPTCHA on your PHP page, you will first need to sign up for an API key pair on the reCAPTCHA website. Once you have your API key pair, you can add the following code to your PHP page to display the reCAPTCHA widget:

<!-- HTML for reCAPTCHA widget -->
<div class="g-recaptcha" data-sitekey="YOUR_SITE_KEY"></div>

<!-- Your existing PHP code -->

<!-- JavaScript to render reCAPTCHA widget -->
<script src="https://www.google.com/recaptcha/api.js" async defer></script>

Replace YOUR_SITE_KEY with the site key that you obtained from the reCAPTCHA website.

After the user has completed the reCAPTCHA challenge, you can then verify the user's response on your server using the following PHP code:

// Get user's response and your site key
$response = $_POST['g-recaptcha-response'];
$secret = 'YOUR_SECRET_KEY';

// Verify the user's response
$verify = file_get_contents("https://www.google.com/recaptcha/api/siteverify?secret={$secret}&response={$response}");
$captcha_success = json_decode($verify);

if ($captcha_success->success) {
    // handle your request here
} else {
    // The user failed the reCAPTCHA challenge
    // Handle the error as appropriate
}

Replace YOUR_SECRET_KEY with the secret key that you obtained from the reCAPTCHA website.

Making reCaptcha required

By default (as implemented above) reCAPTCHA is not a required field. It allows you to send the form even if the puzzle is not solved or even if you didn't click to reCAPTCHA. This situation in my case is handled by PHP on the server but you can prevent this happen and limit requests to your server by making it required field.

To make the reCAPTCHA widget required, you can add the required attribute to the div the element that contains the widget as follows:

<div class="g-recaptcha" data-sitekey="YOUR_SITE_KEY" required></div>

This will prevent the form that contains the reCAPTCHA widget from being submitted unless the user completes the reCAPTCHA challenge.

Alternatively, you can also use JavaScript to validate the reCAPTCHA widget before the form is submitted. To do this, you can add an event listener to the form's submit event, and check if the reCAPTCHA widget has been completed. If the reCAPTCHA has not been completed, you can prevent the form from being submitted and display an error message to the user.

Here is an example of how you might do this:

<!-- HTML for reCAPTCHA widget -->
<div class="g-recaptcha" data-sitekey="YOUR_SITE_KEY"></div>

<!-- Your existing PHP code -->

<!-- JavaScript to render reCAPTCHA widget -->
<script src="https://www.google.com/recaptcha/api.js" async defer></script>

<!-- JavaScript to validate reCAPTCHA widget on form submission -->
<script>
  // Get the form element
  var form = document.getElementById('form-id');

  // Add an event listener to the form's submit event
  form.addEventListener('submit', function(event) {
    // Check if the reCAPTCHA widget has been completed
    if (!grecaptcha.getResponse()) {
      // Prevent the form from being submitted
      event.preventDefault();

      // Display an error message
      alert('Please complete the reCAPTCHA challenge to submit the form.');
    }
  });
</script>

In this example, form-id should be replaced with the id attribute of the form the element that contains the reCAPTCHA widget.

Another way to do it is by adding the following script to your header (this is the way i did it)

<script>
  // make recaptcha verified
  function validateCaptcha() {
    var response = grecaptcha.getResponse();
      if(response.length == 0) {
        alert("Please verify that you are not a robot");
        return false;
    }
    return true;
  }
</script>

Bonus: jQuery + Validate plugin

The page I needed to update used Validate plugin for jQuery.

To use reCaptcha with jQuery and Validate plugin you can use the following code

<!-- ... -->
  <script>
    $("#myForm").validate({
      submitHandler: function(form) {
        // Get the reCAPTCHA response
        var response = grecaptcha.getResponse();

        // If the response is not empty, proceed with form submission
        if (response !== "") {
          // Submit the form
          form.submit();
        } else {
          // Otherwise, display an error message
          alert("Please complete the reCAPTCHA to continue.");
        }
      }
    });
  </script>
<!-- ... -->

In the validate method, the submitHandler function is used to handle the form submission. This function checks the reCAPTCHA response to make sure it's not empty and then submits the form if the response is valid.

If you are using AJAX to send your form, do not forget to reset your reCAPTCHA or refresh (or redirect somewhere else) your page after submitting the form.

To uncheck the reCAPTCHA widget after a successful form submission, you can use the reset method provided by the reCAPTCHA API. Here is an example of how you can do this:

  <script>
    $("#myForm").validate({
      submitHandler: function(form) {
        // Get the reCAPTCHA response
        var response = grecaptcha.getResponse();

        // If the response is not empty, proceed with form submission
        if (response !== "") {
          // Submit the form
          form.submit();

          // Reset the reCAPTCHA widget
          grecaptcha.reset();
        } else {
          // Otherwise, display an error message
          alert("Please complete the reCAPTCHA to continue.");
        }
      }
    });
  </script>

As you can see is not that hard to make your public form (e.g. contact form, comment form) a little bit more secure. You can also use this on your registration forms if you did not do this till now.

The whole guide above is for pure PHP + jQuery, but it's not a problem to rewrite it for some of the frameworks. The main difference will be how you getting server requests, here is a little hint:

// Pure PHP
$response = $_POST['g-recaptcha-response'];

// CakePHP
$respone = $this->request->getData('g-recaptcha-response');

// Laravel
$respone = Input::get('g-recaptcha-response');

That's all for now. Stay safe!

Originally published at May is Coding

Photo by Olav Ahrens Røtne on Unsplash

My Workflow

May Meow — Sun, 04 Dec 2022 16:33:09 +0000

Hey, guys! Today I will show you how my workflow looks like. This is the latest version, I changed it a few times before. If you read my blog, you know that before I hosted a lot of things at my home on my server. Gradually I moved things to the cloud and now I'm trying to simplify my workflow. It's nice to manage your stuff yourself, but it takes a lot of time. Let's take a look at how I managed to do it.

I have divided it into the following categories, Programming, Storage and Deployment.

Programming

Most of my code is written in PHP, JavaScript and HTML. For programming I use VS Code editor, and for more complex things, PHPStorm from JetBrains.

I also use C# from time to time, mostly with my employer. I create this code on Visual Studio or Rider (again an application from Jetbrains) and if the applications are simpler, VS Code.

From other programming languages I use I would mention Java or GO. For these I use again applications from Jetbrains (Idea or Goland depending on the language). (I don't use these that often though).

As far as databases are concerned, my favourite application is DataGrip, but lately I have been trying TablePlus which has a quite minimalistic design and also a mobile application.

As far as the operating system is concerned, I have recently been using Linux (multiple distributions), which I really like, but since we use Windows at work and some of the applications that I create are designed for Windows in the Desktop version, so I went back to Windows.

Instead of dual-boot I use WSL v2 where I have several Linux distributions installed (like Ubuntu, Debian or Kali)

Recently I've been using Codespaces from GitHub more and more, thanks to which I can edit source code from anywhere where I have access to the Internet, for example on a tablet or mobile phone if I need to quickly edit a line.

Storage

I put all the source code I create automatically into GIT, specifically I use GitHub. Besides the GIT repository, it offers you a lot of other options like Codespaces, Docker storage and much more.

I also have the source codes stored on my own server where I host Gitea.

Code testing is also done automatically on GitHub after each push.

Apart from these, I have tried other options such as self-hosted Gitlab, which has its own CI/CD, or Gitea + Drone. I've been using GitLab for the longest time (about 5 years) but as I say I'm trying to simplify things so I can focus on work instead of managing my own server and finding solutions why things don't work.

If we talk about documentation or notes, I write them in Markdown and store them on my GitHub, or I use OneNote / Word which autosyncs with the cloud (Microsoft 365), and from there to any of my devices.

Deployment

Depending on the application, I publish them using Netlify / Vercel or Forge.

If they are static pages, which I create using Hugo, I publish them on the Web using Netlify or Vercel. This is done automatically after each push to the main branch.

I publish my PHP applications using Laravel Forge on my server which I have with Hetzner.

As the name of the service says it will work best with Laravel but it is not a problem to modify code from other frameworks to make it work the same way. I have several applications created this way in CakePHP. I have this set to manual after clicking the deploy button, but if you want you can turn on quick deploy and then it will publish the application after a push to the main branch (or another one, depending on how you set it up)

In conclusion

Only time will tell how I managed it. But now I have more time to devote to programming and less time to managing the server.

But I haven't given up everything self-hosted, I still have my own Gitea or Mastodon server.

What does your workflow look like? How much time does it take you to manage the server vs programming your applications?

If you are interested in what else I use, you can see my uses page.

Originally posted on My blog

Manage multiple git accounts

May Meow — Mon, 24 Oct 2022 19:45:32 +0000

Hi! Do you have multiple git accounts or you just using one? I have multiple and everytime I reinstall my system I trying to find how I
configured it before... (i finally wrote this together here).

Im using multiple git config file rather than multiple host names (i don't like to have somethink like git@github-work or git@github-personal).

How it's work?

First of all you need to create different folders for you personal and work projects (or more folders if you have more accounts). Into each folder
create new .gitconfig file which will looks like this one:

# ~/Work/.gitconfig.work
[user]
email = your@email
name = Your Name

[github]
user = "YourGithubName"

[core]
sshCommand = "ssh -i ~/.ssh/work.pub" # public key for your work profile

You will also need more SSH keys. I using 1Password so I copy only my public keys to the my .ssh folder.

SSH with 1Password

If you want to use 1Passowrd you need to configure ssh. Add following to your ~/.ssh/config file

Host *
    IdentityAgent ~/.1password/agent.sock

SSH With SSH-AGENT

If you want to use more traditional way you will need to configure SSH-AGENT

eval "$(ssh-agent -s)" && \
ssh-add -K ~/.ssh/<personal_key>

Then edit your ~/.ssh/config

Host *
    AddKeysToAgent yes
    UseKeychain yes
    IdentityFile ~/.ssh/<created_key>

OK now you have create your keys and gitconfig files for you profiles. Now you need to tell git to use proper config based on git repository location. Edit ~/gitconfig which will need to looks similar to this:

# ~/.gitconfig

[includeIf "gitdir:~/May/"] # include for all .git projects under May/ 
path = ~/May/.gitconfig.may

[includeIf "gitdir:~/Work/"] # include for all .git projects under Work/
path = ~/Work/.gitconfig.work

[core]
excludesfile = ~/.gitignore      # valid everywhere

You list all your configs with git config --list command.

That's all

Good! You can now clone repositories from multiple accounts based on in which folder you clonning it.

Sending Message to Mattermost With PHP and GitHub Actions

May Meow — Thu, 04 Aug 2022 08:34:00 +0000

Today I show you how you can send notifications to Mattermost with PHP and Github Actions. There are some implementations on Github Marketplace but nothing was made with PHP, there was Javascript, Go, or Python. But PHP can be used to create command-line utilities and it's very easy. Don't trust me? Come I'll show you.

Photo by Daria Nepriakhina 🇺🇦 on Unsplash

Creating new project

First of all, create a new folder for your project, mine is action-mattermost-notify. You can do this with the command as follows.

mkdir action-mattermost-notify

Now initializae new repository

# cd action-mattermost-notify
composer init

The composer will ask you for some information such as project name, author name, and email. When you are done you will have a folder structure like this one:

action-mattermost-notify
├── composer.json
├── composer.lock
├── src
└── vendor

Now You need to add some dependencies. (Here are two of them). The first one is the HTTP client and the second one is Console.

# cd action-mattermost-notify
composer require symfony/http-client
composer require symfony/console

After this step, 1st part is done. Go to next step.

Creating Console application

With the Console component is creating a new console application easy. When you finish this part your folder structure will look like follows

action-mattermost-notify
├── app.php # Added this one
├── composer.json
├── composer.lock
├── src
│   └── SendCommand.php # Added this one
└── vendor

First create app.php, which is the main file that launches your console application, and put there following content.

# app.php
require __DIR__ . '/vendor/autoload.php';

use Symfony\Component\Console\Application;

# Load version information from the composer file
# You will need to add a version tag to your composer.json
$version = json_decode(file_get_contents(__DIR__ . '/composer.json'), true);

$app = new Application('Action Mattermost Notify', $version['version']);

$app->run();

Good job! Now try to run it

php app.php

Action Mattermost Notify 1.0.0

Usage:
  command [options] [arguments]

Options:
  -h, --help            Display help for the given command. When no command is given display help for the list command
  -q, --quiet           Do not output any message
  -V, --version         Display this application version
      --ansi|--no-ansi  Force (or disable --no-ansi) ANSI output
  -n, --no-interaction  Do not ask any interactive question
  -v|vv|vvv, --verbose  Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug

Available commands:
  completion  Dump the shell completion script
  help        Display help for a command
  list        List commands

Next, you need to create a new command that will communicate with Mattermost. Go into the src folder and create SendCommand.php

# cd src
touch SendCommand.php

...and put there following content

<?php
declare(strict_types=1);

# Change namespace to your project's namespace
namespace Maymeow\ActionMattermostNotify;

use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\HttpClient\HttpClient;

class SendCommand extends Command
{
    protected static $defaultName = 'send';

    /**
     * Configure method
     *
     * @return void
     */
    public function configure(): void
    {
        $this
            ->setDescription('Send a message to Mattermost')
            ->setHelp('This command allows you to send a message to Mattermost');

        $this
            ->addArgument('message', InputArgument::REQUIRED, 'The message to send')
            ->addOption('channel', null, InputOption::VALUE_OPTIONAL, 'The channel to send the message to')
            ->addOption('username', null, InputOption::VALUE_OPTIONAL, 'The username to send the message as')
            ->addOption('icon', null, InputOption::VALUE_OPTIONAL, 'The icon to send the message with')
            ->addOption('url', null, InputOption::VALUE_OPTIONAL, 'The URL to send the message with');
    }

    /**
     * Execute method
     *
     * @param \Symfony\Component\Console\Input\InputInterface $input Input interface
     * @param \Symfony\Component\Console\Output\OutputInterface $output Output interface
     * @return int
     */
    public function execute(InputInterface $input, OutputInterface $output): int
    {
        $message = $input->getArgument('message');
        $channel = $input->getOption('channel');
        $username = $input->getOption('username');
        $icon = $input->getOption('icon');
        $url = $input->getOption('url');

        $client = HttpClient::create();

        $response = $client->request('POST', $url, [
            'body' => json_encode([
                'channel' => $channel,
                'text' => $message,
                'username' => $username,
                'icon_url' => $icon,
            ]),
            'headers' => [
                'Content-Type' => 'application/json',
            ],
        ]);

        $output->writeln($response->getContent());

        return Command::SUCCESS;
    }
}

Let me show you what are parts of this file doing

public function configure(): void

The function above, as the name says, is used to configure your command. It tells your application what argument or options this command needs, its name, and description or you can modify the handler (how you call it from command line).

public function execute(InputInterface $input, OutputInterface $output): int

Function execute is the one where all magic happens. It is used to execute your actions.

The part below is HTTP Client that calls your webhook with the POST method and sends there required information.

// SendCommand::execute()
//...
$client = HttpClient::create();
$response = $client->request('POST', $url, [
    'body' => json_encode([
        'channel' => $channel,
        'text' => $message,
        'username' => $username,
        'icon_url' => $icon,
    ]),
    'headers' => [
        'Content-Type' => 'application/json',
    ],
]);
// ...

Ok, Now register your Command to your application with $app->add(new SendCommand());. Add this to your app.php file. After this step, your file will look like this one

<?php

require __DIR__ . '/vendor/autoload.php';

use Maymeow\ActionMattermostNotify\SendCommand;
use Symfony\Component\Console\Application;

$c = json_decode(file_get_contents(__DIR__ . '/composer.json'), true);

$app = new Application('Action Mattermost Notify', $c['version']);

$app->add(new SendCommand());

$app->run();

Try to run your app again php app.php. In your response another action has been added:

Action Mattermost Notify 1.0.0
# // ...
Available commands:
  completion  Dump the shell completion script
  help        Display help for a command
  list        List commands # <--- This one as beed added

To see information about any command append --help behind that command. For example send command

php app.php send --help

Required are the message and url of your webhook.

You can obtain the webhook URL on your mattermost instance in integrations, then click on Incoming webhook then add new and provide requested information.

Sending message

When you have all you need (created webhook), you can send a meesage to the server as follows

php app.php send "Hello World from PHP commandline!" --url "https://your-mattermost.url/webhook-id"

Cool isn't it? But, I like it if I can call the application without php word as follows

`./action-mattermost-notify send "Hello World from PHP commandline!" --url "https://your-mattermost.url/webhook-id"`

Ok, Let's do this.

Packing your application to single file

In this step, you will learn how to pack your PHP application into phar. You have 2 options, read the PHP manual and do it your way, or IMO a more elegant way to use phar-composer.

First of all, you need to install it.

wget https://github.com/clue/phar-composer/releases/download/v1.4.0/phar-composer-1.4.0.phar \
&& chmod +x phar-composer-1.4.0.phar \
&& mv phar-composer-1.4.0.phar /usr/local/bin/phar-composer

To check the current version go to the releases page.

Before you can pack your app you need to make small changes in your composer file. Add "bin": ["app.php"], somewhere in composer file. This tells to phar-composer which file needs to call when execute.

Ok build it and make it executable.

phar-composer build
chmod +x action-mattermost-notify.phar

After this you can call it like follows

./action-mattermost-notify.phar

Ok, the console application is finished and now you can create a GitHub action

Creating Action

The folder structure after this part is finished will look like follows

action-mattermost-notify
├── action.yml # Added this one
├── app.php
├── composer.json
├── composer.lock
├── Dockerfile # Added this one
├── entrypoint.sh # Added this one
├── src
│   └── SendCommand.php
└── vendor

First of all, you need to automate the steps above like building phar and making it executable. You don't want to have bin files in your git repository. To do this, we use Docker in this tutorial. Create Dockerfile and put there following content:

# Dockerfile
# Folloing image has composer-phar preinstaled in it
FROM ghcr.io/maymeow/php-ci-cd/php-ci-cd:8.1.6-cs-git-psalm AS build-env

WORKDIR /app

COPY . /app

RUN composer install --no-ansi --no-dev --no-interaction --no-plugins --no-progress --optimize-autoloader --no-scripts

RUN phar-composer build && chmod +x action-mattermost-notify.phar

# Use smallest php image
FROM php:8.1.6-cli-alpine

COPY --from=build-env /app/action-mattermost-notify.phar /usr/local/bin/action-mattermost-notify

COPY --from=build-env /app/entrypoint.sh /entrypoint.sh

RUN action-mattermost-notify list

ENTRYPOINT ["/entrypoint.sh"]

The example above is a multistep build. In the production image, you will only have phar without source codes.

The second file you need to add is entrypoint.sh which runs when the image starts. Create it with the following content

#entrypoint.sh
#!/bin/sh

action-mattermost-notify send "$1" --url "$2" --channel "$3" --username "$5" --icon "$4"

At last, you need to create an action configuration file that tells Github all the required information about the action that you creating. It is called action.yml and has to be in the root directory. Create it with the following content:

# action.yml
name: 'Action Name' #change this to your action name
author: 'Action Author' # Change this to your
description: 'Action Description' # change this
branding:
  icon: 'command'
  color: 'purple'
inputs: # following are all inputs that can be used in this action
  message:
    description: 'Enter the message to send to Mattermost'
    required: true
  url:
    description: 'The URL to send the message to'
    required: true
  channel:
    description: 'Enter the channel to send the message to'
    required: false
  icon:
    description: 'Enter the icon to use for the message'
    required: false
  username:
    description: 'Enter the username to use for the message'
    required: false
runs: # How this action start? 
  using: 'docker'
  image: 'Dockerfile'
  args:
    - ${{ inputs.message }}
    - ${{ inputs.url }}
    - ${{ inputs.channel }}
    - ${{ inputs.icon }}
    - ${{ inputs.username }}

Good job! Congratulation, You are reading this to the finish. You now have your own Github action and you learned how to

create a PHP console application
how to pack it in a single Phar file
how to create Github Action with PHP

How to run it

At the very end, ill show you how you can use it. There are more options on how to call it.

Register it in the marketplace (via new release)
Call it with branch name or commit hash

If you have published it you can call it as follows

- name: Action Mattermost Notify
uses: MayMeow/action-mattermost-notify@v1 # Change this to your action
with:
  url: ${{ secrets.MATTERMOST_WEBHOOK }}
  message: "Hello world from ${{ github.repository }}"

Your action has name your-github-username/your-action-repository@version or your-github-username/your-action-repository@branch-name or your-github-username/your-action-repository@commit-hash. The last two options don't require to have action registered in the marketplace.

In the end

All source code is available on my Github: Action Mattermost notify and Mattermost Action example.

Thank you for reading this post and I hope you enjoy it.

Originally published at My Blog

You Need To Use 2FA Everywhere

May Meow — Mon, 01 Aug 2022 11:49:04 +0000

Photo by FLY:D on Unsplash

Yes! Use 2 factor authentication (2FA) everywhere and everytime it is possible. Novadays it is pretty common and almost all servicess to allow you to use some kind of 2FA.

What is 2FA?

2FA gives you to your service identification (e.g. emal/username & password) another layer to verify your identity. After logging with your username and password site will ask you to enter one time passowrd or use hardware key (its based on type 2FA you using).

It is similar to process that you had using with your bank account some time ago. Everytime you opened new account your bank provided you GRID cards with table of 36 pregenerated pins. Each grid had different ones and when you tried to make some finnancial operations bank ask you to enter pin from field A7 for example.

Types of 2FA

Most common now is using phone number where application send you TOTP token and Google authenticator. Here is good to know that Google authenticator != TOTP.

TOTP is Time-based one-time password which is computer algorithm that genarates onetime password (OTP) that uses the current time as a source of uniqueness. (Wikipeda)[https://en.wikipedia.org/wiki/Time-based_one-time_password] and Google authenticator is application (one of a kind) that is used to store and generate OTP for you. It's like Email is protocol and Thunderbird is email client that using email protocol to deliver and recieve messages.

Another solution is use push notifications where application will ask you to confirm that you want to login to your account (e.g. Microsoft authenticator or DUO Security by Cisco).

And last one is use hardware keys. After login you have to put key to usb and touch button to proced to your account. Some keys have built in biometric reader which add another lkayer to protect your account (only owner can unlock key).

Passwordless accounts

The last two are commonly used with something that is called "passwordless" account (e.g. Microsoft account), which is as name tells you account without password. After activation you will need everytime confirm notification on your phone, and your account password will be removed (at least with Microsoft account). There are some cons for this approach - RDP not working with passwordless accounts, so you will need to create another local account for using with it.

Google also allows you to use some kind of passwordless authentication however they dont remove you passowrd so in some cases you can choose to authenticate with password.

You consider this as next (higher) level of security as there is no danger of misuse of the password, since there is none.

"But May, here you have only one method of authentication". Yes, but attacker will need to have physical access to your device or to you or he need to have awesome skill in social enginereing to convince you to send him your device.

To summary this:

TOTP via SMS or authenticator apps
Push notifications
Hardware keys
Passwordless accounts - this is not 2FA in the true sense as you not using your password anymore but you need everytime confirm notification or use hardware key.

Why to use it?

It will add another layr of protection to your account, and if your password is leaked, attacker will need to have access to another security object (e.g. mobile phone, hardware key), however many companies also checking locations from where you try to log in. So even if you don't have 2FA activated atacker may not be able to login to your account but this can be easily bypassed by using VPN, he just need to know from which one country you are.

When you have enabled 2FA it is much harder to compromise your account. Attacker will need access to you 2FA device (key, backup codes, mobile phone).

Good to know

TOTP seed is hash which is used to generate your One-time password Keep it safe and never share it! Consider it as your password or key from your house.
QR Code is just another representation of TOTP seed which mobile phones can red so you don't need to enter those codes manually.

Some recommendation at the end

Google Authenticator or Authy isn't only 2FA applications, consider using applications which allow you to export seed to your TOTP to prevent loss of your data. I'm using 1Password.
Use at least 2 methods (when it is possible): Most services require to use your phone number before they allow you setup another method.
Backup code/s can be used when you lost access to you 2FA item (key, phone), keep them safe simmilar as you password and don't give them to anybody.
Use Password managers - keeping you password in some document on you computer or what is even worse - in cloud is really not a good idea!

Stay safe! ✌️

Original is Here

Introduction to PHP Enums

May Meow — Sun, 03 Jul 2022 10:02:00 +0000

PHP 8.1 finally brings enums which can be know from other programming languages like C#. It is in my opinion one of best things which came with new php version.

Enums

Prior enums you maybe used static classes like me or you have installed enum composer package. Enums can be defined with word enum instead of class following with enum name. Values are defined witch word case following name of value. Enum defined as bellow returns for each value it's number in order from 1.

enum DocumentType
{
    case order; //1
    case invoice; //2
    case orderItem; //3
}

then using is obvious

DocumentType::order //enum(DocumentType::order)

reutrn type of each case is enum(DocumentType::<case-name>). If you vant to get value of case you have to add value keyword to you call

DocumentType::order->value //1

You can also get enum from value as bellow

DocumentType::from(2) //enum(DocumentType::order)

if you try to pass to from() something that not exist in your enum it will throw \ValueError whic can be easily handled with try catch.

Backed enums

Tere are something called "backed enums" which are basically same as standard enums but you can define for each enum value (property) value and type which you like, for example

enum DocumentType: string
{
    case order = 'application/disclosure.document.order';
    case invoice = 'application/disclosure.document.invoice';
    case orderItem = 'application/disclosure.document.order-item';
}

Using is same as with normal enums but as return of value you get string that you defined instad of order number. For example:

DocumentType::order->value //application/disclosure.document.order

Using with other classes

As i said prior enums I used static classes with some defined properties like one bellow

class ImportDocumentType
{
    public static string $order = "application/disclosure.document.order";

    public static string $orderItem = "application/disclosure.document.order-item";

    public static string $invoice = "application/disclosure.document.invoice";

    public static function get(string $property): string
    {
        if (property_exists(self::class, $property)) {
            return self::$$property;
        } else {
            throw new \InvalidArgumentException("Property $property does not exist in class " . self::class);
        }
    }
}

It is much more text as you can see and it not ideal (but as example its enough). Than in class you can use it as bellow. (i use interfaces because it's simpler)

interface Document
{
    protected string $type;

    public function __construct(string $type);

    public function getType(): string;
}

Calling ImportDocumentType::$order has return type of string and returns just value of that variable. So as you can see __construct() of my class accepts any string which is not ideal, because you can put there anything. getType() function simmilary returns just string that you put there - which don't have to be just ImportDocumentType.

As someone who really love to use typed properties (not just in PHP but in other languages too), because code looks much more clean and you still know what you get in return when calling your functions, I can agree with people who tells that the PHP code is a mess. It was and I almost ditch PHP just for that, but with new version it is a lot better.

Back to my class, with enums it can looks like one bellow

interface Document
{
    protected DocumentType $type;

    public function __construct(DocumentType $type);

    public function getType(): DocumentType;
}

It is much better isnt it? And I know that $type in __construct() can only be DocumentType and nothing else. Simmilar it is when you calling getType() and you know you can only get DocumentType.

In the end

As you can see using enums is easy (you don't need to define our functions), using enums ensure that variable can be only enum and not any other string as from my example above.

Do you like new additions in PHP? I love them and I am excited what will brings us new versions of it.

Originally posted at My Blog

Photo by Crissy Jarvis on Unsplash

Uploading Files With Cake PHP and FileUpload Plugin

May Meow — Sun, 24 Oct 2021 09:19:58 +0000

I just release new version of my FileUpload plugin for CakePHP.

It will make uploading and downloading files really easi. Want to see? Continue reading.

Prerequisites

If you have existing application you can skip right to Create fileupload app.

CakePHP 4
Https server
PHP 7.x or 8
php extensions mgstring, intl, SimpleXML, PDO

For more informations check CakePHP Installation

Docker
Docker-compose

Right, only those two. I will show you ho to do it in this tutorial.

Prepare Environment

I will use for this tutorial my CakePHP starter kit, but you are ok to use your existing installation. This starter kit contains all you will need to create your app in no time. It contains:

CakePHP 4
PHP 7.4.16, witth all required extensions
Postgres
Minio (s3 storage)
Redis
Adminer

Ok so start it up, and run comands in shell as follows

mkdir fileupload-tutorial
cd fileupload-tutorial
docker run --rm --volume $(pwd):/app ghcr.io/maymeow/php-ci-cd/php-ci-cd:7.4.16-cs-1 sh -c "composer create-project --prefer-dist maymeow/cakephp-starter-kit:dev-main /app"
sudo chown -R $USER:$GID .

You can run ls -la to check if all folders are owned by you. Ok now we create our application

Create fileupload app

Installing plugin

First of all we need to install fileupload plugin and load it, run following command

docker-compose -f docker-compose.dev.yml run --rm cake-app composer require maymeow/file-upload

and load it

docker-compose -f docker-compose.dev.yml run --rm cake-app php bin/cake.php plugin load FileUpload

Creating MVC for Files

Next step is to create MVC for our files controller. For our need is enough to have table with file name and time for creating and modifiing. Create migration as follow

docker-compose -f docker-compose.dev.yml run --rm cake-app php bin/cake.php bake migration CreateFiles name:string created modified

push changes to database

docker-compose -f docker-compose.dev.yml run --rm cake-app php bin/cake.php migrations migrate

and create MVC for our files

docker-compose -f docker-compose.dev.yml run --rm cake-app php bin/cake.php bake all Files

Now is time to start our application with following command

docker-compose -f docker-compose.dev.yml up -d

Navigate to the http://127.0.0.1:8765/ on your favorite browser an you will see Welcome to CakePHP 4.2.10 Strawberry message. This is OK and or applications is now running. To open or files contriller go to http://127.0.0.1:8765/files.

Creating upload view and controller

Standardly CakePHP create controller for viewing, list, editing and adding. But it is not what we need. We want upload file to the server and this one is missing. So create it. First of all create new Modelless form

docker-compose -f docker-compose.dev.yml run --rm cake-app php bin/cake.php bake form Upload

Navigate to src/Form/UploadForm.php and edit _buildSchema as follows

protected function _buildSchema(Schema $schema): Schema
{
    return $schema->addField('file', 'string');
}

Creating view and controller for Upload form

Go to src/Controller/FilesController and add following function

public function upload()
{
    $uploadForm = new UploadForm();

    $this->set(compact('uploadForm'));
}

and create upload.php view in templates/Files with following content

/**
 * @var \App\View\AppView $this
 * @var \App\Form\UploadForm $uploadForm
 */
?>
<div class="row">
    <aside class="column">
        <div class="side-nav">
            <h4 class="heading"><?= __('Actions') ?></h4>
            <?= $this->Html->link(__('List Files'), ['action' => 'index'], ['class' => 'side-nav-item']) ?>
        </div>
    </aside>
    <div class="column-responsive column-80">
        <div class="files form content">
            <?= $this->Form->create($uploadForm, ['type' => 'file']) ?>
            <fieldset>
                <legend><?= __('Upload file') ?></legend>
                <?php
                echo $this->Form->control('file',  ['type' => 'file']);
                ?>
            </fieldset>
            <?= $this->Form->button(__('Submit')) ?>
            <?= $this->Form->end() ?>
        </div>
    </div>
</div>

Now you can navigate to http://127.0.0.1:8765/files/upload and if you see no error but Upload file form you are good to go.

Configuring upload plugin and uploading files

Next stem is load our components to the controller

public function initialize(): void
{
    parent::initialize(); // TODO: Change the autogenerated stub

    $this->loadComponent('FileUpload.Upload', [
        'fieldName' => 'file',
    ]);

    $this->loadComponent('FileUpload.Download');
}

Uploading files

Now you have loaded Uploadfile plugin's components so there is left some more thing to do. Update upload function as follows

public function upload()
{
    $uploadForm = new UploadForm();

    if ($this->request->is('post')) {
        $uploadedFile = $this->Upload->getFile($this->request);

        $file = $this->Files->newEmptyEntity();
        $file->name = $uploadedFile->getFileName();
        $this->Files->save($file);

        return $this->redirect(['action' => 'index']);
    }

    $this->set(compact('uploadForm'));
}

If everything goes right you will see your uploading file name in list of all files.

Downloading files

Create new function for downloading files in FilesController

public function download($fileName)
{
    $downloadedFile = $this->Download->getFile($fileName);

    $response = $this->response;
    $response = $response->withStringBody($downloadedFile->getFileContent());
    $response = $response->withType($downloadedFile->getFileType());

    if ($this->request->getParam('?.download') == true) {
        $response = $response->withDownload($fileName);
    }

    return $response;
}

And edit templates/Files/index.ctp

# edit line 
<td><?= h($file->name) ?></td>
# to this
<td><?= $this->Html->link($file->name, ['action' => 'download', $file->name, '?' => ['download' => false]]) ?></td>

Refresh page. This will display picture you have uploaded befor by clinking on file name. If you want to show download form instead, cahnge download to true.

S3 Support

If you want to use S3 instead of local storage, you need make some small changes for it... First of all open your app_local.php and add at the end of file following config

'S3' => [
    'version' => 'latest',
    'region'  => 'us-east-1',
    'endpoint' => 'http://cake_minio:9000',
    'use_path_style_endpoint' => true,
    'credentials' => [
        'key'    => 'minioadmin',
        'secret' => 'minioadmin',
    ],
]

Now navigate to the http://127.0.0.1:9001 and login with default creadentials, both password and username are minioadmin. In right menu go to buckets and create bucket for your needs. For this purposes i create bucket with name fileupload.tutorial.

You can check it in Object browser on sidebar.

Now let's configure our application. Update FilesController as follows:

public function initialize(): void
{
    parent::initialize(); // TODO: Change the autogenerated stub

    $this->loadComponent('FileUpload.Upload', [
        'fieldName' => 'file',
        'storagePath' => 'fileupload.tutorial', // bucket name
        'storage_type' => 's3'
    ]);

    $this->loadComponent('FileUpload.Download', [
        'storagePath' => 'fileupload.tutorial', // bucket name
        'storage_type' => 's3'
    ]);
}

Ok, That all now you have application which can upload / download files to local or S3 storage. Easy no?

Conclusion

I'm lazy person so I wanted to make it more easier (dont telling that CakePHP on itself is not easy to start) to start my applications. And with Starter kit you are good to go in few seconds and you can focus on your application.

With Fileupload plugin you can upload/download files on bot local and s3 storage literally with one line of code (dont counting configuration). I hope it will make easier for you to manage files uploading in your application to. If you find bugs please report them on FileUpload's Issue tracker, also if you have some ideas i have opened Discussions for project where you can share your ideas.

Anyway if you like this project you can contibute to it on GitHub repository which is also participating in Hacktoberfest.

Same is for CakePHP starter kit which is on Github too.

Bonus

All source codes from this tutorial are awailable here on FileUpload Tutorial Github.

Thank you for reading and have a nice day!

Originally posted on themaymeow.com blog

Docker Volume on NFS?

May Meow — Tue, 03 Aug 2021 10:03:21 +0000

No Problem. Did you know you can have your volumes on nfs server? Yes i know you can mount NFS folder on server and then on point docker volume to this folder, but i will show you
how to mount volume right with docker. Btw you can read more about docker storage on official docker documentation. As prerequisity you will need to have installed NFS server.

Now you can run docker image with volume pointed to your nfs server

docker service create -d \
    --name nfs-service \
    --mount 'type=volume,source=nfsvolume,target=/app,volume-driver=local,volume-opt=type=nfs,volume-opt=device=:/var/docker-nfs,"volume-opt=o=addr=10.0.0.10,rw,nfsvers=4,async"' \
    nginx:latest

If you want to mount nfs volume right in your docker-composer (docker-composer file version 3.2 and up is required) then you can do it as follows:

version: "3.9"

# ...

services:
  wordpress-app:
    # ...
    volumes:
      - wordpress:/var/www/html

volumes:
  wordpress:
    driver: local
    driver_opts:
      type: nfs
      o: addr=server_ip,rw,vers=4.1
      device: ":/path/to/nfs/folder"

device: is full path to your folder, it coresponds with path in your server's nfw export config
addr=server_ip,rw,vers=4.1: Change server_ip to your server ip address, rw gives container both read and write access to the nfs mount, vers tells to docker which verison of NFS to use.

If your container needs root access to the folder do not forget add no_root_squash to you exports as server by default translating all rood operations on remote server to the non privileged user because of security.

For what it is all good? For sharing data between containers. For example if you know Gitlab and their gitlab-runner. You can make it autoscale or you can have them more. When you do this you will need to share build chache otherwise you will run to errors when you trying access cache form runner that is diferrent than that one which wrote cache file ;)

I recommend this to use for storing files like images or website files (like on wordpress) but not database. You newer know how database server reacts when you mount will disconnect, it will cause datafile corruption and you server hang on start. If you need more than one Database server with same date then you will need configure replication.

Originally posted on themaymeow.com
Thats all. Bye!