
# Implementing an example CI/CD Pipeline Workflow

## Introduction

Continuous Integration/Continuous Deployment (CI/CD) pipelines have become indispensable in modern software development, offering numerous benefits such as faster release cycles, improved quality assurance, and enhanced collaboration among development teams. In this article, we'll delve into a well-structured workflow for implementing a CI/CD pipeline, exploring each step in detail.

### Overview of the Workflow
Let's break down each steps of the workflow:

#### 1. GitHub Webhook

- GitHub webhook configured on the service repository triggers the CI process whenever changes are pushed.
- This initiates the CI process on your testing server.

#### 2. Express.js GitHub Webhook Listener (Testing Server)

- Listens for CI requests triggered by GitHub webhook.
- Executes commands to pull changes, build Docker images, and run Docker containers for CI tests.
- This step ensures that changes are tested in an isolated environment before being deployed.

#### 3. Jenkins (Testing Server)

- Monitors the CI Docker container and obtains test outcomes.
- If the image fails tests, it requests GitHub to rollback the repository changes and provides feedback on what went wrong.
- If the image passes tests, it pushes the image to the service Docker Hub registry.

#### 4. Docker Hub Webhook

- Docker Hub webhook listens for changes in the service registry.
- When a new image is pushed, it triggers the CD process on your production server.

#### 5. Express.js Docker Hub Webhook Listener (Production Server)

- Listens for CD requests triggered by Docker Hub webhook.
- Executes commands to pull the latest image and deploy it to update the running containers.
- This step ensures that the latest changes are deployed to the production environment.

## Example Demonstration
Note: Minimal representation; requires actual implementation and customization for practical use.

### Setting up GitHub Webhook

```bash
# Bash script to handle GitHub webhook payload
#!/bin/bash

# Perform actions on repository changes
git pull origin master
```

### Implementing Express.js GitHub Webhook Listener (Testing Server)

```javascript
// Express.js route for handling GitHub webhook requests
app.post('/github-webhook', (req, res) => {
  // Execute CI process
  runCIPipeline();
  res.status(200).send('CI process initiated successfully');
});
```
### Jenkins Integration (Testing Server)

```groovy
// Jenkinsfile for CI/CD pipeline
pipeline {
    agent any

    stages {
        stage('Build') {
            steps {
                // Build Docker image
                sh 'docker build -t my-service .'
            }
        }
        stage('Test') {
            steps {
                // Run tests in Docker container
                sh 'docker run my-service npm test'
            }
        }
        stage('Deploy') {
            steps {
                // Deploy to Docker Hub
                sh 'docker push my-service'
            }
        }
    }
}
```

### Docker Hub Webhook Setup

```bash
# Bash script to handle Docker Hub webhook payload
#!/bin/bash

# Perform actions on new image push
docker pull my-service
```
### Implementing Express.js Docker Hub Webhook Listener (Production Server)

```javascript
// Express.js route for handling Docker Hub webhook requests
app.post('/dockerhub-webhook', (req, res) => {
  // Execute CD process
  runCDPipeline();
  res.status(200).send('CD process initiated successfully');
});
```
## Best Practices
- Error Handling and Logging: Implement robust error handling and logging mechanisms at each step to ensure reliability and traceability in your pipeline.

- Security Measures: Consider implementing security measures such as authentication and authorization to protect your CI/CD infrastructure and processes.

- Infrastructure as Code (IaC): Utilize Infrastructure as Code principles to manage and provision your CI/CD infrastructure, promoting consistency and scalability.

- Version Controlling Pipeline Configurations: Version control your pipeline configurations to track changes and facilitate collaboration among team members.

- Automated Rollback Mechanisms: Implement automated rollback mechanisms to quickly revert changes in case of deployment failures, minimizing downtime and mitigating risks

## Conclusion
This workflow follows the CI/CD principles effectively by automating the testing and deployment processes. It incorporates multiple components to handle CI and CD tasks, providing a structured approach to software delivery. By adhering to best practices and leveraging short code snippets, you can streamline your CI/CD pipeline and enhance the efficiency of your software development process.





