DEV Community: AL EMRAN

How PHP-FPM Works: A Deep Dive into FastCGI Process Management

AL EMRAN — Sun, 29 Dec 2024 12:27:35 +0000

PHP-FPM (FastCGI Process Manager) is a cornerstone in modern PHP deployments, providing substantial performance enhancements over traditional CGI implementations. This article explores the inner workings of PHP-FPM, its architecture, lifecycle, and key mechanisms, supported with code snippets and references.

Core Architecture

PHP-FPM employs a master-worker process model, where a single master process orchestrates multiple worker processes. This structure ensures efficient resource utilization and robust performance.

Master Process

The master process oversees critical tasks such as:

Initialization and Resource Management

Parsing global configurations
Setting up shared memory segments
Creating worker pools
Allocating system resources

Worker Pool Management

Spawning and monitoring workers
Managing worker lifecycle events
Enforcing configuration settings

Signal Handling

Managing signals like SIGTERM, SIGHUP
Coordinating graceful shutdowns
Reloading configurations dynamically

Worker Processes

Worker processes execute PHP scripts. Each worker:

Processes incoming FastCGI requests
Executes PHP scripts in isolation
Updates shared memory (scoreboard) with its status
Terminates after reaching defined thresholds

Pseudo Code for Master-Worker Model

// Master Process Setup
initialize_resources();      // Load shared memory, configurations
load_configuration();        // Parse PHP-FPM pool configurations
create_worker_pools();       // Create pools as per configuration

// Spawn Workers
while (current_children < min_children) {
    fork_child_process();    // Create a child worker
}

// Master Event Loop
while (true) {
    if (signal_received()) {
        handle_signal(signal_type);
        if (signal_type == SIGTERM) {
            terminate_all_children();
            cleanup_resources();
            exit_master();
        } else if (signal_type == SIGHUP) {
            reload_configuration();
        }
    }

    if (worker_exited()) {
        log_worker_exit();
        if (current_children < max_children) {
            fork_child_process();
        }
    }

    adjust_worker_pool_based_on_load();
}

Process Lifecycle

Startup Sequence

Master Process Initialization

Loads configurations
Sets up shared memory and sockets
Spawns initial workers

Worker Initialization

Configures runtime environment
Begins accepting requests

Request Processing

Web server forwards FastCGI requests to PHP-FPM.
Master process assigns the request to an available worker.
Worker:
- Processes the PHP script
- Updates the scoreboard with its status
- Returns the response to the client

Dynamic Process Management

PHP-FPM can adjust the number of worker processes dynamically:

if (dynamic_mode_enabled()) {
    if (current_load_high() && current_children < max_children) {
        fork_child_process();
    } else if (current_load_low() && current_children > min_children) {
        terminate_idle_worker();
    }
}

Shared Memory and Scoreboard

PHP-FPM uses shared memory for inter-process communication, enabling efficient monitoring and management.

Scoreboard Structure

Tracks worker statuses (idle, busy, etc.)
Records request statistics
Facilitates health checks

Synchronization

Uses locks to prevent race conditions
Ensures atomic updates

Shared Memory Pseudo Code

function update_scoreboard() {
    acquire_lock();                    // Lock shared memory for safe updates
    update_worker_status();            // Mark worker as idle/busy
    release_lock();                    // Unlock shared memory
}

Configuration and Optimization

Key Configuration Parameters

pm: Defines process management style (static, dynamic, ondemand)
pm.max_children: Maximum worker processes
pm.start_servers: Initial worker count
pm.min_spare_servers: Minimum idle workers
pm.max_spare_servers: Maximum idle workers

Performance Optimization

Process Management Strategy

Static: Fixed number of workers
Dynamic: Adjusts workers based on load
OnDemand: Spawns workers as needed

Resource Limits

Memory limits per worker
Maximum requests per worker
Idle timeout settings

Example Configuration File

[www]
pm = dynamic
pm.max_children = 50
pm.start_servers = 10
pm.min_spare_servers = 5
pm.max_spare_servers = 20
pm.max_requests = 500

Error Handling and Recovery

PHP-FPM ensures stability through robust error handling:

Worker Recovery

Respawns failed workers automatically
Logs worker exits and failures
Maintains minimum worker count

Master Process Monitoring

Tracks worker health
Handles unexpected terminations
Supports graceful restarts

Error Recovery Pseudo Code

if (worker_exited_unexpectedly()) {
    log_error("Worker process exited unexpectedly");
    if (current_children < max_children) {
        fork_child_process();
    }
}

Limitations of PHP-FPM in High-Concurrency Scenarios

While PHP-FPM is a robust solution for most PHP applications, it faces limitations when handling high levels of concurrency:

Process-Based Architecture
- PHP-FPM relies on a process-per-request model, where each request is handled by a separate worker process.
- This approach can lead to high memory consumption as each worker requires its own memory space, regardless of the actual resource requirements of the request.
Resource Contention
- Managing large numbers of processes introduces overhead due to context switching and memory management.
- This can degrade performance under heavy load compared to event-driven architectures.
Scalability Constraints
- Unlike event-driven models like Node.js or Nginx, PHP-FPM struggles to efficiently handle thousands of simultaneous requests.
- As the number of workers increases, the server's ability to maintain consistent performance diminishes.
Limited Parallelism
- The process-based model inherently limits the level of parallelism achievable compared to asynchronous solutions.

Considerations for High-Concurrency Workloads

For workloads requiring high concurrency, consider integrating PHP with event-driven models or adopting solutions like ReactPHP or Swoole.
Optimize PHP-FPM configurations to balance performance and resource usage.

Conclusion

PHP-FPM’s efficient process management makes it an indispensable tool for high-performance PHP applications. However, understanding its architecture, benefits, and limitations is essential for optimizing PHP workloads in diverse environments.

References

Follow me on Twitter

1.1 Ins & outs of ES6(JavaScript) Import with Realworld Example and Demo Project.

AL EMRAN — Wed, 25 Sep 2024 10:54:06 +0000

Follow me on Twitter

Introduction