Discover a streamlined CI/CD pipeline workflow that automates testing and deployment processes effectively. Explore how GitHub webhooks, Jenkins, and Docker seamlessly integrate to ensure rapid and reliable software delivery. Learn to implement essential steps and best practices for optimizing your development pipeline.

Implementing an example CI/CD Pipeline Workflow

# Minimal Basics: Git Cheatsheet for Beginners

VCS:- Version Control System 
Git:- locally hosted Source Code VCS. 
GitHub:- A cloud platform providing remotely hosted GIT services.

Git and GitHub can communicate with each other seamlessly, allowing for synchronization between local and remote source code repositories. This communication enables developers to work locally on their machines using Git for version control and then push their changes to GitHub for collaboration, backup, and deployment purposes.

New to Git? Don't worry! Here's a simple cheatsheet to help you get started with the basics:

Here i m assuming Git is installed and well configured on your pc.

## Create Local Repo and Branch (your pc folder to git repo)
open terminal at your project root (just inside the folder)
use git commands here:-

1. **Initialize a New Git Repository**
 - Syntax: `git init`
 - Example: `git init`

```bash
git init
```
 
2. **Create a New Branch and switch to it**
 - Syntax: `git checkout -b <branch_name>`
 - Example: `git checkout -b main`

```bash
git checkout -b main
```

Now your changes inside this folder (local repo just made) ll be tracked by the Git system installed on your PC.

## Link your Github account to Git
One time link your github account to the local git system using the command below.

 - Syntax: `git config --global credential.helper store`
 - Example: `git config --global credential.helper store`

```bash
git config --global credential.helper store
```

 Your github user pass are asked u can enter them.

note:- --global credential.helper store => saves the user and password so that next time it ll not ask.

## Publish the Local Repo

3. **Link a Remote Repository to your local repo:** 
First create a new repo in your github account (github.com) and then copy its url.
The url may look like this:- https://github.com/yourusername/your-repo
Then in your workspace (local repo root in terminal):-

 - Syntax: `git remote add origin <remote_repository_url>`
 - Example: `git remote add origin https://github.com/yourusername/your-repo.git`

```bash
git remote add origin https://github.com/yourusername/your-repo.git
```

 note :- in example you see .git is added to url

4. **Push Changes to Remote Repository:** 
Now whenever you change anything in your local repo branch, u can push it to remote repo branch u choose.

 - Syntax: `git push -u origin <branch_name>`
 - Example: `git push -u origin main`

```bash
git push -u origin main
```

## Push multiple Changes in Local Repo branch to Remote Repo branch with Commit Message

5. **Add All Changes**
 - Syntax: `git add .`
 - Example: `git add .`

```bash
git add .
```

6. **Commit Changes**
 - Syntax: `git commit -m "Your message here about what changes u did"`
 - Example: `git commit -m "Added new feature"`

```bash
git commit -m "Added new feature"
```

7. **Push Changes to Remote Repository with Commit Message**
 - Syntax: `git push <remote_name> <local_branch_name>:<remote_branch_name>`
 - Example: `git push origin main:main`

```bash
git push origin main:main
```

Now your remote repo is updated. It means changes are applied to remote repo branch to match local branch.
The changes are labelled with the commit message you used while pushing.
The history or track of changes is kept and can be rolled back too.

Follow these steps, this cheatsheet provides straightforward few basic commands for using Git.

You can use Github desktop to simplify this using GUI mode.
Still learning commands ll be very useful and valuable for your career and also allows to do things which GUI mode doesn't.