ES6 (ECMAScript 2015) introduced a standardized module system to JavaScript, revolutionizing how we organize and share code. In this article, we'll explore the ins and outs of ES6 imports, providing real-world examples and a demo project to illustrate their power and flexibility.

Basic Import Syntax
Named Exports and Imports
Default Exports and Imports
Mixing Named and Default Exports
Renaming Imports
Importing All Exports as an Object
Dynamic Imports
Real-world Examples
Demo Project: Task Manager
Best Practices and Tips
Conclusion

Basic Import Syntax

The basic syntax for importing in ES6 is:

import { something } from './module-file.js';

This imports a named export called something from the file module-file.js in the same directory.

Named Exports and Imports

Named exports allow you to export multiple values from a module:

// math.js
export const add = (a, b) => a + b;
export const subtract = (a, b) => a - b;

// main.js
import { add, subtract } from './math.js';

console.log(add(5, 3));      // Output: 8
console.log(subtract(10, 4)); // Output: 6

Default Exports and Imports

Default exports provide a main exported value for a module:

// greet.js
export default function greet(name) {
  return `Hello, ${name}!`;
}

// main.js
import greet from './greet.js';

console.log(greet('Alice')); // Output: Hello, Alice!

Mixing Named and Default Exports

You can combine named and default exports in a single module:

// utils.js
export const VERSION = '1.0.0';
export function helper() { /* ... */ }

export default class MainUtil { /* ... */ }

// main.js
import MainUtil, { VERSION, helper } from './utils.js';

console.log(VERSION);  // Output: 1.0.0
const util = new MainUtil();
helper();

Renaming Imports

You can rename imports to avoid naming conflicts:

// module.js
export const someFunction = () => { /* ... */ };

// main.js
import { someFunction as myFunction } from './module.js';

myFunction();

Importing All Exports as an Object

You can import all exports from a module as a single object:

// module.js
export const a = 1;
export const b = 2;
export function c() { /* ... */ }

// main.js
import * as myModule from './module.js';

console.log(myModule.a);  // Output: 1
console.log(myModule.b);  // Output: 2
myModule.c();

Dynamic Imports

Dynamic imports allow you to load modules on demand:

async function loadModule() {
  const module = await import('./dynamicModule.js');
  module.doSomething();
}

loadModule();

Real-world Examples

React Components:

// Button.js
import React from 'react';

export default function Button({ text, onClick }) {
  return <button onClick={onClick}>{text}</button>;
}

// App.js
import React from 'react';
import Button from './Button';

function App() {
  return <Button text="Click me" onClick={() => alert('Clicked!')} />;
}

Node.js Modules:

// database.js
import mongoose from 'mongoose';

export async function connect() {
  await mongoose.connect('mongodb://localhost:27017/myapp');
}

// server.js
import express from 'express';
import { connect } from './database.js';

const app = express();

connect().then(() => {
  app.listen(3000, () => console.log('Server running'));
});

Demo Project: Task Manager

Let's create a simple task manager to demonstrate ES6 imports in action:

// task.js
export class Task {
  constructor(id, title, completed = false) {
    this.id = id;
    this.title = title;
    this.completed = completed;
  }

  toggle() {
    this.completed = !this.completed;
  }
}

// taskManager.js
import { Task } from './task.js';

export class TaskManager {
  constructor() {
    this.tasks = [];
  }

  addTask(title) {
    const id = this.tasks.length + 1;
    const task = new Task(id, title);
    this.tasks.push(task);
    return task;
  }

  toggleTask(id) {
    const task = this.tasks.find(t => t.id === id);
    if (task) {
      task.toggle();
    }
  }

  getTasks() {
    return this.tasks;
  }
}

// app.js
import { TaskManager } from './taskManager.js';

const manager = new TaskManager();

manager.addTask('Learn ES6 imports');
manager.addTask('Build a demo project');

console.log(manager.getTasks());

manager.toggleTask(1);

console.log(manager.getTasks());

To run this demo, you'll need to use a JavaScript environment that supports ES6 modules, such as Node.js with the --experimental-modules flag or a modern browser with a bundler like webpack or Rollup.

Best Practices and Tips

Use named exports for multiple functions/values, and default exports for main functionality.
Keep your modules focused and single-purpose.
Use consistent naming conventions for your files and exports.
Avoid circular dependencies between modules.
Consider using a bundler like webpack or Rollup for browser-based projects.
Use dynamic imports for code-splitting and performance optimization in large applications.

Conclusion

ES6 imports provide a powerful and flexible way to organize JavaScript code. By understanding the various import and export syntaxes, you can create more modular, maintainable, and efficient applications. The demo project and real-world examples provided here should give you a solid foundation for using ES6 imports in your own projects.

Remember to always consider the specific needs of your project when deciding how to structure your modules and imports. Happy coding!

Why we shifted from Node JS( Adonis JS & Nuxt JS) to Laravel for refactoring uihut.com

AL EMRAN — Mon, 03 Apr 2023 07:58:33 +0000

UIHUT is a platform that provides design and coding resources for developers, entrepreneurs, and designers. As the platform grows and evolves, we have decided to refactor our system using the Laravel Ecosystem. Laravel is a popular PHP framework that has gained a lot of popularity in recent years, and it provides a robust and reliable foundation for building web applications.
In this article, we will share the reasons why we chose to shift from Node JS (Adonis JS and Nuxt JS) to Laravel for refactoring UIHUT.

Here are main reasons:

Ready Authentication System
Almost Ready Social Login system
Ready Queue System with UI with Horizon
Awesome testing system for frontend and api with Dusk and Pestphp
Good Websocket Backend with Laravel Websocket and broadcast
Laravel Inertia JS is fantastic tool for SSR and hydration with - React JS or Vue JS
Awesome Laravel Eloquent Model
Nice Code formatter with Laravel Pint
Code Static Analysis with LaraStan
Fantastic Laravel Telescope for deeply debugging application
Laravel Debugbar

- Ready Authentication System

Laravel provides an out-of-the-box authentication system that can be easily set up with just a few commands. This system is secure, reliable, and follows best practices for password hashing and user authentication. With Laravel's built-in authentication scaffolding, we were able to quickly and easily set up user registration and login functionality for our application.

For example, if we wanted to create a simple registration form with fields for name, email, and password, we might have to write our own middleware to handle form validation and authentication in Node JS. However, with Laravel, we can simply generate the authentication scaffolding with the make:auth command, and Laravel will automatically generate the necessary views, controllers, and routes for us.

This not only saves us time and effort, but it also ensures that our authentication system is secure and reliable. Additionally, Laravel provides many customization options for the authentication system, so we can tailor it to fit our specific needs.

- Almost Ready Social Login system

Another factor that led us to choose Laravel for our refactoring project was its built-in social authentication features. Social login is becoming increasingly popular as it allows users to quickly and easily sign up or log in to a website using their existing social media accounts such as Facebook, Google, or Twitter.

Laravel Socialite supports many popular social networks, including Facebook, Twitter, Google, LinkedIn, and GitHub. With just a few lines of code, we were able to set up social authentication for our UIHUT application, saving us time and effort while providing a seamless user experience for our users.

*** You May like Ezytor:

- Ready Queue System with UI with Horizon

One of the main reasons we chose Laravel for refactoring UIHUT is its ready-to-use queue system with a beautiful UI called Horizon.

In UIHUT, we have many background jobs that need to be processed efficiently without slowing down the main application. Laravel's queue system provides an elegant solution to this problem by allowing us to handle time-consuming tasks in the background, freeing up resources for other critical operations.

Using Laravel's queue system is very easy. We can define jobs as classes and dispatch them to be processed by a worker. Laravel comes with several ready-made queue drivers, including a database driver that allows us to store jobs in a database table.

What makes Laravel's queue system even more powerful is the inclusion of Horizon, a beautiful dashboard that provides real-time monitoring of queues and jobs. With Horizon, we can easily see what jobs are currently running, how long they take to complete, and how many jobs are waiting to be processed.

Overall, Laravel's queue system with Horizon gives us a powerful toolset to manage background jobs efficiently.

- Awesome testing system for frontend and api with Dusk and Pestphp:

Dusk is Laravel's official browser testing tool that allows us to simulate user interactions with our application's frontend. We can write expressive and readable tests using Laravel's fluent syntax and assertions to ensure that our frontend behaves as expected.

On the other hand, Pestphp is a modern and elegant testing framework that provides a developer-friendly syntax for writing tests for our application's API. Pestphp's syntax is clean and easy to read, making it accessible to developers of all levels of experience.

With Dusk and Pestphp, we were able to create a comprehensive testing suite that covered both our frontend and API, ensuring that our application was thoroughly tested and reliable.

- Good Websocket Backend with Laravel Websocket and broadcast

Laravel offers an excellent backend for real-time communication with its WebSockets (❤️🙏 beyondcode ) and broadcasting capabilities. With Laravel WebSockets, we can easily set up a WebSocket server and handle real-time events like user notifications, chat messages, and other updates. The broadcasting system provides a unified API to send events to different broadcasting drivers like Pusher, Redis, and even WebSocket server.

In our UIHUT project, we needed to have real-time updates on various pages, and Laravel's broadcasting and WebSocket capabilities allowed us to easily achieve this functionality. We were able to create a seamless user experience that keeps users engaged and informed with minimal latency.

Additionally, Laravel's WebSockets and broadcasting system come with built-in support for authentication and authorization, allowing us to secure WebSocket connections and broadcasting channels with ease. Overall, Laravel's WebSockets and broadcasting system offer a robust solution for real-time communication needs in web applications.

- Laravel Inertia JS is fantastic tool for SSR and hydration with - React JS or Vue JS

Laravel Inertia JS is another reason why we chose Laravel for refactoring UIHUT. Inertia is a fantastic tool that provides a seamless integration of server-side rendering (SSR) with client-side single-page applications (SPA) like React JS or Vue JS. It allows us to build modern web applications without having to compromise on the benefits of SSR.

With Inertia, we can write our frontend code using the familiar syntax of React or Vue, but still have the benefits of SSR for improved performance and SEO. Inertia also allows us to easily pass data between the frontend and backend, which is especially useful when working with complex user interfaces.

In addition, Inertia provides a great developer experience. It allows us to write frontend code in a modern framework like React or Vue, but still use Laravel's powerful backend features like Eloquent models, Blade templates, and route helpers.

Overall, Inertia JS is a fantastic tool that allows us to build modern, high-performing web applications while leveraging the strengths of both server-side and client-side rendering.

-Awesome Laravel Eloquent Model

Laravel's Eloquent Model is one of the main reasons why we chose Laravel for refactoring UIHUT. Eloquent is an ORM (Object-Relational Mapping) system that allows us to interact with the database using PHP objects instead of writing raw SQL queries.

With Eloquent, we can easily define our database tables as PHP classes, and then manipulate data by creating and modifying objects based on those classes. This makes it easier to read, write, and maintain database code, as well as reducing the risk of SQL injection attacks.

In addition, Eloquent provides a variety of helpful features, such as model relationships, query scopes, and eager loading. These features make it easier to work with complex data structures and improve the overall performance of the application.

-Nice Code formatter with Laravel Pint

Laravel Pint is a package that provides an easy and configurable way to format your PHP code according to the PSR-2 coding standard. This package integrates with Laravel's command-line interface, Artisan, allowing you to easily format your code using the command line.

Pint comes with sensible default settings, but you can also customize the formatting to fit your team's coding standards. This makes it a great tool for maintaining a consistent code style across your entire codebase.

Using Pint is as simple as running the php artisan pint:fix command in your terminal. This command will automatically format your PHP files according to the PSR-2 coding standard, making your code more readable and maintainable.

In addition to formatting your code, Pint can also check your code for compliance with the PSR-2 coding standard using the php artisan pint:check command. This can help you catch coding style issues early, before they become a problem in your production code.