For more commands and additional information, you can refer to the [GitHub Cheatsheet](https://education.github.com/git-cheat-sheet-education.pdf).

New to Git? Don't worry! Here's a simple cheatsheet to help you get started with the basics

Minimal Basics: Git Cheatsheet for Beginners


# Introduction to HTML

Hello noobies, lets dive into 1st step towards Web Development.

## HTML: Overview

Let's break down...







Dive into 1st step towards Web Development.

Introduction to html

# MyPhpApp

A powerful and flexible PHP library for building web applications.

## Features

- **App Routing Essentials** 
 - Routing Management: Seamless navigation of routes. 
 - Middleware Integration: Enhanced functionality with easy middleware incorporation. 
 - Static Files routing: Efficient delivery of static files from your specified directory. 
 - Custom Error Handling: Flexible error management, integrate your custom error handling in the app.

- **Error Utils** 
 - Option to use built in Custom Error and Error handling.

- **File Utils** 
 - files Uploads to and deletes from the specified directory.
 - Provides integration with Cloudinary upload and delete services.

- **Db Utils** 
 - Create a PDO connection to the database.
 - Execute SQL queries with optional parameters.
 - Calculate the OFFSET value for pagination.

- **Mail Utils** 
 - Creates a mailer instance with the provided configurations.
 - Allows composing and sending emails using PHPMailer.

- **Validation Utils** 
 - Create a new customizable schema for defining validation rules.
 - Validate data against a given schema.
 - Middleware function for validating request data against a schema.

- **Payment Utils** 
 - Stripe initialization and checkout process initiation.
 - Handle stripe payment response and webhook events from Stripe.

- **Coming Soon** 
 - Additional methods for handling other payment methods such as eSewa, Khalti, etc.
 - Db connection pooling using Hyperf.


## Installation

 SOON...

## USAGE

 SOON...

## Contributing

SOON...

## CONTACT

Bibek Dhakal (Aswin)
dhakalaswin8366@gmail.com

## License

SOON....

A powerful and flexible PHP library for building web applications.

MyPhpApp README


# Understanding SOLID Principles in Object-Oriented Programming with PHP

In object-oriented programming, the SOLID principles are a set of guidelines designed to create more maintainable, scalable, and flexible software. Let's break down each principle with examples in PHP:

## S: Single Responsibility Principle (SRP)

The Single Responsibility Principle states that a class should have only one reason to change.

### Example:

Consider a `User` class that handles both user authentication and user profile management. This violates SRP because the class has multiple responsibilities.

```php
class User {
    public function authenticate($username, $password) {
        // Authentication logic
    }
    
    public function updateProfile($userId, $data) {
        // Profile update logic
    }
}
```

To adhere to SRP, we can split the responsibilities into separate classes:

```php
class Authenticator {
    public function authenticate($username, $password) {
        // Authentication logic
    }
}

class UserProfileManager {
    public function updateProfile($userId, $data) {
        // Profile update logic
    }
}
```

## O: Open/Closed Principle (OCP)

The Open/Closed Principle states that software entities should be open for extension but closed for modification.

### Example:

Consider a `Shape` class with different shapes such as `Circle` and `Square`. We want to calculate the area of each shape.

```php
interface Shape {
    public function area();
}

class Circle implements Shape {
    public function area() {
        // Circle area calculation
    }
}

class Square implements Shape {
    public function area() {
        // Square area calculation
    }
}
```

To adhere to OCP, we can introduce a new requirement to calculate the perimeter of each shape without modifying existing code:

```php
interface Shape {
    public function area();
    public function perimeter();
}
```

Now, we can create new classes such as `Triangle` without modifying existing ones.

## L: Liskov Substitution Principle (LSP)

The Liskov Substitution Principle states that objects of a superclass should be replaceable with objects of its subclass without affecting the correctness of the program.

### Example:

Consider a `Bird` class with a `fly()` method. We create a `Duck` subclass that cannot fly.

```php
class Bird {
    public function fly() {
        // Flying logic
    }
}

class Duck extends Bird {
    public function fly() {
        throw new Exception("Duck cannot fly");
    }
}
```

The `Duck` class violates LSP because it cannot replace instances of the `Bird` class without affecting the program's behavior.

## I: Interface Segregation Principle (ISP)

The Interface Segregation Principle states that clients should not be forced to depend on interfaces they do not use.

### Example:

Consider an `Animal` interface with methods for both land and sea animals:

```php
interface Animal {
    public function walk();
    public function swim();
}
```

This forces all clients, including land-only or sea-only animals, to implement both methods. To adhere to ISP, we can split the interface:

```php
interface LandAnimal {
    public function walk();
}

interface SeaAnimal {
    public function swim();
}
```

Now, clients can implement only the methods relevant to them.

## D: Dependency Inversion Principle (DIP)

The Dependency Inversion Principle states that high-level modules should not depend on low-level modules; both should depend on abstractions.

### Example:

Consider a `PaymentProcessor` class that directly depends on a `Stripe` class.

```php
class PaymentProcessor {
    private $stripe;
    
    public function __construct(Stripe $stripe) {
        $this->stripe = $stripe;
    }
    
    public function processPayment($amount) {
        $this->stripe->charge($amount);
    }
}
```

To adhere to DIP, we introduce an abstraction (interface) and inject it into the `PaymentProcessor` class:

```php
interface PaymentGateway {
    public function charge($amount);
}

class PaymentProcessor {
    private $gateway;
    
    public function __construct(PaymentGateway $gateway) {
        $this->gateway = $gateway;
    }
    
    public function processPayment($amount) {
        $this->gateway->charge($amount);
    }
}
```

Now, the `PaymentProcessor` class depends on the `PaymentGateway` abstraction rather than the concrete `Stripe` class.

By understanding and applying these SOLID principles, you can create more maintainable, flexible, and scalable PHP code.





Get idea about the SOLID principles of object-oriented programming (OOP) using examples in php.

Understanding SOLID Principles in Object-Oriented Programming with PHP


# Embracing Modular Design in PHP Projects

As developers, we often find ourselves grappling with the challenge of maintaining clean, readable, and scalable code. One approach that can greatly alleviate this challenge is embracing modular design principles, particularly in PHP projects. In this blog post, I'll discuss the importance of modular design and provide practical examples using a structured views directory.

## Why Modular Design Matters

Modular design is all about breaking down your codebase into smaller, reusable components. By doing so, you can achieve several benefits:

1. **Maintainability**: Modular code is easier to maintain since each component has a well-defined responsibility.
2. **Scalability**: As your project grows, modular code allows you to add or modify functionality without causing cascading changes throughout your codebase.
3. **Readability**: Breaking down your code into smaller modules improves readability, making it easier for you and your team to understand and debug.

## An example: Structured Views Directory in PHP

Let's consider a hypothetical PHP project with the following views directory structure:

```diagram
views/
│
├── base/
│ ├── base-template.php
│ └── base-units/
│ ├── header.php
│ ├── footer.php
│ └── navigation.php
│
├── contents/
│ ├── content-units/
│ │ ├── sidebar.php
│ │ └── post-list.php
│ ├── content1.php
│ ├── content2.php
│ └── content3.php
│
├── page1.php
└── page2.php
```


In this structure:
- **base/** contains the base template (`base-template.php`) and its associated units (`header.php`, `footer.php`, `navigation.php`).
- **contents/** contains content files (`content1.php`, `content2.php`, `content3.php`) and their associated units (`sidebar.php`, `post-list.php`).
- **page1.php** and **page2.php** represent specific pages in the application which uses the `base-template.php` and `its-corresponding-content`.

Example:- 

```diagram
views/
│
├── base/
│ ├── base-template.php (uses base-units)
│ └── base-units/
│ ├── header.php
│ ├── footer.php
│ └── navigation.php
│
├── contents/
│ ├── content-units/
│ │ ├── sidebar.php
│ │ └── post-list.php
| |
│ ├── home.php
(uses required content-units to make content for home page)
│
├── home.php
(uses base template and corresponding content which is content/home.php
to make full home page)
```

This is just an example to motivate you, you can make your own modular structure.

## Advantages of this Approach

By organizing our views in this manner, we gain several advantages:

1. **Reusability**: Base units and content units can be reused across multiple pages, reducing duplication of code.
2. **Maintainability**: Changes to base templates or content units are localized, making it easier to maintain and update the codebase.
3. **Scalability**: As new pages or components are added, they can easily integrate with existing base templates and content units.

## Conclusion

Adopting a modular design approach in PHP projects can greatly enhance code maintainability, scalability, and readability. By structuring our views directory in a modular manner, we can reap the benefits of reusability and maintainability while keeping our codebase organized and efficient.

So, next time you start a new PHP project, consider incorporating modular design principles from the outset. Your future self (and your team) will thank you for it!

Happy coding!





As developers, we often find ourselves grappling with the challenge of maintaining clean, readable, and scalable code. One approach that can greatly alleviate this challenge is embracing modular design principles, particularly in PHP projects. In this blog post, I'll discuss the importance of modular design and provide practical examples using a structured views directory.