Overall, Laravel Pint is a fantastic tool for maintaining a consistent and readable code style across your Laravel application.

-Code Static Analysis with LaraStan

Code static analysis is the process of evaluating the codebase for potential issues and vulnerabilities without actually executing the code. It is an important aspect of software development as it helps in identifying potential issues early on in the development process, allowing developers to fix them before they cause any major problems.

Laravel offers a fantastic tool for code static analysis called LaraStan. LaraStan is a static analysis tool that analyzes your Laravel codebase and provides insights into any issues or vulnerabilities that it finds. Some of the issues that LaraStan can detect include unused variables, undefined functions, and type mismatches.

One of the key advantages of LaraStan is that it integrates seamlessly with Laravel and can be easily integrated into your existing development workflow. You can run LaraStan as part of your CI/CD pipeline, ensuring that your codebase is analyzed and any issues are identified before your code is deployed.

Overall, the use of LaraStan can help improve the quality of your codebase and make it more robust and secure. By using a code static analysis tool like LaraStan, you can identify and fix issues early on in the development process, which can save time and money in the long run.

-Fantastic Laravel Telescope for deeply debugging application

Laravel Telescope is a powerful debugging tool that provides insight into the requests coming to the application, database queries, logs, and more. It is a convenient and elegant way to debug Laravel applications, allowing developers to track and debug errors in real-time. Telescope provides an easy-to-use dashboard that displays various statistics and data about the application, allowing developers to quickly identify and resolve any issues.

One of the most useful features of Laravel Telescope is its ability to display detailed information about each request. This includes the response time, status code, and any exceptions that were thrown during the request. This information is invaluable for debugging performance issues and identifying the root cause of any errors.

Telescope also provides a comprehensive view of all database queries that are executed by the application, including their duration, the number of rows affected, and the exact SQL statements that were executed. This allows developers to quickly identify slow or inefficient queries and optimize them for better performance.

In addition to its core functionality, Laravel Telescope is also highly customizable. Developers can easily create custom views and notifications to track specific application events and errors, making it a versatile tool that can be adapted to the unique needs of any project.

-Laravel Debugbar

Laravel Debugbar is a package that provides a simple way to debug Laravel applications. It adds a debug bar to the bottom of the application, displaying information about the current request and response, database queries, and other useful information.

The package provides a lot of features such as a timeline of the current request, displaying all the executed queries, including the time it took to execute them, detailed information about the current view, including all the variables passed to it, the number of database queries, the time it took to execute them, and much more.

Laravel Debugbar is incredibly useful when developing Laravel applications, as it provides an easy way to see what is happening under the hood. It allows developers to quickly identify and fix issues, saving time and effort. The package is easy to install and configure, and it works seamlessly with Laravel.
Overall, Laravel Debugbar is a great tool for any Laravel developer.

Setup GoAccess for Caddy server in Ubuntu/Linux with Docker and access over domain/sub-domain

AL EMRAN — Sun, 02 Apr 2023 01:20:42 +0000

Follow me on Twitter

GoAccess is a powerful web log analyzer that generates real-time web traffic statistics.

In this article, I'll show you how to set up GoAccess on Ubuntu/Linux and access the report over a domain/sub-domain. Whether you're using Apache, Nginx, or any other web server, you can use the same approach (I've used Caddy in this tutorial). So, let's get started!

Prerequisites

Before we start, make sure you have the following prerequisites installed:

Docker
Docker Compose
Caddy (or any other web server you prefer)

Step 1: Create directories for GoAccess

First, create/ensure two directories on your Ubuntu/Linux machine to store the log files and the HTML report generated by GoAccess. Run the following commands:

#sudo mkdir /var/log/caddy - caddy server will create the dir.
sudo mkdir /var/www/goaccess

Step 2: Create a Docker Compose file

Next, create a Docker Compose file named "docker-compose.yml" in any directory of your choice with the following content:

version: '3'
services:
  goaccess:
    image: allinurl/goaccess:latest
    volumes:
      - "/var/log/caddy:/var/log/caddy:ro"
      - "/var/www/goaccess:/var/www/goaccess:rw"
    ports:
      - "7890:7890"
    command: "/var/log/caddy/access.log --log-format=CADDY -o /var/www/goaccess/index.html --real-time-html --ws-url=wss://sub.domain.com:443/ws --port=7890"

This Docker Compose file defines a service named "goaccess" using the official GoAccess Docker image. The "volumes" section sets up two bind mounts that map the directories we created in step 1 to the corresponding directories inside the container. The first mount is read-only and maps the Caddy access logs to the "/var/log/caddy" directory inside the container. The second mount is read-write and maps the directory where we want to generate the HTML report to the "/var/www/goaccess" directory inside the container.

The "ports" section maps port 7890 on the host to port 7890 inside the container. This allows us to access the GoAccess report using a web browser.

The "command" section specifies the command to run when the container starts(More). In this case, we're telling GoAccess to analyze the Caddy access logs using the CADDY log format, generate an HTML report in real-time, and serve it over a WebSocket connection to the specified URL.

Step 3: Create a Caddy server block

Now, create a Caddy server block in the Caddyfile that proxies WebSocket traffic from the specified path "/ws" to the GoAccess container running on localhost at port 7890. Run the following command to open the Caddyfile:

sudo nano /etc/caddy/Caddyfile

Then add the following server block:

sub.domain.com {
    root * /var/www/goaccess

        # Enable the static file server.
        file_server

  reverse_proxy /ws localhost:7890
}

This server block specifies how to serve traffic to the domain/sub-domain "sub.domain.com" and how to proxy WebSocket traffic to the GoAccess container running on localhost at port 7890.

Step 4: Start the GoAccess container

Now we can start the GoAccess container using Docker Compose. Run the following command:

sudo docker-compose up -d

This command will start the GoAccess container in detached mode, which means it will run in the background.

Step 5: Access the GoAccess report

Finally, you can access the GoAccess report by visiting the domain/sub-domain "sub.domain.com" on the configured port 7890. You should see the real-time web traffic statistics in your browser.

Conclusion

Congratulations, you have successfully set up GoAccess in Ubuntu/Linux with Docker and real-time access over domain/sub-domain! With this setup, you can monitor and analyze the web traffic to your website in real-time and make informed decisions to improve its performance.

Setup Redis Replica in Ubuntu/Linux

AL EMRAN — Thu, 09 Mar 2023 21:30:57 +0000

Follow me on Twitter

Redis is a powerful in-memory database that can handle a huge volume of data at high speeds. However, as your data grows, you may find that your Redis instance is struggling to keep up. This is where Redis replication comes in.

Redis replication allows you to scale your Redis database horizontally, without downtime. By configuring a replica server, you can create a copy of your master server that automatically updates itself whenever changes are made to the master. This means you can handle more read traffic and improve your database's fault tolerance.

Setting up Redis replication is easy. First, configure your master server with a password and a unique identifier. Then, create a replica server and use the replicaof command to specify the IP address and port number of the master server. Redis will handle the rest, automatically replicating data to the replica server in real-time.

With Redis replication, you can handle more traffic and keep your database running smoothly, all without downtime. So why not give it a try and see how it can improve your Redis performance?

setup Steps:

--Run

 nano /etc/redis/redis.conf

--Uncomment ‘requirepass’ and set a password like👇

  requirepass [password]

--restart redis

--Run

  nano /etc/redis/redis.conf

--Uncomment ‘replicaof’, 'masterauth' and set value like👇

  replicaof [master-server-private-ip] 6379  
  masterauth [master-requirepass]

restart redis

--Finally Run:

redis-cli
AUTH <master-requirepassword>
info replication

Verify: ss -antpl | grep redis

Done 😃 Follow me On Twitter

AL EMRAN
CTO at Besnik

Data Transfer Object (DTO) in Laravel

AL EMRAN — Sat, 28 Jan 2023 01:38:39 +0000

Follow me on Twitter

Understanding DTOs in Modern PHP Applications: A Comprehensive Guide

Introduction

In modern PHP applications, particularly in systems like Doplac CRM, Data Transfer Objects (DTOs) play a crucial role in maintaining clean, maintainable, and type-safe code. This article explores the concept of DTOs, their benefits, and practical implementation strategies in PHP applications.

What is a DTO?

A Data Transfer Object (DTO) is a design pattern that encapsulates data for transfer between different layers of your application. Think of it as a specialized container that safely carries data across boundaries in your system, much like how a shipping container standardizes the transport of goods across different modes of transportation.

Why Should You Use DTOs?

1. Type Safety and Transparent Data Definition

DTOs provide a robust type system that catches errors at compile-time rather than runtime. By explicitly defining data types for each property, you create a contract that both developers and IDEs can understand and validate.

// Without DTO - Prone to errors
function processUser($data) {
    $name = $data['name'];  // What if 'name' doesn't exist?
    $email = $data['email']; // What if it's not a valid email?
}

// With DTO - Type-safe and clear
function processUser(UserDto $data) {
    $name = $data->name;    // IDE autocompletion works
    $email = $data->email;  // Property is guaranteed to exist
}

2. Error Prevention and Code Clarity

DTOs act as a safeguard against common programming mistakes by providing:

Clear property definitions that IDEs can autocomplete
Type hints that prevent passing incorrect data types
Centralized validation rules
Explicit documentation of expected data structures

3. Clean and Maintainable Code

DTOs contribute to clean code principles by:

Separating data structure from business logic
Providing a single source of truth for data schemas
Making code intentions clear through explicit property definitions
Enabling easier code navigation and refactoring

4. Enhanced Security Through Type Hinting

Modern PHP's type system, when used with DTOs, provides an additional layer of security:

Runtime type checking prevents injection of unexpected data types
Validation can be enforced at the DTO level
Input sanitization can be centralized in the DTO

5. Performance Optimization

DTOs can improve application performance by:

Reducing database queries through selective data transfer
Minimizing network payload by including only necessary fields
Enabling easy caching of data objects

6. Improved Testability

DTOs make testing more straightforward and reliable:

Easy to mock for unit tests
Clear separation of concerns
Predictable data structures for assertions

Practical Implementation

Basic DTO Implementation

Here's a basic implementation that showcases type safety and validation:

use Illuminate\Http\Request;

class UserDto
{
    public function __construct(
        public readonly string $name,
        public readonly string $email,
        public readonly ?string $address
    ) {}

    public static function fromRequest(Request $request): self
    {
        return new self(
            name: $request->input('name'),
            email: $request->input('email'),
            address: $request->input('address'),
        );
    }
}

Advanced DTO with Validation

This implementation includes validation and error handling:

use Illuminate\Http\Request;
use Illuminate\Validation\ValidationException;

class UserDto
{
    public function __construct(
        public readonly string $name,
        public readonly string $email,
        public readonly ?string $address,
    ) {}

    public static function fromRequest(Request $request): self
    {
        $validated = $request->validate([
            'name' => ['required', 'string', 'max:100'],
            'email' => ['required', 'email', 'max:200'],
            'address' => ['nullable', 'string', 'max:500'],
        ]);

        return new self(
            name: $validated['name'],
            email: $validated['email'],
            address: $validated['address'] ?? null,
        );
    }
}

Best Practices and Recommendations

Keep DTOs Immutable: Use readonly properties in PHP 8.1+ to prevent accidental modifications.
Avoid Complex Logic: DTOs should primarily handle data transfer and basic validation.
Use Named Arguments: They make DTO instantiation more readable and less error-prone.
Don't Rely on External Packages: Native PHP features are usually sufficient for implementing DTOs.
Document Your DTOs: Use PHPDoc to describe properties and their purposes.

Practical Usage Example

// Controller
public function createUser(Request $request)
{
    $userDto = UserDto::fromRequest($request);

    // DTO guarantees type safety and data validity
    $user = $this->userService->createUser($userDto);

    return response()->json($user);
}

// Service
public function createUser(UserDto $dto): User
{
    // Safely access validated and typed properties
    return User::create([
        'name' => $dto->name,
        'email' => $dto->email,
        'address' => $dto->address,
    ]);
}

Conclusion

DTOs are more than just data containers – they're a powerful tool for maintaining code quality, ensuring type safety, and improving application architecture. While it might seem like extra work initially, the benefits in terms of code maintenance, error prevention, and developer experience make them invaluable in modern PHP applications.

Thank you for your time to read the article.

You can Follow me on Twitter

Our Products:

Doplac CRM

1.2 WordPress Smart Coding Tips | Schedule Event / scheduled tasks

AL EMRAN — Wed, 17 Nov 2021 16:11:42 +0000

Normally in WordPress plugin development, we declare a scheduled event like the following.

register_activation_hook( __FILE__, 'my_plugin_activation_event' );

function my_plugin_activation_event() {
    if ( ! wp_next_scheduled( 'my_plugin_activation_event' ) ) {
        wp_schedule_event( time(), 'daily', 'my_plugin_activation_event' );
    }
}

register_deactivation_hook( __FILE__, 'my_plugin_deactivation_event' );

function my_plugin_deactivation_event() {
    wp_clear_scheduled_hook( 'my_plugin_deactivation_event' );
}

We use this type of code in many places.

Problem is that - This code is not re-usable.

We can create a class for reuse.

Let's Start

Create a class or global functions file

a. First create a class name Schedule

namespace MyPlugin\Utilities;

class Scheduler {

}

b. Then add a method name add

public static function add( $hook, $callback, $recurrence = 'daily', $start_time = null ) {
        if ( ! wp_next_scheduled( $hook ) ) {
            if(!$start_time) $start_time = time();
            wp_schedule_event( $start_time, $recurrence, $hook );
        }

     add_action( $hook, $callback );
 }

** $hook: hook name for the event.
** $callback: callback function or array for add action of our event hook.
** $recurrence: How often the event should subsequently recur. See wp_get_schedules() for accepted values. Default id 'daily'
** $start_time: event first starting time. You can pass your desired time.

c. Then we need to remove/clean our event.
For that let's create a method for removing events.

  public static function delete($hook){
      wp_clear_scheduled_hook($hook);
  }

Uses

Schedule::add('my-custom-schedule-event', [$this, 'event_handler']);

Schedule::delete('my-custom-schedule-event');

OR you can create global functions as like previous methods.

AL EMRAN
Github

For Creating Awesome Structured PSR Based Plugin:
PluginMaster, a WordPress plugin development framework

1.1 WordPress Smart Coding Tips | Escaping & translation

AL EMRAN — Sun, 14 Nov 2021 04:16:35 +0000

Get $100 Digitalocean credit

When we develop WordPress plugin/theme, we need to use translatable function(gettextFunctions) and also escaping text. In WordPress have some functions for scaping and translating text. like (), esc_html(), _e(), esc_html_e()

We declare those functions like.

__('Hello Awesome WordPress', 'my-plugin-text-domain');

But problem is that we declare those functions many places with our text domain it's repeating same text again and again and if we need to change our text domain then need to change all files where declared those functions.

Let's try to solve the problem.

Create a file in your plugin/theme for global function declaring. file name like: global-functions.php
declaring following functions:

1

if ( !function_exists( 'mp_text' ) ) {
    function mp_text( $text, $fn = '__' ) {
        return $fn( $text, 'my-plugin-text-domain' );
    }
}

*** This function will return translated text with __() function but you can pass any function related to same purpose.
*** mp is my plugin short name. Add sort prefix of your plugin/theme name.
*** you can declare the function with your desired name but must use a sort prefix.

2

if ( !function_exists( 'mp_text_p' ) ) {
    function mp_text_p( $text, $fn = '_e' ) {
        $fn( $text, 'my-plugin-text-domain' );
    }
}

*** This function will print translated text with _e() function but you can pass any function related to same purpose.
*** mp is my plugin short name. Add sort prefix of your plugin/theme name.

3

if ( !function_exists( 'mp_title' ) ) {
    function sep_title( $text, $fn = 'esc_html__' ) { 
         return $fn( $text, 'my-plugin-text-domain' ); 
    }
}

*** This function will return translated text with html escaping with esc_html__() function but you can pass any function related to same purpose.
*** You can declare the function with your desired name but must use a sort prefix.

4

if ( !function_exists( 'mp_title_p' ) ) {
    function sep_title_p( $text, $fn = 'esc_html__' ) { 
         echo $fn( $text, 'my-plugin-text-domain' ); 
    }
}

*** This function will print translated text after html escaping with esc_html__() function but you can pass any function related to same purpose.

*** If you have question that when we create pot file through any tool, we must use those function not custom wrapper functions.
Answer is no, every pot file generating tool's have custom functions adding system for filtering php file. You can check
https://github.com/wp-pot/wp-pot

Uses

mp_title_p('Hello Awesome WordPress');
echo mp_text('Hello Awesome WordPress');
echo mp_text('container', 'esc_attr__');

AL EMRAN
Github

PluginMaster, a WordPress plugin development framework

Create PHP Dependency Injection Container and Learn How Laravel Initiate Controller and Method with Dependency and Parameter

AL EMRAN — Sat, 20 Feb 2021 18:47:15 +0000

Follow me on Twitter

We are building applications with Laravel but many of us do not know how Laravel Initiate Controller and Method with Dependency and Parameters.

We declare route like:

Route::get('hello', 'TestController@index')

AND Our Controller Like:


 namespace App\Http\Controllers\Test;


 class TestController extends Controller
 {
      private $requests;

      public function __construct( Request $request)
         {
            $this->requests = $request;
         }


     /**
      * Show the application dashboard.
      */
     public function index(TestModel $testModel)
     {
       return $testModel->get();
     }


 }

OR Route Like:

Route::get('hello', 'TestController')

AND Controller like:


 namespace App\Http\Controllers\Test;


 class TestController extends Controller
 {
      private $requests;

      public function __construct( Request $request)
         {
            $this->requests = $request;
         }


     /**
      * Show the application dashboard.
      */
     public function __invoke(TestModel $testModel)
     {
       return $testModel->get();
     }


 }

Now Question:

1.1 How Laravel detect construct's Dependency and inject ?

1.2 And How Laravel initiate class with construct's Dependencies and call the 'index' Method with Its Dependencies and Parameters?

2.1 We do not pass method name but How Laravel Detect __invoke method as default method?

Let's build a dependency injection container to understand previous Questions.

Why we should know?

As Laravel Developer, We need to know How Laravel Work.
It will help us to build a new Framework in our own approach.
We can use this container for our large project or Module.
Finally, we will start learning PHP Reflection (The Awesome)

Let's Start

Our Steps

Create a Class
Create a method (make) for initiating a class and injecting the constructor's dependencies and parameters
create a method (call) for extracting class & method and injecting dependencies and parameters of the method

1. Let's Create a Class

class DependencyInjectionContainer
{

    /**
     * The container's  instance.
     *
     * @var static
     */
    protected static $instance;


    /**
     * the class name with namespace
     *
     * @var string
     */
    protected $callbackClass;

    /**
     * the method name of provided class
     *
     * @var string
     */
    protected $callbackMethod;

    /**
     * method separator of a class. when pass class and method as string
     */
    protected $methodSeparator = '@';

    /**
     * namespace  for  class. when pass class and method as string
     *
     * @var string
     */
    protected $namespace = "App\\controller\\";


    /**
     *   get Singleton instance of the class
     *
     * @return static
     */
    public static function instance()
    {

    }

    /**
     * @param $callable -- string class and method name with separator @
     * @param  array  $parameters
     */
    public function call($callable, $parameters = [])
    {

    }


    /**
     * separate class and method name
     * @param $callback
     */
    private function resolveCallback($callback)
    {

    }

    /**
     * instantiate class with dependency and return class instance
     * @param $class - class name
     * @param $parameters (optional) -- parameters as array . If constructor need any parameter
     */
    public function make($class, $parameters = [])
    {
    }

}

Create a method (make) for initiating a class and injecting the constructor's dependencies and parameters

We are going to use PHP PHP Reflection. In this section we use PHP ReflactionClass object.There are so many methods exist in PHP ReflactionClass.
In this section, we need to make a class instance.
We know that if we make-instance of any class, we must pass/inject all dependencies & parameters.

With PHP ReflactionClass we need to detect all dependencies.

public function make($class, $parameters = [])
    {
        $classReflection = new ReflectionClass($class);
        $constructorParams = $classReflection->getConstructor()->getParameters();
   }

In this above code, we collect all parameters for the constructor to $constructorParams variable.

Then we need to loop with $constructorParams and detect parameter and dependency.

public function make($class, $parameters = [])
    {

        $classReflection = new ReflectionClass($class);
        $constructorParams = $classReflection->getConstructor()->getParameters();
        $dependencies = [];

        /*
         * loop with constructor parameters or dependency
         */
        foreach ($constructorParams as $constructorParam) {

            $type = $constructorParam->getType();

            if ($type && $type instanceof ReflectionNamedType) {

                echo "It is a class and we need to instantiate the class and pass to constructor"

            } else {

                echo "This is a normal parameter and We need to find parameter value from $parameters . If not found value then needs to check if this parameter is optional or not. If not optional then through error"

            }

        } 
    }

Point:

if Parameter is a class, we need to instantiate the class and pass it to the constructor.
if Parameter is not a class, We need to find parameter value from $parameters . If not found value then needs to check if this parameter optional or not. If not optional then through error.

Lets Finalize the make method:

public function make($class, $parameters = [])
    {

        $classReflection = new ReflectionClass($class);
        $constructorParams = $classReflection->getConstructor()->getParameters();
        $dependencies = [];

        /*
         * loop with constructor parameters or dependency
         */
        foreach ($constructorParams as $constructorParam) {

            $type = $constructorParam->getType();

            if ($type && $type instanceof ReflectionNamedType) {

                // make instance of this class :
                $paramInstance = $constructorParam->getClass()->newInstance()

                // push to $dependencies array
                array_push($dependencies, $paramInstance);

            } else {

                $name = $constructorParam->getName(); // get the name of param

                // check this param value exist in $parameters
                if (array_key_exists($name, $parameters)) { // if exist

                    // push  value to $dependencies sequencially
                    array_push($dependencies, $parameters[$name]);

                } else { // if not exist

                    if (!$constructorParam->isOptional()) { // check if not optional
                        throw new Exception("Can not resolve parameters");
                    }

                }

            }

        }
        // finally pass dependancy and param to class instance 
        return $classReflection->newInstance(...$dependencies);
    }

I explain everything in code.

OK.... we have completed a Dependency Injection container for class

Let's Create a Singleton Instance

  public static function instance()
    {

        if (is_null(static::$instance)) {
            static::$instance = new static;
        }

        return static::$instance;
    }

Basic Usage

 $container =  DependencyInjectionContainer::instance();

Define a class

class MyClass
{
    private $dependency;

    public function __construct(AnotherClass $dependency)
    {
        $this->dependency = $dependency;
    }
}

Instead of using new MyClass, use the Container's make() method:

$instance = $container->make(MyClass::class);

The container will automatically instantiate the dependencies, so this is functionally equivalent to:

$instance = new MyClass(new AnotherClass());

Practical Example

Here's a more practical example based on the PHP-DI docs - separating the mailer functionality from the user registration:

class Mailer
{
    public function mail($recipient, $content)
    {
        // Send an email to the recipient
        // ...
    }
}

class UserManager
{
    private $mailer;

    public function __construct(Mailer $mailer)
    {
        $this->mailer = $mailer;
    }

    public function register($email, $password)
    {
        // Create the user account

    }
}



$container = DependencyInjectionContainer::instance();

$userManager = $container->make(UserManager::class);
$userManager->register('dave@davejamesmiller.com', 'MySuperSecurePassword!');

3. create a method (call) for extracting class & method and injecting dependencies and parameters of the method

In this section, we are going to understand how Laravel parses the controller and method and initiates with dependency/parameters.

Steps

Separate controller and method
Detect method Dependency/parameters and call method
Instantiate class with our make() function.

1. Separate controller and method

Our class has a property $methodSeparator as a separator for separating class name and method name.

 private function resolveCallback($callable)
    {

        //separate class and method
        $segments = explode($this->methodSeparator, $callable);

        // set class name with namespace
        $this->callbackClass = $this->namespace.$segments[0]; 

        // set method name . if method name not provided then default method __invoke
        $this->callbackMethod = isset($segments[1]) ? $segments[1] : '__invoke'; 

    }

2. Detect method Dependency/parameters and call method

 public function call($callable, $parameters = [])
    {

        // set class name with namespace and method name
        $this->resolveCallback($callable);

        // initiate ReflectionMethod with class and method 
        $methodReflection = new ReflectionMethod($this->callbackClass, $this->callbackMethod);

        // get all dependencies/parameters
        $methodParams = $methodReflection->getParameters();

        $dependencies = [];

        // loop with dependencies/parameters
        foreach ($methodParams as $param) {

            $type = $param->getType(); // check type

            if ($type && $type instanceof ReflectionNamedType) { /// if parameter is a class

                $name = $param->getClass()->newInstance(); // create insrance 
                array_push($dependencies, $name); // push  to $dependencies array

            } else {  /// Normal parameter  

                $name = $param->getName();

                if (array_key_exists($name, $parameters)) { // check exist in $parameters

                    array_push($dependencies, $parameters[$name]); // push  to $dependencies array

                } else { // if not exist

                    if (!$param->isOptional()) { // check if not optional
                        throw new Exception("Can not resolve parameters");
                    }
                }

            }

        }

        // make class instance
        $initClass = $this->make($this->callbackClass, $parameters);

        // call method with $dependencies/parameters
       return $methodReflection->invoke($initClass, ...$dependencies); 
    }

Now you have a question how Laravel collects parameter for calling a function.

When we declare a route with dynamic parameter like:

Route::get('hello/{name}', 'TestController@index')

Laravel Routing system collects all parameter and pass to call function.

$parameters = ["name" => "AL EMRAN" ];
$container->cal("TestController@index", $parameters)

Usage

$container->call('TestController@index');
$container->call('TestController@show', ['id' => 4]);

$container->call('TestController');
$container->call('TestController', ['id' => 4]);

example


class TestController 
{
     protected $company;
     public function __construct(Company $company)
        {
            $this->company =  $company ;
        }

    /**
     * @param  Request  $request 
     */
    public function index(Request $request){

    $company =  $company->get();

     return view('admin.company', compact('company'));        

    }

}

We can use :

   $instance = DependencyInjectionContainer::instance();
   $instance->namespace = "App\\Http\Controllers\\Admin\\"; // change namespace

   $class = $instance->make(CompanyController::class); // make class instance

   $instance->call(["CompanyController", 'index']); // call method

   $instance->call([$class, 'index']); // or--call method

Install package

Package Github link here

composer require emrancu/dependency-injection-container

Declaimer

Laravel Dependency Injection Container is so vast and also its routing system. I just create this mini-class only for understanding.

This is my first article, so please comment your valuable opinion or mail me at "emrancu1@gmail.com"

You can Follow me on Twitter

Our Products:

DEV Community: AL EMRAN

How PHP-FPM Works: A Deep Dive into FastCGI Process Management

Core Architecture

Master Process

Worker Processes

Pseudo Code for Master-Worker Model

Process Lifecycle

Startup Sequence

Request Processing

Dynamic Process Management

Shared Memory and Scoreboard

Shared Memory Pseudo Code

Configuration and Optimization

Key Configuration Parameters

Performance Optimization

Example Configuration File

Error Handling and Recovery

Error Recovery Pseudo Code

Limitations of PHP-FPM in High-Concurrency Scenarios

Considerations for High-Concurrency Workloads

Conclusion

References

Follow me on Twitter

1.1 Ins & outs of ES6(JavaScript) Import with Realworld Example and Demo Project.

Introduction

Table of Contents

Basic Import Syntax

Named Exports and Imports

Default Exports and Imports

Mixing Named and Default Exports

Renaming Imports

Importing All Exports as an Object

Dynamic Imports

Real-world Examples

Demo Project: Task Manager

Best Practices and Tips

Conclusion

Why we shifted from Node JS( Adonis JS & Nuxt JS) to Laravel for refactoring uihut.com

Here are main reasons:

- Ready Authentication System

- Almost Ready Social Login system

- Ready Queue System with UI with Horizon

- Awesome testing system for frontend and api with Dusk and Pestphp:

- Good Websocket Backend with Laravel Websocket and broadcast

- Laravel Inertia JS is fantastic tool for SSR and hydration with - React JS or Vue JS

-Awesome Laravel Eloquent Model

-Nice Code formatter with Laravel Pint

-Code Static Analysis with LaraStan

-Fantastic Laravel Telescope for deeply debugging application

-Laravel Debugbar

Setup GoAccess for Caddy server in Ubuntu/Linux with Docker and access over domain/sub-domain

Prerequisites

Step 1: Create directories for GoAccess

Step 2: Create a Docker Compose file

Step 3: Create a Caddy server block

Step 4: Start the GoAccess container

Step 5: Access the GoAccess report

Conclusion

Setup Redis Replica in Ubuntu/Linux

setup Steps:

Done 😃 Follow me On Twitter

Data Transfer Object (DTO) in Laravel

Understanding DTOs in Modern PHP Applications: A Comprehensive Guide

Introduction

What is a DTO?

Why Should You Use DTOs?

1. Type Safety and Transparent Data Definition

2. Error Prevention and Code Clarity

3. Clean and Maintainable Code

4. Enhanced Security Through Type Hinting

5. Performance Optimization

6. Improved Testability

Practical Implementation

Basic DTO Implementation

Advanced DTO with Validation

Best Practices and Recommendations

Practical Usage Example

Conclusion

You can Follow me on Twitter

Doplac CRM