DEV Community: Angel Oduro-Temeng Twumasi

How to Migrate Azure Snapshots with Ease: Single and Multiple Scenarios

Angel Oduro-Temeng Twumasi — Thu, 12 Dec 2024 14:02:42 +0000

Introduction

Azure snapshots are point-in-time backups of managed disks. They are mainly used for:

Creating backups for disaster recovery.
Migrating disk data across different subscriptions or tenants.
Creating new managed disks from existing snapshots.

However, manually handling snapshot migration, especially across tenants or subscriptions, can be tedious. Another point to note is that, snapshots could be very large depending on the size of the Virtual Machine(VM) it was created from.

In this guide, we’ll show how to migrate Azure snapshots efficiently; whether it’s a one-time task or handling multiple snapshots in bulk.

Why Migrate Snapshots?

There are a couple of reasons why you would want to migrate your snapshot to a different tenant. These include:

Consolidation of services and licenses to improve efficiency and reduce expenses.
Mergers and Acquisitions of companies hence the need for a centralized tenant.
Ensuring backups for the snapshots in another tenant.

Prerequisites

Access permissions: Access permissions to both source and destination snapshots and storage accounts respectively.
Destination storage and container.
Key Information:
- Subscription ID of source account.
- Resource group name containing the snapshot.
- Storage name and access key for the destination.

Migrating a Single Snapshot

Follow these steps to migrate a single snapshot

Generate Shared Access Signature (SAS) for the snapshot.
```
az snapshot grant-access \
--resource-group <resource-group-name> \
--name <snapshot-name> \
--duration-in-seconds 3600 \
--query [accessSas] -o tsv
```
This generates a SAS URL for the snapshot, valid for the specified duration (3600 seconds in this case).

Here are the parameters explained,
resource-group-name : Replace this with the resource group name which has the snapshot.
snapshot-name: Replace this with the name of the snapshot.
Copy snapshot to the Destination.
```
az storage blob copy start \
--destination-blob <destination-file-name>.vhd \
--destination-container <container-name> \
--account-name <storage-account-name> \
--account-key <storage-account-key> \
--source-uri <sas-url>
```
Parameters explained,
destination-file-name: Give your it a name of your choice, for example mysnapshot.vhd.
storage-account-name: Storage account name of destination tenant.
storage-account-key: Access key of the storage account.
sas-url: SAS Uri generated in STEP 1.

Migrating Multiple Snapshots

Now, let’s automate the migration for multiple snapshots with a Bash script. This approach is perfect for those managing multiple snapshots across large environments.

Create an empty file.
```
touch transfer_script
```
Open the file.
```
vim transfer_script
```

Add these to the file.

#!/bin/bash

# Azure subscription ID
subscriptionId="your-subscription-id"

# Resource group containing snapshots
resourceGroupName="your-resource-group"

# SAS expiry duration (seconds)
sasExpiryDuration=3600

# Destination storage account and key
storageAccountName="your-storage-account"
storageAccountKey="your-storage-key"

# Destination container name
storageContainerName="snapshots"

# Snapshots array: ["snapshot-name destination-file-name"]
snapshots=(
    "<snapshot1> <snapshot1.vhd>"
    "<snapshot2> <snapshot2.vhd>"
    "<snapshot3> <snapshot3.vhd>"
)

# Set the Azure subscription
az account set --subscription "$subscriptionId"

# Loop through each snapshot and migrate
for snapshot in "${snapshots[@]}"; do
    # Extract snapshot name and destination file name
    snapshotName=$(echo "$snapshot" | awk '{print $1}')
    destinationVHDFileName=$(echo "$snapshot" | awk '{print $2}')

    echo "Processing snapshot: $snapshotName -> $destinationVHDFileName"

    # Generate SAS URL
    sas=$(az snapshot grant-access \
        --resource-group "$resourceGroupName" \
        --name "$snapshotName" \
        --duration-in-seconds "$sasExpiryDuration" \
        --query [accessSas] -o tsv)

    if [ -z "$sas" ]; then
        echo "Failed to generate SAS for $snapshotName. Skipping..."
        continue
    fi

    # Copy to destination
    az storage blob copy start \
        --destination-blob "$destinationVHDFileName" \
        --destination-container "$storageContainerName" \
        --account-name "$storageAccountName" \
        --account-key "$storageAccountKey" \
        --source-uri "$sas"

    if [ $? -eq 0 ]; then
        echo "Successfully copied $snapshotName to $destinationVHDFileName."
    else
        echo "Failed to copy $snapshotName."
    fi
done

Extra parameters explained

snapshot1 and snapshot1.vhd are the names of the snapshot in the source file and how you would want to name them at the destination respectively. Do this for all.

Press ESC, then :wq to save the file.
Change the file permissions to executable.
```
chmod +x transfer_script
```
Run the executable.
```
./transfer_script
```

Reference Links

Microsoft Official Documentation

Conclusion

Whether you’re migrating a single snapshot or handling multiple backups across subscriptions, automating the process saves time and ensures accuracy. With the script provided, you can adapt it to your specific needs and scale operations as required.

Reach out to me via LinkedIn , X and Email.

Cheers 🚀

Getting Started With Terraform For Infrastructure Provisioning 🛠️

Angel Oduro-Temeng Twumasi — Wed, 19 Jun 2024 16:59:59 +0000

Infrastructure as Code (IaC) is a modern approach to managing and provisioning computing resources through machine-readable configuration files rather than physical hardware or interactive configuration tools. This method allows for more consistent and scalable infrastructure management, enabling automation and reducing the risk of human error.

Why Terraform?

Terraform, developed by Hashicorp is one of the most popular IaC tools due to its open-source nature, flexibility, and support for multiple cloud platforms. It lets users define and provision data center infrastructure using a high-level configuration language.

In this article, you will learn how to use Terraform as an IaC tool.

Understanding the Basics

What is Terraform?

Terraform is an open-source Infrastructure as Code (IaC) tool that allows you to define and provision infrastructure using a high-level configuration language called Hashicorp Configuration Language (HCL). *Terraform manages resources such as virtual machines, storage, and networking for various cloud providers through a *declarative approach, where you simply define the desired state of your infrastructure and Terraform ensures that it matches that state.

Overview of Architecture and Workflow

FIG 1.1

FIG 1.2

A typical Terraform workflow as shown in FIG 1.1 involves:

Writing configuration files to define the desired state.
Initializing the configuration directory with terraform init.
Creating an execution plan with terraform plan.
Applying the changes with terraform apply.
Managing the infrastructure state and making updates as needed.
Destroying the infrastructure with terraform destroy if required.

Key Components

Providers

Providers are responsible for managing the lifecycle of resources. They offer a set of resources and data sources that Terraform can manage. Each provider requires a configuration to define the credentials and regions where Terraform would operate. Examples of providers include AWS, Azure, GCP, etc.

Example configuration

provider "aws" {
  region = "us-east-1"
}

Resources

Resources are the fundamental building blocks of Terraform configurations. They represent components of your infrastructure, such as virtual machines, databases, or networking components. Each resource is defined with a type, name, and a set of properties.

Example resource definition:

resource "aws_instance" "example" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
}

Modules

Modules are reusable configurations that help organize and structure your code. They allow you to group multiple resources and encapsulate complex infrastructure patterns.

Example module usage

module "vpc" {
  source = "terraform-aws-modules/vpc/aws"
  version = "2.77.0"
  name = "my-vpc"
  cidr = "10.0.0.0/16"
  azs             = ["us-east-1a", "us-east-1b"]
  public_subnets  = ["10.0.1.0/24", "10.0.2.0/24"]
  private_subnets = ["10.0.3.0/24", "10.0.4.0/24"]
}

Setting up your Environment

Visit the Terraform downloads page and download or install the version of Terraform concerning your operating system.

For Linux systems (Ubuntu/Debian) follow this:

STEP 1

wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg

echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list

sudo apt update && sudo apt install terraform

STEP 2

Verify the installation with this

Terraform –version

STEP 3

For this article, we will be provisioning our infrastructure using AWS.

Use this link to install the aws cli for your operating system

STEP 4

Run aws configure to set your variables after installing the aws cli. Terraform needs to be able to use these credentials for infrastructure provisioning.

Writing Your First Configuration

Basic Configuration File

Terraform configuration files are written in Hashicorp Configuration Language (HCL). The basic structure as shown in **FIG 1.2 **above includes

Provider Configuration:

Specifies the cloud provider and its settings.

provider "aws" {
  region = "us-east-1"
}

Resource Definition:

Declares the resources to be managed.

resource "aws_instance" "example" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
}

resource: This tells Terraform that this is a resource block.

aws_instance: This is the actual resource we want to provision in aws.

example: This is a specific name given to the resource so that we can reference it elsewhere in our terraform code

Variables:

Defines variables for dynamic values.

variable "ami_name" {
  type        = string
  description = "The name of the machine image (AMI) to use for the server."
  default = “ubuntu-local”
}

variable: This indicates a variable block.

ami_name: This is the name of the variable. Hence, it can be referenced anywhere in the terraform code.

description: The description should explain the variable and what value is expected.

default: If present, the variable is considered optional and the default value will be used if no value is set when calling the module or running Terraform.

Outputs:

Specify outputs to display after applying the configuration.

output "instance_id" {
  value = aws_instance.example.id
}

Writing your first `main.tf` file

Create a directory for your terraform config files

mkdir terraform-practise

Create the main.tf file in this directory. This file would contain your Terraform configuration

provider "aws" {
  region = "us-east-1"
}

resource "aws_instance" "example" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
}

Next, we initialize the directory

terraform init

Understanding the Initialization Process and Its Output

Provider Plugins: Terraform downloads the necessary provider plugins specified in your configuration. In our case aws.
Backend Initialization: Terraform sets up the backend for storing the state of your infrastructure.
Directory Structure: Terraform creates a .terraform directory to store the provider plugins and state files.

A sample output would look like this


Initializing the backend...

Initializing provider plugins...

- Finding latest version of hashicorp/aws...

- Installing hashicorp/aws v3.27.0...

- Installed hashicorp/aws v3.27.0 (signed by HashiCorp)

Terraform has been successfully initialized!

Terraform Commands

To view the entire list of commands, do terraform –help. Here are some commands and their uses

terraform init: Initializes a Terraform working directory by downloading the necessary provider plugins and setting up the backend for state management. This should be run first before any other terraform command.
terraform fmt: This command is used to ensure the configuration files are properly formatted and easy to read. It helps maintain a consistent style across the files.
terraform validate: Checks whether the configuration is valid.
terraform plan: This command is used to preview the changes that Terraform will make to the infrastructure. It helps in verifying the resources that will be created, modified, or destroyed.
terraform apply: This command executes the actions proposed in the execution plan. It prompts for approval before making any changes unless the -auto-approve flag is used.
terraform destroy: This command is used to terminate and remove all resources defined in the Terraform configuration. It prompts for approval before making any changes unless the -auto-approve flag is used.
terraform show: This command is used to inspect the current state of the infrastructure managed by Terraform. It can also show the details of a specific plan file.
terraform refresh: This command reconciles the state file with the real-world resources to detect any drift between the two.

Practical Example: Setting Up an EC2 Instance with a VPC

In this example, we will provision an EC2 instance within a VPC. This configuration will include

Creating a VPC
Subnets
An internet gateway
Route tables
EC2 instance with appropriate security groups

For this demonstration, we will create a new folder in our main directory named learn-terraform-aws.


mkdir learn-terraform-aws

cd learn-terraform-aws

We would then create our main.tf file responsible for holding our terraform configurations

touch main.tf

First, we will define the VPC resource in the main.tf file

provider "aws" {
  region = "us-east-1"
}

resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"

  tags = {
    Name = "main-vpc"
  }
}

Next, we define the public and private subnets within the VPC

resource "aws_subnet" "public" {
  vpc_id            = aws_vpc.main.id
  cidr_block        = "10.0.1.0/24"
  availability_zone = "us-east-1a"
  tags = {
    Name = "public-subnet"
  }
}

resource "aws_subnet" "private" {
  vpc_id            = aws_vpc.main.id
  cidr_block        = "10.0.2.0/24"
  availability_zone = "us-east-1a"
  tags = {
    Name = "private-subnet"
  }
}

After this, we create our internet gateway to allow access to the VPC

resource "aws_internet_gateway" "gw" {
  vpc_id = aws_vpc.main.id
  tags = {
    Name = "main-gateway"
  }
}

Define a route table and associate it with the public subnet

resource "aws_route_table" "public" {
  vpc_id = aws_vpc.main.id

  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.gw.id
  }
  tags = {
    Name = "public-route-table"
  }
}

resource "aws_route_table_association" "public" {
  subnet_id      = aws_subnet.public.id
  route_table_id = aws_route_table.public.id
}

Now we create our EC2 Instance

resource "aws_instance" "web" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
  subnet_id     = aws_subnet.public.id
  tags = {
    Name = "web-server"
  }
}

You would realize that we are simply declaring the state of our infrastructure like we would if we were to go to the AWS console. Also, The specific name of the resource blocks for our file is being reused as and when necessary. For instance, in the aws_instance resource, we made use of aws_subnet.public.id which is a named resource in our configuration telling terraform which resource to get this id from.

Variables and Outputs

Add variables and outputs to make the configuration more flexible and provide useful information after the infrastructure is provisioned.

Create a variables.tf file and add this code


variable "aws_region" {

  description = "The AWS region to deploy resources"

  default     = "us-east-1"

}

variable "instance_type" {

  description = "Type of EC2 instance"

  default     = "t2.micro"

}

Now create an outputs.tf file and add this code as well


output "instance_id" {

  value = aws_instance.web.id

}

output "public_ip" {

  value = aws_instance.web.public_ip

}

Now ensure that all three files are in the same directory and run the following commands

STEP 1. Initialize the directory

terraform init

STEP 2. Create an Execution Plan

terraform plan

STEP 3. Apply the configuration

terraform apply

STEP 4. After terraform apply is complete, you will see the instance ID and public IP of the newly created EC2 instance.

Reference Links

Conclusion

In this article, we've explored the foundational aspects of using Terraform for infrastructure provisioning. From understanding the core concepts and basic commands to diving into practical scenarios like setting up an EC2 instance with a VPC, we've covered essential topics that will help you get started with Terraform.

Reach out to me via LinkedIn , X via Email.

Happy Learning 🚀

Git Branching Strategies for DevOps: Best Practices for Collaboration

Angel Oduro-Temeng Twumasi — Mon, 10 Jun 2024 11:12:42 +0000

Introduction

Prerequisites

This article is intended for readers who are already familiar with GitHub and understand its functionality. If you’re new to GitHub, consider exploring some introductory resources HERE

Introduction to Git Branching in DevOps

In a fast-paced world of software engineering, efficient and effective code management is crucial. Git branching strategies play a vital role in maintaining a smooth workflow and ensuring seamless collaboration among team members.

This article aims to explore various Git branching strategies, offering insights and best practices to help you and your team enhance your collaborative efforts and streamline your development process.

Understanding Git Branching

In Git, a branch represents a single line of development. Branches allow multiple developers to work on different features, bug fixes, or experiments simultaneously without interfering with the main codebase. This flexibility is crucial in the DevOps environment where continuous integration and continuous delivery practices demand frequent updates and deployments.

Key Concepts:

Branches: Parallel lines of development that diverge from the main project.
Commits: Individual changes or updates made to the codebase.
Merges: The process of integrating changes from one branch into another.

Git Branching Strategies

Trunk-Based Development

Trunk-based development focuses on having a single main branch, often referred to as the "trunk" or "main." Developers commit to this branch frequently, ensuring that the codebase is always in a deployable state. If branches are used, they are short-lived and quickly merge back into the trunk.

Advantages

Simplifies the CI process
Reduces complexity in managing branches
Promotes rapid delivery and quick feedback cycles.

Disadvantages

Frequent integration can lead to conflicts
Requires discipline in maintaining build and test stability

GitHub Flow

GitHub Flow is a simple and effective branching strategy that revolves around a single production-ready branch, typically named main or master. Development work is done on short-lived feature branches, and changes are merged into the main branch through pull requests, which facilitate collaboration and code review.

Advantages

Keep the branching model simple
Pull requests encourage collaboration and code reviews
Integrates well with CI/CD pipelines for continuous deployment

Disadvantages

Can become difficult to manage large teams
Relies on thorough code reviews to maintain quality

Git Flow

Git Flow uses multiple long-lived branches, including main, develop, release, and hotfix, in addition to short-lived feature branches. This strategy provides a structured process for managing different types of changes, making it ideal for large teams and complex projects.

Advantages

Organized and structured process
Clear separation between production and development code
Scales well for large teams and complex projects

Disadvantages

Can be overly complex for smaller teams or projects
Frequent merging and branch management can be time-consuming

Feature Branching (Feature-Based Development)

Feature Branching involves creating a dedicated branch for each feature, which may be long-lived or short-lived. This strategy allows multiple features to be developed in parallel without affecting the main branch. Features are merged back into the main branch once they are complete and tested

Advantages

Each feature is isolated, reducing the risk of conflicts
Facilitates parallel development
Maintains a clear commit history for each feature

Disadvantages

Features might stay in separate branches for too long, leading to integration challenges
Merging multiple feature branches can be complex and error-prone

Summary Table

Strategy	Key Feature	Main Advantage	Main Disadvantage
Trunk-Based	Single main branch	Simplifies CI and rapid delivery	Frequent integration conflicts
GitHub Flow	Feature branches + PRs	Encourages collaboration and code reviews	Not ideal for large teams
Git Flow	Multiple long-lived branches	Structured process, clear separation	Can be complex and time-consuming
Feature Branching	Dedicated feature branches	Isolation and parallel development	Integration delays and complex merges

Here is a sample code snippet that summarizes creation and merging of branches

# Create and switch to a develop branch

git checkout -b develop

# Create a feature branch from develop

git checkout -b feature-branch develop

# Make changes and commit

git add .

git commit -m "Implement new feature"

# Merge feature branch back to develop

git checkout develop

git merge feature-branch

# When ready for release, merge develop to master

git checkout master

git merge develop

# Tag the release

git tag -a v1.0 -m "Release version 1.0"

Choosing the Right Strategy

Selecting the appropriate branching strategy depends on several factors, including team size and deployment frequency. Let’s take a closer look at how these factors influence the choice of branching strategy.

Team Size

The size of your development team significantly impacts the choice of branching strategy. Smaller teams often benefit from simpler and more streamlined approaches whereas larger teams may require more structured strategies to manage their workflows effectively. Below is a table outlining recommended branching strategies based on team size.

Team Size	Recommended Strategies	Reasoning
Small team (1 - 5 members)	Trunk Based development, GitHub Flow	Simpler strategies minimize overhead and facilitate rapid integration.
Medium team (6 - 20 members)	Github Flow, Feature Branching	Structured branching to handle multiple features and tasks simultaneously.
Large team (20+)	Feature Branching, Git Flow	A structured approach to managing multiple parallel developments and releases.

Deployment Frequency

The frequency with which your team deploys code is another critical factor in selecting the right branching strategy. High deployment frequency necessitates approaches that support rapid integration and deployment, while less frequent deployments can accommodate more complex and structured branching models. The table below summarizes the recommended strategies based on deployment frequency.

Deployment Frequency	Recommended Strategies	Reasoning
High Frequency	Trunk Based Development, GitHub Flow	Supports continuous integration and quick deployments.
Moderate Frequency	GitHub Flow, Feature Branching	Balances structure and flexibility for regular updates.
Low Frequency	Feature Branching, Git Flow	Manages long development cycles and ensures stability.

Best Practices For Collaboration

Effective collaboration is essential for the success of any development team, regardless of the chosen branching strategy. Here are some best strategies to ensure smooth collaboration and maximize productivity.

Effective Communication

Clear and consistent communication is crucial for avoiding misunderstandings and ensuring everyone is on the same page. Some ways to enhance communication within your team are as follows

Hold daily stand-ups or weekly check-ins to discuss progress, challenges, and next steps
Leverage communication tools like Slack, Microsoft Teams, or Discord for real-time communication and updates.
Maintain comprehensive documentation of processes, guidelines, and project details. Tools like Confluence or Notion can help with that

Code Reviews and Pull Requests

Code reviews are vital for maintaining code quality and knowledge sharing within the team. Best practices for conducting code reviews are

Define clear guidelines for code reviews, including what to look for, and provide constructive feedback.
Use automated tools to check for code quality, style, and security issues before the review process. I covered that in my previous article HERE.
Encourage developers to create small, focused pull requests that are easier to review and merge.

Handling Conflicts and Merges

Merge conflicts are inevitable in collaborative development, but they can be managed effectively with the right approach. Here’s how to handle conflicts and merges smoothly:

Regularly merge changes from the main branch into feature branches to minimize conflicts. This keeps your branch up-to-date with the latest changes.
Address conflicts as soon as they arise to prevent them from becoming more complex over time.
Involve team members in resolving conflicts, especially if the changes affect multiple areas of the codebase. Pair programming or mob programming can be useful for resolving tricky conflicts.

Integrating with CI/CD

Aligning your branching strategy with continuous integration and continuous delivery practices is essential for efficient development and deployment. Here’s how to integrate your branching strategy with CI/CD:

Set up automated builds and tests for each branch to catch issues early. Tools like Jenkins, Travis CI, and GitHub Actions can help.
Configure your CI/CD pipeline to deploy changes automatically from the main branch or a designated release branch. This ensures that your code is always in a deployable state.
Use feature flags to deploy incomplete features safely. This allows you to release code to production while keeping new features hidden until they are ready.

Helpful links

Conclusion

In the fast-paced world of software development, choosing the right Git branching strategy is crucial for maintaining efficiency and collaboration within your team. By understanding the needs of your team size and deployment frequency, you can select a strategy that balances simplicity and structure, ensuring smooth development workflows.

I believe this article has saved you a ton of time in integrating and deciding which branching strategies to use.

Don't forget to connect with me on LinkedIn and X.

Happy Learning 🚀

How to Set Up GitHub Actions for Continuous Integration

Angel Oduro-Temeng Twumasi — Thu, 23 May 2024 13:20:37 +0000

Introduction

In the fast-paced world of software development, ensuring that code is consistently tested and integrated can be a challenging task. This is where Continuous Integration (CI) comes to play.

CI is a development practice that requires developers to integrate code into a shared repository frequently.

CI automates the process of building, testing and integrating code changes regularly, helping developers to catch issues early and maintain a stable codebase.

GitHub Actions, a powerful feature introduced by GitHub, has revolutionized the way developers automate their workflows. We will explore how to use this tool for setting up CI in your projects.

Here's what we will cover

Understanding CI and it's benefits
Introduction to GitHub Actions
Building CI workflows with Github Actions
Advanced Techniques and Integration with External Tools

Benefits of Continuous Integration

There are several benefits to Continuous Integration. These include

Early Detection of Bugs
Continuous Integration facilitates the early detection of bugs by automatically running tests with each code integration, allowing developers to identify and fix issues before they escalate, resulting in more stable software releases.
Improved Code Quality
By ensuring consistent coding standards and practices through automated testing and integration, code quality is checked. This reduces technical debt and ensures the maintainability of the codebase
Faster Feedback Loop
With Continuous Integration, developers receive rapid feedback on their code, enabling them to iterate quickly and address issues promptly leading to faster development cycles.

These are some of the benefits derived from Continuous Integration. Now let's look at using GitHub actions for CI.

Introduction to GitHub Actions

GitHub Actions serves as a platform for continuous integration and continuous delivery (CI/CD), enabling you to automate the process of building, testing, and deploying your software pipeline.

Here are some uses of GitHub Actions

You can set up workflows that automatically build and test each pull request submitted to your repository.
Deploy successfully merged pull requests to your production environment.
Actions can also be used to package or release projects into the pipeline.

GitHub Actions goes beyond just DevOps and lets you run workflows when other events happen in your repository. For example, you can run a workflow to automatically add the appropriate labels whenever someone creates a new issue in your repository. It has gained popularity for its simplicity and the fact that it is integrated directory into your repository.

Now let's look at the components that make up a GitHub workflow

Understanding a Github Action Workflow

A workflow is a configurable automated process that will run one or more jobs. A GitHub Actions workflow is defined by a YAML file typically located in the .github/workflows directory within your repository.

Components of a workflow

Triggers
These define the event that trigger the workflow. Example, the workflow can start when a user:

Creates a pull request
Opens an issue
Pushes a commit to the repository etc

Jobs
These specify the individual tasks to be executed as part of the workflow. Each job runs sequentially or in parallel and can include multiple steps.

Steps
Define the individual actions or commands to be executed within a job. Steps can include tasks like checking out code, running tests, or deploying artifacts.

Actions
Actions are reusable units of code that perform specific tasks within a workflow. They can be authored by GitHub or by the community and can be easily integrated into workflows. An action can pull your git repository from GitHub, set up the correct toolchain for your build environment

Runners
A runner is a server that runs your workflows when they're triggered. Each runner can run a single job at a time. GitHub provides three runners to run your workflows: Ubuntu Linux, Microsoft Windows and macOS.

Build an example workflow

In this section we would set up a simple workflow that runs linters for Python using pycodestyle. This will help ensure that your Python code adheres to PEP 8 style guidelines and is free of common errors.

Step-By-Step Guide

Create the .github/workflows directory at the root of your repository.
Inside the directory, create a file lint.yml. Go to Add file and then write the directory as shown in the image below

After this, commit the changes for it to take effect.

Open the lint.yml file and add the following code



name: Lint Python Code

on: [push, pull_request]

jobs:
  lint:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v3

    - name: Set up Python
      uses: actions/setup-python@v4
      with:
        python-version: '3.x'

    - name: Install Pycodestyle
      run: |
        pip install pycodestyle

    - name: Lint Python files with Pycodestyle
      run: |
        pycodestyle .

Explanation of the code

name: Defines the name of the workflow as "Lint Python Code".
on: Triggers the workflow on push or pull request events to the main branch. Hence, anytime there's a pull request to merge code or pushing to main branch, this workflow would be triggered.
jobs: Defines a single job named lint that executes the linting steps.
runs-on: Specifies the environment which would run the workflow, in our case, ubuntu-latest.
steps: This section defines the sequential steps within the job:
- Checkout Code: Uses the actions/checkout action to check out the repository code.
- Set up Python: Uses the actions/setup-python action to set up a Python environment.
- Install Pycodestyle: Installs the Pycodestyle linter for Python files.
- Lint Python Files: Runs Pycodestyle on the entire repository to check for PEP 8 compliance.

This workflow ensures that every time code is pushed or a pull request is created, Pycodestyle is automatically run to check for style issues in Python code.

Now let's create a simple python file hello.py in our repository with the following code



#!/usr/bin/python3
"""
This is a function file
"""


def hello():
    print("hello World")


if __name__ == '__main__':
    hello()

Now commit and push this code to your repository. The workflow would automatically be triggered since we specified a push in the trigger. You would see something equivalent to the image below in the actions tab

Now when there's an error in the workflow (which normally reflects an error in the codebase), it would be marked red otherwise, it would check and you'll get something like the image below.

Debugging a workflow

Here's another python code which should fail in the workflow. We would then learn how to debug or troubleshoot a workflow.



#!/usr/bin/python3
"""
This is a function file
"""

def hello():
    print("hello World")

def new():
  print("This is me")

if __name__ == '__main__':
    hello()
    new()

This is what we get from the workflow

Now click on the failed workflow to troubleshoot

The logs rightly shows what needs to be done to get the linter to check correctly.



./python_with_error.py:6:1: E302 expected 2 blank lines, found 1
./python_with_error.py:9:1: E302 expected 2 blank lines, found 1
./python_with_error.py:10:3: E111 indentation is not a multiple of 4
./python_with_error.py:12:1: E305 expected 2 blank lines after class or function definition, found 1

As shown above, there needs to be blank lines added and indentation issues. This gives you a sense of what exactly didn't allow the code to flow in the pipeline.

After fixing the issues with pycodestyle, you should have the equivalent of these

Advanced CI Workflow Techniques

There are other useful configurations when building a workflow. Let's look at three of them.

Variables

Variables store non-sensitive information that can change depending on the environment or the context of the workflow.

To add a new variable, navigate to Settings > Secrets and Variables > Actions

Use Cases

Setting environment-specific configurations, such as the target environment (development, staging, production).
Storing file paths or URLs that might differ between environments.

Secrets

Secrets store sensitive information securely, such as API keys, passwords, and tokens. They ensure that this information is not exposed in the workflow configuration or logs.

To add a new secret, navigate to Settings > Secrets and Variables > Actions

Use Cases

Stores access tokens for third-party services like AWS, Docker Hub, or email services.
Database passwords or credentials for accessing secure services.

Webhooks

Webhooks trigger actions in response to specific events, such as sending notifications to external services.

To add a new webhook, navigate to Settings > Webhooks

Use Cases

Sending notifications to Slack, email, or SMS services when a build fails or succeeds.
Initiating deployments to environments such as staging or production when certain conditions are met.

Now let's add a notification to our workflow such that, a SMS is automatically sent to us when our pipeline fails.

Edit the yml file with the following code snippet



name: CI Pipeline

on: [push, pull_request]

jobs:

  build:

    runs-on: ubuntu-latest

<span class="na">steps</span><span class="pi">:</span>
<span class="pi">-</span> <span class="na">name</span><span class="pi">:</span> <span class="s">Checkout code</span>
  <span class="na">uses</span><span class="pi">:</span> <span class="s">actions/checkout@v3</span>

<span class="pi">-</span> <span class="na">name</span><span class="pi">:</span> <span class="s">Set up Python</span>
  <span class="na">uses</span><span class="pi">:</span> <span class="s">actions/setup-python@v4</span>
  <span class="na">with</span><span class="pi">:</span>
    <span class="na">python-version</span><span class="pi">:</span> <span class="s1">'</span><span class="s">3.x'</span>

<span class="pi">-</span> <span class="na">name</span><span class="pi">:</span> <span class="s">Install dependencies</span>
  <span class="na">run</span><span class="pi">:</span> <span class="pi">|</span>
    <span class="s">pip install requests pycodestyle</span>

<span class="pi">-</span> <span class="na">name</span><span class="pi">:</span> <span class="s">Lint Python files with Pycodestyle</span>
  <span class="na">run</span><span class="pi">:</span> <span class="pi">|</span>
    <span class="s">pycodestyle .</span>

<span class="pi">-</span> <span class="na">name</span><span class="pi">:</span> <span class="s">Send SMS Notification</span>
  <span class="na">if</span><span class="pi">:</span> <span class="s">failure()</span>
  <span class="na">run</span><span class="pi">:</span> <span class="pi">|</span>
    <span class="s">python - &lt;&lt;EOF</span>

    <span class="s">import requests</span>
    <span class="s">import json</span>

    <span class="s">quicksend_url = "https://uellosend.com/quicksend/"</span>

    <span class="s">data = {</span>
        <span class="s">'api_key': '${{ secrets.SMS_API_KEY }}',</span>
        <span class="s">'sender_id': 'GitHub',</span>
        <span class="s">'message': 'CI Pipeline has failed, check the details',</span>
        <span class="s">'recipient': '${{ secrets.SMS_RECIPIENT }}'</span>
    <span class="s">}</span>

    <span class="s">headers = {'Content-type': 'application/json'}</span>

    <span class="s">response = requests.post(quicksend_url, headers=headers, json=data)</span>

    <span class="s">with open('sms_response.json', 'w') as f:</span>
        <span class="s">json.dump(response.json(), f, indent=4)</span>
    <span class="s">EOF</span>

Explanation of Code

We check for a failure of the task to be run then we send aSMS to the user.
We use UelloSend for the SMS service.
Secrets are configured for the services in the secrets file within the repository.

Below is the SMS that would be sent should the run or job fail

Helpful links

Conclusion

In this article, we explored how GitHub Actions can streamline and enhance your Continuous Integration (CI) workflows. By leveraging GitHub Actions, you can automate various aspects of your development process, ensuring code quality and improving collaboration among team members.

By implementing these techniques, you can create robust CI workflows that not only automate code checks and tests but also keep you informed about the status of your builds in real-time. This enhances the overall development process, making it more efficient and reliable.

What did you think? Share your thoughts and feedback in the comments below!

Your input helps me deliver insightful and informative content in the future. Let's keep the conversation going!

Connect with me:

Happy learning 🚀

What happens when you type google.com in your browser and press Enter ❓

Angel Oduro-Temeng Twumasi — Fri, 26 Apr 2024 12:55:14 +0000

Introduction

Have you ever wondered what exactly happens when you type www.google.com in your web browser? Of course, depending on your internet connection, you'd receive the google homepage homepage in a matter of micro-seconds.

Did you know that there are lots of communications, channels and protocols which are ticked before the webpage is displayed on your screen?

In this article, we would demystify the basics of everything which happens behind that scenes when you type any website into your web browser. We would go over some of the architecture, protocols and services responsible for serving us the pages we request for.

Here is a simplified diagram showing most of the components we would talk about in this article.

DNS Resolution 🔍

When you enter the Uniform Resource Locator (URL), www.google.com, DNS resolution is the first step in loading the webpage.

DNS is like the phonebook of the internet. Instead of remembering IP addresses like 192.168.1.1, you can use domain names like google.com to navigate the web. DNS translates human-readable domain names into IP addresses that computers use to identify each other on a network.

How DNS works

Local DNS Cache
Your operating system typically has local DNS cache that stores recently accessed domain names and their corresponding IP address. If you've visited Google recently, your computer might already have this information cached, speeding up the process
DNS Query
If the domain information is not cached locally, your computer sends a DNS query to a DNS resolver. The resolver is usually provided by your Internet Service Provider (ISP) or a third party service like Google DNS.
Root Servers
The resolver starts by querying the root servers to find the authoritative name server for the .com top-level domain
Top-Level Domain (TLD) Servers
Once the resolver gets the information about the .com TLD Server, it queries that server to find out the authoritative name server for google.com
Authoritative Name Server
Finally the resolver queries the authoritative name server for google.com which provides the IP address associated with google.com and then returns it to your computer, allowing it to access the site

TCP/IP 🌐

Once the IP address for google.com is found, TCP/IP takes over to establish connections between your computer and the google webserver.

Transmission Control Protocol/ Internet Protocol (TCP/IP) is a set of rules for internet communication, ensuring that data get's to where it needs to go.

How TCP/IP Works

Three Way Handshake Your computer and the server exchange synchronization (SYN) and acknowledgement (ACK) packets.
Data Transfer Data is then sent in small packets over the established connection.
Connection Termination After the transfer of data the connection is closed

Firewall 🛡️

A firewall is a security system that monitors and controls incoming and outgoing network traffic based on a set of predetermined security rules.

How a firewall works

A firewall inspects incoming and outgoing data packets to determine if they meet the security criteria set by the rules
Based on those predefined rules, a firewall either allows or blocks the data packets

Firewalls essentially acts as a protective barrier between your computer and the internet, ensuring that only safe and authorized traffic can pass through.

HTTPS/SSL 🔐

Once the firewall allows the connection, that connection has got to be secured using Https/SSL.

HTTPS (Hyper Text Transfer Protocol) is the secured version of HTTP and SSL (Secured Socket Layer) is the technology that encrypts the data transmitted between your browser and the webserver.
Learn about SSL
Learn about HTTPS

How HTTPS/SSL operates

Encryption SSL encrypts the data transferred between your browser and the webserver, making it unreadable for anyone who intercepts the network.
Authentication SSL certificates verify the identity of a website ensuring that you are connecting to the legitimate server and not a malicious one
Data Integrity SSL provides data integrity checks to ensure that data hasn't been altered during transmission.

Load Balancer ⚖️

Google has various webservers which process different requests from client computers like yours. As such a load balancer is used to distribute the network traffic across those servers.

A load balancer is a device or software that distributes incoming network traffic across multiple servers to ensure efficient use of resources, maximize throughput, and minimize response time.
Read about load balancers

How a load balancer works

A load balancer receives incoming requests and distributes them across multiple servers based on predefined algorithms such as round Robbin.
Load balancers also monitor the health of servers by sending regular requests to check their status. If a server becomes unavailable or unhealthy, the load balancer redirects the traffic to another server.
Load balancers can drop and add servers depending on the demand allowing for easy scalability.

Webserver 🖥️

After being directed by the load balancer, the request reaches the web server which hosts the website files.

A webserver is a software that serves web pages to clients over the internet using HTTP Protocol
Read about Web server

How the Web server works

When a request arrives from the client, the web server processes it, retrieves the requested files, and generates a response.
The web server delivers the requested web pages, images or other resources to the client's web browser.
In addition to serving static files, web servers can also execute scripts or interact with databases to generate dynamic content.

Examples of the popular webservers include Nginx, Apache and Microsoft IIS

Application Server 📡

The application server basically handles all dynamic content and business logic that the request contains.

Application Server is software that provides the runtime environment for web applications, allowing them to run and execute code written in programming languages.
Read about Application Server

How the Application Server works

The application server executes the scripts to generate dynamic content based on user input, database queries or other factors.
It often integrates with databases or other backend systems to fetch data to be returned to the user.

NOTE: Web servers is more fitted for static content, while the application server handles dynamic content.
Read more about the differences HERE

Database 🗃️

After the application server handles dynamic content, it may interact with the database to retrieve or store information required for the web application.

A database is a structured collection of data organized for efficient retrieval, storage, and management. It stores information such as user profiles, product details, or any other data needed by the web application.
Read about databases

How the database works

The database stores data in tables, with each table containing rows and columns representing individual records and fields, respectively.
The application server sends queries to the database to retrieves or manipulate data. These queries are written using a query language like SQL.
The database processes queries, retrieves the requested data and performs the necessary operations like filtering, sorting or aggregating.

Conclusion

In addition to the major routes and services discussed in this article, there are other microservices like CDNs (Content Delivery Networks) that also play a crucial role in delivering web content. While we've covered the essential components involved in the process of accessing a website like google.com, it is important to recognize the complexity of the underlying infrastructure that ensures the seamless delivery of content to your web browser.

I invite you to share your thoughts and feedback in the comments section. Did this article meet your expectations?
Your input is valuable in shaping future discussions and ensuring that we continue to provide insightful and informative content.

Follow me on Github, let's get interactive on Twitter and form great connections on LinkedIn 😊

Happy Learning 🚀

Build your own Shell : PART 2 👨🏾‍💻

Angel Oduro-Temeng Twumasi — Mon, 06 Nov 2023 09:01:09 +0000

In the first part of our journey to create a shell, we explored the basics, crafting a shell that worked when we typed in commands but needed the complete path, like /bin/ls, to function properly.

Find the previous article HERE

Now, in this next step, we're going to upgrade our shell to be more flexible and user-friendly:

We'll make our shell more versatile, allowing it to be used in both interactive chats and automated processes.
We're going to tweak things so that the shell understands simple commands like ls without needing the whole path, just like we're used to in regular shells.
In a nutshell, we're enhancing our shell to be easier to use and adaptable to different situations. This way, it'll feel more like the shells we commonly use, making our coding journey more exciting and practical.

Linus Torvalds once said and I want you to note 👇🏾

"Talk is cheap. Show me the code" - Linus Torvalds

Now let's show the code 🔥

This is our current main.h file



#ifndef MAIN_H
#define MAIN_H

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>

#endif /* MAIN_H */

and this is our current main.c file



#include "main.h"

/**
  * main - Getline function
  * @argc: Argument count
  * @argv: Array of argument values
  *
  * Return: 0 on success
  */

int main(int argc, char **argv)
{
        (void)argc, (void)argv;
        char *buf = NULL, *token;
        size_t count = 0;
        ssize_t nread;
        pid_t child_pid;
        int i, status;
        char **array;

        while (1)
        {
                write(STDOUT_FILENO, "MyShell$ ", 9);

                nread = getline(&buf, &count, stdin);

                if (nread ==  -1)
                {
                        perror("Exiting shell");
                        exit(1);
                }

                token = strtok(buf, " \n");

                array = malloc(sizeof(char*) * 1024);
                i = 0;

                while (token)
                {
                        array[i] = token;
                        token = strtok(NULL, " \n");
                        i++;
                }

                array[i] = NULL;

                child_pid = fork();

                if (child_pid == -1)
                {
                        perror("Failed to create.");
                        exit (41);
                }

                if (child_pid == 0)
                {
                        if (execve(path, array, NULL) == -1)
                        {
                                perror("Failed to execute");
                                exit(97);
                        }
                }
                else
                {
                        wait(&status);
                }
        }
        free(buf);
        return (0);
}

Don't forget we would compile with this command



gcc -Wall -Wextra -pedantic *.c -o shell && ./shell

In order to enhance our shell functionality so that it would work with just the executables eg ls, I would create a function in a file to handle that.

In the original shell, when the user inputs ls, here's what happens

The shell looks through the PATH environment variable. The PATH is made up of various directories which contain various executable files. These directories are where the system searches for executable files. When you type a command in the terminal, the system goes through these directories in order until it finds the executable file corresponding to the command you entered. If it doesn't find the command in any of these directories, it will display a "command not found" error.

These are the directories in my PATH



/home/vagrant/.local/bin:/home/vagrant/.local/bin/:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin

Note that they are separated by a colon :. Hence, in effect, when the user enters ls, the shell builds an executable path which would be /bin/ls and runs that instead.

With this understanding, we need to upgrade our shell with this functionality.

Here are the steps that we would take

STEP 1: We would get the PATH variable with the getenv() command.
STEP 2: Tokenize each directory in the PATH with strtok()
STEP 3: For each directory, we build an absolute path for the file (user input). Hence if the user input is ls or hello, we build an absolute path like so /usr/local/bin/ls or /usr/local/bin/hello respectively assuming /usr/local/bin/ is our first directory in the PATH environment.
STEP 4: After constructing the absolute path above, stat() is to check the existence of that file in that directory and gather as much information about that file. We then access() to check if the file is accessible and executable. If either stat() or access() fails, then the file is either not found or not executable.
With the example above, /usr/local/bin/hello is invalid whereas /usr/local/bin/ls is valid.
STEP 5: The first instance of the executable file is returned to the execve(). We would use a function get_file_path for this and assign its value to a variable.

NOTE: The first argument (array[0]) of the execve() function is the absolute path of the executable.

Add this code to the main.c file



/* Initialize the path variable */
char *path;

/* Add this code just after array[i] == NULL */
path = get_file_path(array[0]);

/* Now update the execve to use the path variable like so */
if (execve(path, array, NULL) == -1)
{
    perror("Failed to execute")
    exit(97);
}

Now we would code the get_file_path() function in a different file. Create a file file_loc.c.

In this file, I would add a helper function to the get_file_path() named get_file_loc(). get_file_path() would retrieve the PATH variable, check whether the PATH exists. If yes, the value of PATH is passed to the get_file_loc() function would return the full path of the file to the get_file_path.

To get the PATH as stated in STEP 1 above, we use the getenv() function.

Getenv()

man 3 getenv

Synopsis



#include <stdlib.h>

char *getenv(const char *name);

Description: The getenv() function searches the environment list to find the environment variable name.

Return Value: A pointer to the corresponding value of name or NULL if there's no match.

In our file_loc.c file, let's add the get_file_path function.



#include "main.h"

/**
  * get_file_path - Get's the full path of the file
  * @file_name: Argument name
  *
  * Return: The full path argument to the file
  */

char *get_file_path(char *file_name)
{
        char *path = getenv("PATH");

        if (!path)
        {
                perror("Path not found");
                return (NULL);
        }

        return (path);
}

Explanation

The get_file_path takes an argument file_name which would be the input of the user or array[0] used by the execve.
The variable path stores the value of the getenv("PATH").
A condition is checked for the value returned by the getenv. If false, the condition is executed ie. The "PATH" value wasn't found.
We then return the value.

NOTE: The value we are returning would be something like this



/home/vagrant/.local/bin:/home/vagrant/.local/bin/:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin

which is not exactly what we need.

Hence, we would create another function to help us tokenize this value as stated in STEP 2. After which the same function would help us build an absolute path with the file name which in our case is ls.

Add this code to the get_file_path function



/* Add to the initialization */
char *full_path;


/* Add this to the function body */
full_path = get_file_loc(path, file_name);

if (full_path == NULL)
{
       perror("Absolute path not found");      
       return (NULL);
}

return (full_path); /* Replace the current return with this */

Explanation

We pass the path value and the file_name (ls) into the get_file_loc function. This function would help us build the absolute path for the filename ls after tokenizing the path value.
The result is stored in the full_path variable.
We check if it's null and return NULL if Yes, otherwise we return the absolute path to the function.

Now in the get_file_loc function,

We tokenize the path as stated in STEP 2 with the delimeter :.
For each directory, we build an absolute path for and append the file_name to the end of it.
We then use stat and access as stated in the STEPS above to check the existence and execute permissions of the file

Stat

man 2 stat

Synopsis



#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

int stat(const char *pathname, struct stat *statbuf);

Description: Returns the information about the file in the buffer pointed to by the statbuf variable.

Return Value: On success 0, on error -1

Access

man 2 access

Synopsis



#include <unistd.h>

int access(const char *pathname, int mode);

Description: This checks whether the file pathname can be accessed. It has three modes:
- F_OK: This tests for the existence of the file
- R_OK: Tests if file exists and grants read permissions
- W_OK: Tests if file exists and grants write permissions
- X_OK: Tests if file exists and grants execute permissions

Return Value: 0 if all permissions (modes) specified are met or -1 if at least one fails.

With this well settled there are other things to consider.

We would create a buffer to hold the absolute path, hence, we would have to malloc (man 3 malloc) memory for that.
We would have to duplicate using strdup (man 3 strdup) the value from the PATH so that we do not loose it during tokenization.
We would also perform concatenation using strlen (man 3 strlen).

Now this is how the get_file_loc function would look like. Add this to the file file_loc.c.



/**
  * get_file_loc - Get the executable path of file
  * @path: Full path variable
  * @file_name: The executable file
  *
  * Return: Full path to the executable file
  */

char *get_file_loc(char *path, char *file_name)
{
        char *path_copy, *token;
        struct stat file_path;
        char *path_buffer = NULL;

        path_copy = strdup(path);
        token = strtok(path_copy, ":");

        while (token)
        {
                if (path_buffer)
                {
                        free(path_buffer);
                        path_buffer = NULL;
                }
                path_buffer = malloc(strlen(token) + strlen(file_name) + 2);
                if (!path_buffer)
                {
                        perror("Error: malloc failed");
                        exit(EXIT_FAILURE);
                }
                strcpy(path_buffer, token);
                strcat(path_buffer, "/");
                strcat(path_buffer, file_name);
                strcat(path_buffer, "\0");

                if (stat(path_buffer, &file_path) == 0 && access(path_buffer, X_OK) == 0)
                {
                        free(path_copy);
                        return (path_buffer);
                }
                token = strtok(NULL, ":");
        }
        free(path_copy);
        if (path_buffer)
                free(path_buffer);
        return (NULL);
}

Explanation

We initialize all variables that would be needed.
The struct stat file_path is a variable used by the stat() function. See it's implementation in the man page
We duplicate the original path and store that in the variable path_copy. This is done so that we don't loose the original PATH when manipulating it. strdup allocates memory and the copies the content of the PATH into path_copy.
The value of the PATH is then tokenized with the delimiter :.
path_buffer is used to store the absolute path of the executable file input from the user. We need to allocate memory for it and it's size would be the length of the token (eg /usr/bin), the length of file (eg ls) and then 2 (because we would add a / and then end it with a null character \0 to make it a complete string).
strcpy and strcat are used to build this absolute path which would look like /usr/bin/ls (notice that we added a / before the ls and then we completed it with the null character to make it a string).
After building the absolute path, we use stat to get more information about the file. We then use access with the mode X_OK to check if the file is executable. -When these conditions are satisfied, we would free the path_copy because we allocated space for it and then we return the absolute path which is the path_buffer. Otherwise, we continue the string tokenization.
If we didn't get a match for the executable file, we free the path_copy and path_buffer and return NULL.

That was a lot I know 😀, take your time to re-read it again with understanding

Don't forget to update your main.h file to include the headers of our new functions and system calls.
Here's our updated main.h



#ifndef MAIN_H
#define MAIN_H

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <string.h>

/* Helper Funcitons */
char *get_file_path(char *file_name);
char *get_file_loc(char *path, char *file_name);

#endif /* MAIN_H */

Now we would add this to our main.c file.



#include "main.h"

/**
  * main - Getline function
  * @argc: Argument count
  * @argv: Array of argument values
  *
  * Return: 0 on success
  */

int main(int argc, char **argv)
{
        (void)argc, (void)argv;
        char *buf = NULL, *token, *path;
        size_t count = 0;
        ssize_t nread;
        pid_t child_pid;
        int i, status;
        char **array;

        while (1)
        {
                write(STDOUT_FILENO, "MyShell$ ", 9);

                nread = getline(&buf, &count, stdin);

                if (nread ==  -1)
                {
                        perror("Exiting shell");
                        exit(0);
                }

                token = strtok(buf, " \n");

                array = malloc(sizeof(char*) * 1024);
                i = 0;

                while (token)
                {
                        array[i] = token;
                        token = strtok(NULL, " \n");
                        i++;
                }

                array[i] = NULL;

                path = get_file_path(array[0]); /* Get the absolute path using the function */

                child_pid = fork();

                if (child_pid == -1)
                {
                        perror("Failed to create.");
                        exit (41);
                }

                if (child_pid == 0)
                {
                        if (execve(path, array, NULL) == -1) /* Replace the first argument with that executable file */
                        {
                                perror("Failed to execute");
                                exit(97);
                        }
                }
                else
                {
                        wait(&status);
                }
        }
        free(path);
        free(buf);
        return (0);
}

NOTICE THE CHANGES ‼️

We pass the first input of the user (array[0]) to the function get_file_path so that the absolute file path is returned to us.
We then pass this to the execve function since it's first argument is supposed to be an executable file/command.

But there's a slight problem
We want our shell to handle user inputs whether it is the absoulute path (/usr/bin/ls) or just the executable file(ls).

We would implement a function to help us with that startsWithForwardSlash. Let's add this to the file_loc.c file.



/**
  * startsWithForwardSlash - Checks if file starts with "/"
  * @str: The filename to be checked
  *
  * Return: 0 if yes and 1 if NO
  */

int startsWithForwardSlash(const char *str)
{
        if (str != NULL || str[0] == '/')
                return (1);

        return (0);
}

Explanation

This function simply checks the first character of the input string and returns a 1 or 0 if found or not found respectively.

We would update our get_file_path function to check if the first character is a /.



/* Previous initializations */

if (startsWithForwardSlash(file_name) && access(file_name, X_OK) == 0)
         return (strdup(file_name));

/* Rest of code */

Hence the full file_loc.c file would look like this



#include "main.h"

/**
  * startsWithForwardSlash - Checks if file starts with "/"
  * @str: The filename to be checked
  *
  * Return: 0 if yes and 1 if NO
  */

int startsWithForwardSlash(const char *str)
{
        if (str != NULL || str[0] == '/')
                return (1);

        return (0);
}

/**
  * get_file_loc - Get the executable path of file
  * @path: Full path variable
  * @file_name: The executable file
  *
  * Return: Full path to the executable file
  */

char *get_file_loc(char *path, char *file_name)
{
        char *path_copy, *token;
        struct stat file_path;
        char *path_buffer = NULL;

        path_copy = strdup(path);
        token = strtok(path_copy, ":");

        while (token)
        {
                if (path_buffer)
                {
                        free(path_buffer);
                        path_buffer = NULL;
                }
                path_buffer = malloc(strlen(token) + strlen(file_name) + 2);
                if (!path_buffer)
                {
                        perror("Error: malloc failed");
                        exit(EXIT_FAILURE);
                }
                strcpy(path_buffer, token);
                strcat(path_buffer, "/");
                strcat(path_buffer, file_name);
                strcat(path_buffer, "\0");

                if (stat(path_buffer, &file_path) == 0 && access(path_buffer, X_OK) == 0)
                {
                        free(path_copy);
                        return (path_buffer);
                }
                token = strtok(NULL, ":");
        }
        free(path_copy);
        if (path_buffer)
                free(path_buffer);
        return (NULL);
}

/**
  * get_file_path - Get's the full path of the file
  * @file_name: Argument name
  *
  * Return: The full path argument to the file
  */

char *get_file_path(char *file_name)
{
        char *path = getenv("PATH");
        char *full_path;

        if (startsWithForwardSlash(file_name) &&
                        access(file_name, X_OK) == 0)
                return (strdup(file_name));

        if (!path)
        {
                perror("Path not found");
                return (NULL);
        }

        full_path = get_file_loc(path, file_name);

        if (full_path == NULL)
        {
                write(2, file_name, strlen(file_name));
                write(2, ": command not found\n", 19);
                return (NULL);
        }

        return (full_path);
}

Finally, we update our main.h file with the new function



#ifndef MAIN_H
#define MAIN_H

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <string.h>

/* Helper Funcitons */
char *get_file_path(char *file_name);
char *get_file_loc(char *path, char *file_name);
int startsWithForwardSlash(const char *str);


#endif /* MAIN_H */

Let's compile our file with the command



gcc -Wall -Werror -Wextra -pedantic *.c -o hsh && ./hsh

Extras

See what happens when you enter the following command in the terminal


 "ls" | ./hsh

However we want this to execute the ls command against the ./hsh executable file. This is known as non-interactive mode.
We would use the isatty command for this.

Isatty

man 3 isatty

Synopsis:



#include <unistd.h>

int isatty(int fd);

Description:
The isatty() function tests whether fd is an open file descriptor referring to a terminal. This means it checks for the file descriptors - in our case, 0 or STDIN_FILENO, which checks for a file or standard input - and works accordingly.
Return Value:
isatty() returns 1 if fd is an open file descriptor referring to a terminal; otherwise 0 is returned, and errno is set to indicate the error.

Let's add the isatty() function to our main.



/* Add it after the while condition */
if (isatty(STDIN_FILENO))
     write(STDOUT_FILENO, "MyShell$ ", 9);

/* Modify the nread function like so */
if (nread == -1)
{
     exit(1);
}

Explanation

The isatty function works to check whether the file is opened in interactive or non-interactive mode using the file descriptor
We removed the perror message in the nread condition of the getline function. This is so that we don't get such error messages when exiting the program in either interactive or non-interactive modes.

Now you should get the following output

Here's a summary of all the files
main.c



#include "main.h"

/**
  * main - Getline function
  * @argc: Argument count
  * @argv: Array of argument values
  *
  * Return: 0 on success
  */

int main(int argc, char **argv)
{
        (void)argc, (void)argv;
        char *buf = NULL, *token, *path;
        size_t count = 0;
        ssize_t nread;
        pid_t child_pid;
        int i, status;
        char **array;

        while (1)
        {
                if (isatty(STDIN_FILENO))
                        write(STDOUT_FILENO, "MyShell$ ", 9);

                nread = getline(&buf, &count, stdin);

                if (nread ==  -1)
                {
                        exit(0);
                }

                token = strtok(buf, " \n");

                array = malloc(sizeof(char*) * 1024);
                i = 0;

                while (token)
                {
                        array[i] = token;
                        token = strtok(NULL, " \n");
                        i++;
                }

                array[i] = NULL;

                path = get_file_path(array[0]);

                child_pid = fork();

                if (child_pid == -1)
                {
                        perror("Failed to create.");
                        exit (41);
                }

                if (child_pid == 0)
                {
                        if (execve(path, array, NULL) == -1)
                        {
                                perror("Failed to execute");
                                exit(97);
                        }
                }
                else
                {
                        wait(&status);
                }
        }
        free(path);
        free(buf);
        return (0);
}

main.h



#ifndef MAIN_H
#define MAIN_H

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <string.h>

/* Helper Funcitons */
char *get_file_path(char *file_name);
char *get_file_loc(char *path, char *file_name);
int startsWithForwardSlash(const char *str);


#endif /* MAIN_H */

file_loc.c



#include "main.h"

/**
  * startsWithForwardSlash - Checks if file starts with "/"
  * @str: The filename to be checked
  *
  * Return: 0 if yes and 1 if NO
  */

int startsWithForwardSlash(const char *str)
{
        if (str != NULL || str[0] == '/')
                return (1);

        return (0);
}

/**
  * get_file_loc - Get the executable path of file
  * @path: Full path variable
  * @file_name: The executable file
  *
  * Return: Full path to the executable file
  */

char *get_file_loc(char *path, char *file_name)
{
        char *path_copy, *token;
        struct stat file_path;
        char *path_buffer = NULL;

        path_copy = strdup(path);
        token = strtok(path_copy, ":");

        while (token)
        {
                if (path_buffer)
                {
                        free(path_buffer);
                        path_buffer = NULL;
                }
                path_buffer = malloc(strlen(token) + strlen(file_name) + 2);
                if (!path_buffer)
                {
                        perror("Error: malloc failed");
                        exit(EXIT_FAILURE);
                }
                strcpy(path_buffer, token);
                strcat(path_buffer, "/");
                strcat(path_buffer, file_name);
                strcat(path_buffer, "\0");

                if (stat(path_buffer, &file_path) == 0 && access(path_buffer, X_OK) == 0)
                {
                        free(path_copy);
                        return (path_buffer);
                }
                token = strtok(NULL, ":");
        }
        free(path_copy);
        if (path_buffer)
                free(path_buffer);
        return (NULL);
}

/**
  * get_file_path - Get's the full path of the file
  * @file_name: Argument name
  *
  * Return: The full path argument to the file
  */

char *get_file_path(char *file_name)
{
        char *path = getenv("PATH");
        char *full_path;

        if (startsWithForwardSlash(file_name) &&
                        access(file_name, X_OK) == 0)
                return (strdup(file_name));

        if (!path)
        {
                perror("Path not found");
                return (NULL);
        }

        full_path = get_file_loc(path, file_name);

        if (full_path == NULL)
        {
                write(2, file_name, strlen(file_name));
                write(2, ": command not found\n", 19);
                return (NULL);
        }

        return (full_path);
}

Congratulations 👏🏾 you have enhanced your shell. Go ahead and test your shell extensively 🔥.

In our next article, we would implement other functionalities like exit, cd, handling #, env etc.

Follow me on Github, let's get interactive on Twitter and form great connections on LinkedIn 😊

Happy coding 🥂

Build your own Shell : PART 1 👨🏾‍💻

Angel Oduro-Temeng Twumasi — Wed, 11 Oct 2023 20:22:10 +0000

A shell is a program that provides a user interface to the operating system. It allows users to interact with the system by typing commands. The shell interprets these commands and executes them on behalf of the user.
When a user logs into a system, the shell is typically the first program that is started. The shell then presents the user with a prompt, which is a symbol or sequence of symbols that indicates that the shell is ready to accept a command.

The user can then type a command and press Enter. The shell will then interpret the command and execute it. If the command is successful, the shell will display the output of the command to the user. If the command is not successful, the shell will display an error message.

In this article, we are going to build our own Shell.

Pre-requisite

What is Shell
Basic understanding of C programming
System Calls

I would also encourage you to familiarize yourself to use the man pages to read the implementation of any command you wouldn't understand. I would provide the links at various points in this article.

Getting Started 🔥

Now let's get to the core of building the shell. As we go along, the various system calls I implement would be explained.

Basic Functionality

Let's look at what happens when you enter a command in the shell. Eg.



ls -l

STEP 1. User enters command ls -l.
STEP 2. The shell creates a new process(child process) using the fork() function. This creates a copy of the shell process, with its own memory space and program counter.
STEP 3. This child process, executes the ls command with another system call (execve). This replaces the child process's image with the image of the ls command.
STEP 4. The shell waits for the child process to terminate using the wait() function. This ensures that the shell does not continue to the next command until the ls is done executing.
STEP 5. The child process then parses the command line using the strtok() function. This breaks the command line into individual words and arguments. In our case ls, -l.
STEP 6. The child process executes the ls, with the -l argument. This displays a long listing of the content of the current directory.

As shown in the picture below

STEP 7. The child process terminates.
STEP 8. The shell continues to wait for the next command from the user.
STEP 9. If the user enters "exit" or Ctrl+D, the shell exits. This means the EOF (end-of-file) has been reached. Read more on EOF here

From the above steps we now understand what happens anytime we interact with the shell.

Let's start by creating the files we need as seen.
First create a directory named my_shell like so mkdir my_shell, then add these two files touch main.c and touch main.h.

Let's add some codes to both files.
Add this to the main.h file



#ifndef MAIN_H
#define MAIN_H

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#endif /* MAIN_H */

And to the main.c file



#include "main.h"

/**
  * main - Main entry point for our program
  * @argc: Argument count to the main
  * @argv: Pointer to array of argument values
  *
  * Return: O Always success
  */

int main(int argc, char *argv[])
{
        (void)argc, (void)argv;
        write(STDOUT_FILENO, "MyShell$ ", 9);
        return (0);
}

Now we would execute our program using this command.



gcc -Wall -Wextra -pedantic *.c -o shell && ./shell

This of course would print a simple "#myShell$ " to the screen. Feel free to rename it as you please.

Following the steps I listed above, we need accept input from the user to be executed. This can be achieved with the function getline().

Getline()

man getline

Synopsis: ```man

#include

ssize_t getline(char **lineptr, size_t *n, FILE *stream);

* **Description**: The `getline()` function reads a line of text from a stream. The stream can be a file, a pipe or the standard input (meaning reading what the user enters to the shell like in our case).
* **Return Value**: On success, the number of characters is returned, otherwise -1 on failure.

Let's use this to read input from the user. In the `main.c` file, update the codes to look like so.
```c


int main(int argc, char **argv)
{
        (void)argc, (void)argv;
        char *buf = NULL;
        size_t count = 0;
        ssize_t nread;

        write(STDOUT_FILENO, "MyShell$ ", 9);
        nread = getline(&buf, &count, stdin);

        if (nread ==  -1)
        {
                 perror("Exiting shell");
                 exit(1);
        }
        printf("%s", buf);
        free(buf);
        return (0);
}

Explanation

The argc and argv arguments of the main are typecast to void since they are not being used currently.
We initialize the various variables with their datatypes.
We first print "MyShell$ " to the screen and wait for the user input.
The getline function is used to get the user input and it stores it in the buf variable.
- buf - Holds the entire user input
- buf_size - This is the number of bytes in the buf
- stdin - This allows us to receive input from the user
We then store the return value of the getline in nread.
The condition then checks if getline failed to read (ie. if it returns -1) as we saw in the return statement, and then prints a system error message using the perror function (perror is used to print system error messages).
However if getline is successful, we want to print the user input.
Finally, getline dynamically allocates memory for the buf, hence we need to free up that memory and then return 0 to the main.

When this code is compiled and run we should get the following output.

But wait ✋🏾, our program just exited. That's not how the shell behaves right? We want the user to manually exit the shell by typing "exit", or a combination of "Ctrl + D" which signifies the end-of-file.

We can solve this adding an infinite while loop to our program as shown below



int main(int argc, char **argv)
{
        (void)argc, (void)argv;
        char *buf = NULL;
        size_t count = 0;
        ssize_t nread;

        while (1)
        {
                write(STDOUT_FILENO, "MyShell$ ", 9);

                nread = getline(&buf, &count, stdin);

                if (nread ==  -1)
                {
                        perror("Exiting shell");
                        exit(1);
                }
                printf("%s", buf);
        }
        free(buf);
        return (0);
}

When this is compiled and executed we should get as shown in the images below.

So far, our program is reading our input and returning it correctly as supposed.

Now we would want to execute our program so that when the user inputs a command, a result would be given. As stated in the steps earlier on, our shell would need to create a child process for executing every command.

NOTE: Every process that runs in the shell has a unique identifier known as process ID (PID). Each process on a system has a unique PID. The PID is used by the operating system to track and manage processes. A process (parent process) can create another process (child process).

Example
When a user inputs /bin/ls, the following happens:

The shell forks a child process.
The child process executes the /bin/ls command.
The child process terminates.

With this analogy in place we would go ahead and create a child process which would execute the user input. The function fork() would be used.

Fork()

man 2 fork

Synopsis: ```

include

pid_t fork(void);

* **Description**: The `fork()` function simply creates a child process by duplicating the calling process.
* **Return Value**: On success, the PID (process ID) of the child process is returned in the parent and 0 is returned in the child. Otherwise, -1 is returned to the parent and no child is created.

Once we are able to create the child process, we need to make the parent process wait for the child process to execute. Remember that the child process was created to execute the "/bin/ls" command from the user. To make the parent process wait, we use the function `wait()`;

#### Wait()
[man 2 wait](https://linux.die.net/man/3/wait)
* **Synopsis**:

include

pid_t wait(int *wstatus);

* **Description**: The `wait()` function causes the current process to wait until one of its child processes terminates. When a child process terminates, the wait() function returns the child process's exit status.

The wait() function is typically used to ensure that all of a process's child processes have terminated before the process itself terminates.
* **Return Value**: On success, return PID of the terminated child otherwise -1 on error.

Let's edit the `main.h` file to include the header files which would enable us use the functions we have discussed
```c


#ifndef MAIN_H
#define MAIN_H

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

#endif /* MAIN_H */

Now let's implement the fork() and wait() in our program.
Update the main.c file with this code




int main(int argc, char **argv)
{
        (void)argc, (void)argv;
        char *buf = NULL;
        size_t count = 0;
        ssize_t nread;
        pid_t child_pid;
        int status;

        while (1)
        {
                write(STDOUT_FILENO, "MyShell$ ", 9);

                nread = getline(&buf, &count, stdin);

                if (nread ==  -1)
                {
                        perror("Exiting shell");
                        exit(1);
                }

                child_pid = fork();

                if (child_pid == -1)
                {
                        perror("Failed to create.");
                        exit (41);
                }

                if (child_pid == 0)
                {
                        /* The creation was successful and we can execute the user input */
                        printf("The creation was successful\n");
                }
                else
                {
                        /* Wait for the child process to execute before terminating the parent process */
                        wait(&status);
                }
        }
        free(buf);
        return (0);
}

If the fork() returns a 0 in the child, the process has been created and hence we can execute the command given by the user. To achieve this, we use the execve() function.

Execve()

man 2 execve

Synopsis: ```

include

int execve(const char *pathname, char *const argv[],
char *const envp[]);

* **Description**: The `execve()` function is typically used to execute a new program referred to by the `pathname` variable as seen above.
     *The pathname is an executable file which is found on your system. 
     * Argv is a an array of strings
     * Envp is also an array of strings (more on that later)
     * Both Argv and Envp should be terminated by a NULL pointer.

Let me explain with an Example.
When the user inputs `ls -l` to the shell, the `fork()` creates the child process to execute that command. When the child process is successfully created (child_pid == 0), the execve function looks for a NULL terminated array format like so `argv = {"ls", "-l", NULL}`. The first argument of the `execve` (pathname) is replaced by `ls` which is argv[0] or the first element in the array argv. 

**NOTE**: This `ls` is an executable file which is found in the `/bin` folder. So when you input `ls` it would give you the same output as `/bin/ls` in the shell (we would implement that later in our shell). Our `execve` function currently accepts only the full path of the executable and therefore `ls` wouldn't work; however `/bin/ls` which is the path of the full executable would work.

* **Return Value**: On success the execve doesn't return, however it returns -1 on error.

Phew! That was a lot 😀. Let's implement it in our `main.c` file
```c


/* Add this code to the condition when child_pid == 0 */
 if (execve(array[0], array, NULL) == -1)
           {
                   perror("Couldn't execute");
                   exit(7);
           }

So far we have seen that the execve accepts an array of strings which is terminated by the NULL pointer. The question now is, how do we get that array of string inputs. Remember that, the user only inputs /bin/ls -l and our shell should put this in an array format for the execve function to use. To accomplish this, we use a function called strtok() to split the inputs of the user.

Strtok()

man 3 strtok

Synopsis: ```

include

char *strtok(char *str, const char *delim);

* **Description**: The `strtok()` function breaks a string into a sequence of tokens. A token is a sequence of characters that is separated from other tokens by a delimiter character (delim). The `strtok()` function returns a pointer to the first token in the string.

The `strtok()` function is typically used to parse strings into individual words or arguments.

In the case of the `/bin/ls -l` command, the *str becomes "/bin/ls" and our delim becomes a space (" "). This means we are separating the string inputs by the space.

The shell uses the strtok() function to parse the command line into the following words and arguments:
`/bin/ls` (command name)
`-l` (argument)
The shell then passes these words and arguments to the execve() function, which executes the `/bin/ls` command with the `-l` argument.

* **Return Value**: On success, the PID (process ID) of the child process is returned in the parent and 0 is returned in the child. Otherwise, -1 is returned to the parent and no child is created.

Let's implement the strtok in our `main.c` file. 
```c


/* Add these initializations just below the main function */
char *token;
char **array;
int i;

/* Add these lines in the while loop after the getline condition */
token = strtok(buf, " \n");

array = malloc(sizeof(char *) * 1024);
i = 0;
while (token)
{
      array[i] = token;
      token = strtok(NULL, " \n");
      i++;
}
array[i] = NULL;

Don't forget to update your main.h file with this



/* Add this line to the include statements */
#include <string.h>

Explanation of the code

The strtok takes in the input of the user which has been stored in the buf and separates it by a space or the newline "\n"(because the user would press ENTER for the command to execute).
We create an array so we can store the tokens (this would be used by the execve).
Since an array is created, we enter a loop where we assign each token to a space in the array.
We update the token and set it's first argument to NULL, and then assign the delimiter appropriately. This is found in the usage of strtok() function.
If there are no more tokens (or strings to be parsed), we need to add the NULL pointer to the array per the demands of the execve function.

Now that we have implemented all these functions, this is how your main.h file should look like.



#ifndef MAIN_H
#define MAIN_H

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>


#endif /* MAIN_H */

This is the final code in the main.c file



#include "main.h"

/**
  * main - Getline function
  * @argc: Argument count
  * @argv: Array of argument values
  *
  * Return: 0 on success
  */

int main(int argc, char **argv)
{
        (void)argc, (void)argv;
        char *buf = NULL, *token;
        size_t count = 0;
        ssize_t nread;
        pid_t child_pid;
        int i, status;
        char **array;

        while (1)
        {
                write(STDOUT_FILENO, "MyShell$ ", 9);

                nread = getline(&buf, &count, stdin);

                if (nread ==  -1)
                {
                        perror("Exiting shell");
                        exit(1);
                }

                token = strtok(buf, " \n");

                array = malloc(sizeof(char*) * 1024);
                i = 0;

                while (token)
                {
                        array[i] = token;
                        token = strtok(NULL, " \n");
                        i++;
                }

                array[i] = NULL;

                child_pid = fork();

                if (child_pid == -1)
                {
                        perror("Failed to create.");
                        exit (41);
                }

                if (child_pid == 0)
                {
                        if (execve(array[0], array, NULL) == -1)
                        {
                                perror("Failed to execute");
                                exit(97);
                        }
                }
                else
                {
                        wait(&status);
                }
        }
        free(buf);
        return (0);
}

When we compile and execute with



gcc -Wall -Wextra -pedantic *.c -o shell && ./shell

We should get as seen in the images

You can test your shell with these commands to make sure it's working
/bin/ls, /bin/ls -l, /bin/ls -la, /bin/pwd, /bin/echo "Hello World", /bin/cat main.c.

Remember that this is the absolute path of the commands ls, pwd, echo, cat etc. We would add functionalities so that these could give us the results their absolute path gives us.

Congratulations 👏🏾, you have built a simple shell with basic functionalities.

References

Wikipedia
CS University

Check this out
Build your own shell part 2

Follow me on Github, let's get interactive on Twitter and form great connections on LinkedIn 😊

Happy coding 🥂

Exploring File I/O in C📁

Angel Oduro-Temeng Twumasi — Fri, 06 Oct 2023 08:38:04 +0000

Introduction

File handling is a fundamental aspect of programming that allows us to interact with data stored on our computers. Whether it's reading text from a file, writing data to it, or manipulating its contents, mastering Input/Output (IO) operations is essential for any developer.

In this article, we would cover some file handling concepts in C, low-level and high-level File I/O, file descriptors and more.

Importance of File Handling

When a program is terminated, the entire data is lost. Storing in a file will preserve data even if the program terminates.
If you have to enter a large number of data, it'll take sometime. However, if you have a file containing all the data, you can easily access the contents with few commands.
File handling enables the reading and writing of configuration files, allowing users to tailor software settings to their preferences.
Through file handling, programs that need to exchange data with other programs or systems can share data in various formats with external entities.
Regularly saving data to files ensures that valuable information can be restored in case of system failures or data loss

Getting started with File Handling

At its core, file handling involves performing operations on files which include opening, reading, writing and closing files. In C programming, file handling is achieved through the following

Streams
File pointers
File descriptors.

Let's look at these more closely

Streams

These are a fundamental abstraction for file handling in C. They provide a high-level interface for reading and writing to files. In C, there are standard streams like stdin(standard input) stdout (standard output) and stderr (standard error) which are automatically available for input and output.

File Pointers

A file pointer is a mechanism used to keep track of the current position within a file. It determines where the next read or write operation will occur. File pointers are essential for sequential file access and help navigate through the file's contents.

File Descriptors

These are low-level integer identifiers that represent open files in C. Each descriptor corresponds to a particular stream as we found above.

Below is a table to summarize the various descriptors and their corresponding streams.

Integer Value	Name	Symbolic Constant	File Stream
0	Standard Input	STDIN_FILENO	stdin
1	Standard Output	STDOUT_FILENO	stdout
2	Standard Error	STDERR_FILENO	stderr

NOTE
stdin: It is used to read input from the user or another program.
stdout: Used to write output to the user or another program.
stderr: Used to write error messages and other diagnostics output to the user.

Basic operations in File handling with C

There are four (4) basic operations in file handling with C. They are opening, reading, writing and closing. These operations must be followed in order when handling and manipulating files.

Aside the four (4) basic operations, there are generally two (2) approaches to handling them. They are low-level approach with system calls and high-level approach with standard library.

Another point to note is that files come in different formats such as csv, binary and text. This article would focus on the text files only.

Let us look at the basic operations in file handling. For each operation, we would look at its implementation in both the high-level and low-level approaches.

Opening a File

This is the first step in file handling. It establishes connection between your program and the file on disk.
During file opening, you specify the following parameters
- File's name
- Location
- Mode with which you want to open the file in. These modes specify what exactly you would like to do with the file you are opening. These includes: reading only, writing only, appending etc. Man fopen

High-Level Approach

FILE *file = fopen("example.txt", "r");

RETURN VALUE: FILE pointer if successful, NULL if otherwise

Low-Level Approach

int fd = open("example.txt", O_RDONLY);

man open
RETURN VALUE: New file descriptor if successful, -1 if an error occurred.

Below is a table to understand various modes and how they correspond to each other in high-level and low-level approaches.

fopen() mode	open() flags	Usage
r	O_RDONLY	Opens file for reading
r+	O_RDWR	Opens file for reading and writing
w	O_WRONLY \| O_CREAT \| O_TRUNC	Writes to a file. It clears(truncates) everything if there is already text
w+	O_RDWR \| O_CREAT \| O_TRUNC	Opens for reading and writing. The file is created if it doesn't exist otherwise it's truncated.
a	O_WRONLY \| O_CREAT \| O_APPEND	Open for appending (writing at end of file). The file is created if it doesn't exist

Reading from a File

This involves retrieving data from existing file on disk.
You can read data character by character, line by line or in larger chunks depending on your program's requirement.

High-Level Approach

There are two ways to read from files with this approach. They are:
fgets(): This reads texts line by line and stores in a buffer.

FILE *file;
char buffer[1024];
while(fgets(buffer, sizeof(buffer), file) != NULL) {
     // Process each line in the file
}

RETURN VALUE: A string on success, NULL on error.
man fgets
fread(): This reads specified number of bytes from a file or for reading binary files also into a buffer.
man fread

FILE *file;
char buffer[1024];
size_t bytes_to_read = sizeof(buffer);
size_t bytes_read = fread(buffer, 1, bytes_to_read, file);

RETURN VALUE: Number of items read

Low-Level Approach

This uses the read() function.

char buffer[1024];
ssize_t bytes_read = read(fd, buffer, sizeof(buffer));
if (bytes_read == -1)
    // handle error
else
    // Process the data in the buffer

NOTE: The fd is the return value of the open function
man read

Writing to a file

This adds or updates data in a file.
You can write character by character, line by line or in larger blocks as well.
Writing is essential for tasks like creating log files, saving program output or storing user-generated content.

High-Level Approach

This method uses fprintf() (Write formatted text data to a file)

FILE *file = fopen("example.txt", "w"); // Open for writing
fprintf(file, "Hello, %s!\n", "World");

man fprintf
fwrite() (Writes a specified number of bytes from the buffer to a file)

FILE *file = fopen("data.bin", "wb"); // Open for binary writing
char data[] = {0x01, 0x02, 0x03};
size_t bytes_to_write = sizeof(data);
size_t bytes_written = fwrite(data, 1, bytes_to_write, file);

man fwrite

Low-Level Approach

write() is the function used here.

int fd = open("example.txt", O_CREAT | O_WRONLY | O_TRUNC, 0644);
const char *text = "Hello, World!\n";
ssize_t bytes_written = write(fd, text, strlen(text));

man write

NOTE: Modify the various modes/flags of the write operation to get the desired results like append etc.

In the low-level approach, you have more control over the writing process and can directly manipulate the binary data. However, you need to manage buffering and handle text encoding yourself if you're working with text files.

Closing a File

This is the final step in the file handling and it's essential to release the system resources and ensure data integrity.
Once you finish reading or writing, you should close the file to free up the file descriptors and ensure that all pending changes are saved.
Failing to close a file property can result in resource leaks and data corruption.

High level approach

FILE *file = fopen("example.txt", "w"); // Open for writing
// Write data to the file
fclose(file); // Close the file when done

man fclose

Low level approach

int fd = open("example.txt", O_CREAT | O_WRONLY | O_TRUNC, 0644); // Open for writing
// Write data to the file
close(fd); // Close the file descriptor when done

man close

Until now you might have realized that there are two approaches to handline files in C. The commonest one used is the high-level approach. However, let us look at some differences between the two. This would help inform our decisions as to which of them to use at what point in time.

Aspect	High level Approach	Low level Approach
File representation	Uses a file stream represented by FILE*, for file operations	Uses file descriptors represented by int for file operations
Common functions	Common functions include fopen(), fclose(), fgets(), fprintf(), fwrite().	Common functions include open(), close(), read(), write().
Text vs. Binary Files	Suitable for both text and binary files, with functions handling text encoding and formatting.	Suitable for both text and binary files, but you need to handle text encoding and formatting manually if required.
Error Handling	Uses functions like ferror() and feof() to handle errors.	Relies on error codes returned by functions like read() and write() for error handling.
Resource Cleanup	Automatically flushes data and releases resources when you use fclose()	Requires manual closure of file descriptors using close() for resource cleanup.

Now let's look at some examples with practical questions

QUESTION 1
Implement a program to read text from a file

SOLUTION

High level approach

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
    if (argc != 2) {
        printf("Usage: %s source_file\n", argv[0]);
        return 1;
    }

    FILE *source = fopen(argv[1], "r");

    if (!source) {
        perror("Error");
        return 1;
    }

    char buffer[1024];

    while (fgets(buffer, sizeof(buffer), source)) {
        printf("%s", buffer);
    }

    fclose(source);

    return 0;
}

Low level approach

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

int main(int argc, char *argv[]) {
    if (argc != 2) {
        printf("Usage: %s source_file\n", argv[0]);
        return 1;
    }

    int source_fd = open(argv[1], O_RDONLY);

    if (source_fd == -1) {
        perror("Error");
        return 1;
    }

    char buffer[1024];
    ssize_t bytes_read;

    while ((bytes_read = read(source_fd, buffer, sizeof(buffer))) > 0) {
        if (write(STDOUT_FILENO, buffer, bytes_read) == -1) {
            perror("Error");
            return 1;
        }
    }

    close(source_fd);

    return 0;
}

QUESTION 2
Implement a program to append some text to a file. This program should take the text from the user (stdin) and then append to the file

SOLUTION

High level approach

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
    if (argc != 2) {
        printf("Usage: %s destination_file\n", argv[0]);
        return 1;
    }

    FILE *destination = fopen(argv[1], "a");

    if (!destination) {
        perror("Error");
        return 1;
    }

    char input[1024];

    printf("Enter text (Ctrl-D to end):\n");

    while (fgets(input, sizeof(input), stdin)) {
        fputs(input, destination);
    }

    fclose(destination);

    return 0;
}

Low level approach

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

int main(int argc, char *argv[]) {
    if (argc != 2) {
        printf("Usage: %s destination_file\n", argv[0]);
        return 1;
    }

    int destination_fd = open(argv[1], O_WRONLY | O_CREAT | O_APPEND, 0644);

    if (destination_fd == -1) {
        perror("Error");
        return 1;
    }

    char input[1024];

    printf("Enter text (Ctrl-D to end):\n");

    while (fgets(input, sizeof(input), stdin)) {
        if (write(destination_fd, input, strlen(input)) == -1) {
            perror("Error");
            return 1;
        }
    }

    close(destination_fd);

    return 0;
}

QUESTION 3
Implement a File Copy Program (like cp command)

SOLUTION

High level approach

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
    if (argc != 3) {
        printf("Usage: %s source_file destination_file\n", argv[0]);
        return 1;
    }

    FILE *source = fopen(argv[1], "rb");
    FILE *destination = fopen(argv[2], "wb");

    if (!source || !destination) {
        perror("Error");
        return 1;
    }

    char buffer[1024];
    size_t bytes_read;

    while ((bytes_read = fread(buffer, 1, sizeof(buffer), source)) > 0) {
        fwrite(buffer, 1, bytes_read, destination);
    }

    fclose(source);
    fclose(destination);

    return 0;
}

Low level approach

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

int main(int argc, char *argv[]) {
    if (argc != 3) {
        printf("Usage: %s source_file destination_file\n", argv[0]);
        return 1;
    }

    int source_fd = open(argv[1], O_RDONLY);
    int destination_fd = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0644);

    if (source_fd == -1 || destination_fd == -1) {
        perror("Error");
        return 1;
    }

    char buffer[1024];
    ssize_t bytes_read;

    while ((bytes_read = read(source_fd, buffer, sizeof(buffer))) > 0) {
        if (write(destination_fd, buffer, bytes_read) == -1) {
            perror("Error");
            return 1;
        }
    }

    close(source_fd);
    close(destination_fd);

    return 0;
}

NOTE: In low-level implementation, the open() function has an optional argument known as permissions. These are file permissions that you can set to the file are read, write and execute permissions represented by their numerical values.
More about file permissions here

References

Congratulations on making it this far 👏🏾. As you have studied, file handling is a very useful programming concept. I would love to know what your experience is with File handling in the comment section.

Follow me on Github, let's get interactive on Twitter and form great connections on LinkedIn 😊

Happy coding 🥂

The Art of Clean Code: Mastering the Betty Style 🧑🏾‍💻

Angel Oduro-Temeng Twumasi — Sun, 16 Jul 2023 22:14:48 +0000

Introduction

When it comes to developing software in any programming language, adhering to a consistent coding style is crucial for maintaining readability, collaboration, and code quality. For the C programming language, one widely recognized coding style is known as Betty. Betty, originally created for the Linux kernel development, has become popular within the C programming community, providing a set of guidelines to enhance code clarity and maintainability.

What is Betty?

Betty is a coding style guide specifically tailored for the C programming language. It was devised to standardize coding practices within the Linux kernel development community, ensuring that the codebase is cohesive and comprehensible to developers working on the project.

The Importance of Consistent Style:

Consistency in coding style plays a vital role in collaborative projects, making it easier for team members to understand and modify each other's code. Betty enforces a standardized set of rules, including naming conventions, indentation, spacing, and comment placement. By following these guidelines, developers can produce clean, readable code that is more approachable to others and less prone to errors.

Set up betty on local machine.

Clone the betty repo
cd into the Betty directory
Install the linter with



sudo ./install.sh

Run the following commands to check if your code/doc fits the Betty Style:



betty-style <filename>



betty-doc <filename>

Let's look at a simple guide for coding using the Betty style

Indentation

Imagine looking at a codebase for more than 20hrs. Indentation helps you to easily identify which parts to find information quickly. This really helps with debugging

Use TAB to indent your code. A block of code is every group of statements inside a set of curly braces ({})

An example is what is used in our main function



int main(void)
{
        return (0);
}

Do not put multiple statements on a single line

This is a bad example



if (condition) do_this;
do_something_everytime;

This is a good example



if (condition)
     do_this;

do_something_everytime;

In the case of multiple indentation statements - the switch statement -, the switch keyword and it's subordinate case are placed on the same indentation levels as shown in the example below



int add(int sum)
{
        var i = 0;
        switch (sum)
        {
        case 23:
                i = 34;
        default:
                i = 4;
        }
        return var;
}

The use of braces {}

Opening and closing braces should be placed at the beginning of the next line. This is a bad example ```

if (condition) {
statement1;
statement2;
}

This a good example

if (condition)
{
statement1;
statement2;
}


This applies to functions as well. An example is the main function

int main(void)
{
return (0);
}

- The body of the braces should be indented as stated in the above examples.

There are exceptions to this rule however. If a continuation of the same statement follows the ending braces, you need to add it. An example is the `do....while` statement.

do {
body of loop;
} while (condition);

- Don't use braces for when a single statement is written in 
An example is the code below

if (condition)
statement;

It applies to this as well

if (condition)
statement;
else
statement;

Note that this doesn't apply where the even one has multiple statements. An example is

if (condition)
{
do_this();
do_this();
}
else
{
do_this();
}


- Don't use commas on a single line to avoid braces

if (condition)
do_this(), do_this();

Do this instead

if (condition) {
do_this();
do_this();
}


### Use of spaces
- Use space after these keywords `if`, `else if`, `switch`, `case`, `for`, `while`, `return`.
- Do not use space however after the following which look like functions: `sizeof`, `typeof`, `alignof` and `__attribute__`.

Here's a table for reference


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xj08kns1wwrp7mldlb07.png)

However, do not use spaces around (inside) expressions.
This is a bad example

a = sizeof( struct file );

This is a good example

a = sizeof(struct file);


- Use one space around most binary and ternary operators such as :

= + - < > * / % | & ^ <= >= == != ? :

- Do not use spaces around **_unary operators_** :

& * + ~ ! sizeof typeof alignof attribute defined


- Do not leave trailing whitespace at the end of lines else you'll receive the following warning from betty


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/smy3rpnsw2cpxm573xut.png)

### Breaking of long lines of character
Coding is all about readability and maintainability. Lines of code should not be very long such that one needs to scroll laterally to read them.
The limit on the lines is **80 columns** and is strongly the preferred limit

### Functions
Functions are simply a chunk of code that does one particular thing.
- Functions must contain not more than **40 lines of code**
- Local variables in a function shouldn't exceed `5-10`
- When using source file, **separate functions with one blank line**

### Commenting in C

/* This is a single line comment */

/**

This is a multiline comment
comments in C source code */


## Code Documentation
The use of documentation in programming is very necessary for anyone to be able to understand the code very well. We provide documentation by way of commenting. By adding comments at key points, you provide context, explanations, and insights that clarify your code's purpose, intentions and intricacies.

Betty has a style for documenting your code. Let's look at them

### How to document functions
Instead of a regular C multiline commenting, the comment block for the documentation would look like this.

/**

main - This is the entry point of the code *
Return - 0 Successful */

int main(void)
{
printf("Hello");
return (0);
}


- If the function must return a value, the `Return:` header tag is **mandatory**

- Arguments supplied to functions must be added to their respective tags.

/**

sum - Calucates the sum of two numbers
@arg1 - First operand
@arg2 - Second operand *
Return: The sum of the two parameters */


- You could add additional sections like `Example` which you could give examples of the usage of your function

/**

Sum- Makes the sum of two numbers
@arg1: First operand
@arg2: Second operand *
Return: The sum of two parameters *
Example:
sum(10, 5); --> 15 */

int sum(int num1, int num2)
{
return (num1 + num2);
}


Using the Betty Coding style is extremely beneficial as a programmer. It ensures that your codes are consistent, readable and have great clarity.

I believe this was a great read for you especially if you are a C programmer and a student of ALX Software Engineering and Holberton School. Like and comment if you found it helpful.

Read more about the style of coding from the [Linux Kernel coding style](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/plain/Documentation/process/coding-style.rst)

Follow me on [Github](https://www.github.com/angelotheman), let's get interractive on [Twitter](https://www.twitter.com/_angelotheman) and form great connections on [LinkedIn](https://www.linkedin.com/in/angelotheman) 😊

Introduction to the Linux Command Line 👨🏾‍💻

Angel Oduro-Temeng Twumasi — Fri, 14 Jul 2023 07:58:30 +0000

Introduction

The Linux command line is a powerful tool that lies at the heart of the Linux operating system. It provides users with direct access to the system, enabling them to interact with their computer through a text-based interface.

While the graphical user interface (GUI) offers convenience and ease of use, the command line remains an essential component for advanced users, administrators, developers, and those seeking efficient and precise control over their Linux environment.

Why Linux Command Line (CLI) ❓

The command line is the easiest and fastest way to get things done on practically any operating system.

I came across these quotes about the Linux CLI which summarizes why you should know how to use the CLI.

Give a person a GUI, and they'll click for a day. Teach a person the Linux CLI, and they'll script for a lifetime. ~ Anonymous

Another quote says

In the hands of a knowledgeable user, the Linux command line is a powerful tool that can turn the complex into the simple. ~ Larry Wall

It takes time to get used to the command line. However, a good knowledge of it would greatly enhance your workflow.

Here are some advantages of the command line:

The CLI allows for faster and more efficient interaction with the computer. With few strokes (literally 😎), you can execute tasks quickly without the need to navigate through menus or click options.
CLI-based tools and applications generally have lower system resource requirements. CLI programs often consume less memory and processing power, allowing for better resource allocation and system responsiveness.
The CLI excels in automation and scripting capabilities. By combining commands and writing scripts, you can automate repetitive tasks and create complex workflows.
CLI commands and scripts are portable and reproducible. Scripts written on one Linux machine can be easily executed on another with minimal modifications.
CLI provides access to advanced tools for system monitoring, network diagnostics, text processing, version control, and programming. These tools offer granular control, extensive customization options.
Embracing the CLI promotes learning and skill development. It enhances understanding of system operations, file management, and process control.

In this series, we will explore the essential concepts, commands, and techniques of the Linux command line.

We will cover the following:

File system navigation and manipulation
Shell permissions and user management
Shell redirections and text processing
Shell initialization, variables and expansion

And many others 🔥

By the end of this series, you will have a solid foundation to navigate the command line with confidence and leverage its full potential to accomplish your goals efficiently.

Whether you are a beginner taking your first steps into the Linux command line or an experienced user looking to expand your skills, this guide will provide you with the knowledge and insights necessary to become proficient in the Linux command line.

So, let's embark on this adventure together and unlock the power and versatility of the Linux command line! 💪🏾

Let's get interactive on Twitter and LinkedIn.

Master Git Commands with This Handy Cheat Sheet 📜

Angel Oduro-Temeng Twumasi — Fri, 30 Jun 2023 15:39:34 +0000

Git, the widely used distributed version control system, has revolutionized the way developers collaborate and manage their codebases. Whether you're a seasoned developer or just starting your coding journey, having a solid understanding of essential Git commands is crucial for maintaining an efficient workflow and ensuring the integrity of your projects.

As said by Ben Collins-Sussman, Co-founder of Google Code 👇🏾

Git is a powerful tool for distributed version control. It is a way to ensure that your project evolves gracefully over time, no matter how many people are working on it.

Now steal this git cheat sheet I prepared for you 😀

🔗Configurations

Configure your name. This would serve as the author of the commit : git config --global user.name "[fistname lastname]"
Configure your email. This would serve as the email of the author : git config --global user.email "[your_email]"

🌱Initialization

Initialize a new Git repository : git init
Create a local copy of a remote repository : git clone <repository_url>
Add a remote repository : git remote add <remote_name> <remote_url>

📝Basic Workflow

Add a file to the staging area : git add <filename>
Add all files to the staging area : git add .
Commit changes to the repository : git commit -m "[commit_message]"

🔁Updating and Publishing

Publish all local commits to a remote branch : git push <remote_name> <branch_name>
Publish all local commits to a new branch : git push -u <remote_name> <branch_name>
Update the local repository : git pull
Download remote changes without merging : git fetch

🌿Branches

Create a new branch : git branch <branch_name>
Switch to a branch : git checkout <branch_name>
Create a new branch and switch to it : git checkout -b <branch_name>
List all the branches : git branch -a
Determine your current branch : git branch

🔀Merging

Combine changes of one branch to your current branch : git merge <branch_name>
Reapply commits on top of another base commit : git rebase <branch_name>

🔃Resets

Discard all local changes : git reset --hard HEAD

🔍Status and History

View the status of the working directory : git status
Show difference between commits or the working directory : git diff
Show commit history : git log
Display who last modified each line of a file : git blame

💼Additional commands

Remove untracked files : git clean -f

Useful tips ✍🏾

Don’t EVER commit private keys / Api keys / certificates.
Use descriptive commit messages and branch names.
Create a branch for every new feature, and delete the branch once the feature is merged into main.
Ignore some files using a .gitignore file.
Regularly update and sync with remote repositories
Use git alias for frequently used commands.

Visit Atlassian or GitHub Education to read more on other advanced git commands🔥

In conclusion, mastering Git commands is crucial for efficient version control and collaboration in software development, enabling developers to effectively manage projects and streamline workflows.

Did you learn anything new ❓ Share it in the comments.

Let's get interactive on Twitter and LinkedIn

Follow my projects on GitHub

Happy coding 👨🏾‍💻

Flowchart Wizardry: Master the Art of Visualizing Algorithms 😎

Angel Oduro-Temeng Twumasi — Tue, 27 Jun 2023 19:16:54 +0000

In my previous article, we looked at Pseudocode and its application in problem solving as a developer.
In this article, we would consider Flow charts, which is basically the graphical representation of Pseudocode.

Flowcharts Explained

Flowcharts makes it easier for developers to communicate clearly the algorithm used to solve a particular problem. This in turn makes it easier for the audience to grasp the concepts and for other developers to easily code this out.

Flow charts are a part of the Unified Modelling Language, which provides a broader range of diagrams that cover various aspects of system design and modelling.

Uses of Flow charts

Flow charts provide a visual representation of all processes or workflows used to solve a problem.
They serve as a common language for sharing and discussing problems. This means, they are not tied to a specific programming language and hence makes collaboration and communication easier between other developers and stakeholders.
They also serve as great tools for education and training purposes especially for beginner programmers.

Flow Chart Symbols

For flow charts to foster easy communication of thought process of developers, there must be guidelines for this.

Let's have a look at the six (6) basic symbols which are widely used.

Now let's explain them.

Terminator: This represents the start and end points of the flow diagram / algorithm that is represented.
Decision: This represents a question to be answered either YES or NO. The flowchart path may split to different branches depending on the answer.
Process: This represents an action taken or a function. It is the most widely used of all the symbols.
Document: This is used to indicate a point in the process where information is documented or recorded.
Data: This represents the input of data into the flowchart. This input is then processed in the flowchart.
Direction of flow: As the name clearly suggests, it determines where every process leads. This makes it easier to trace the logic being explained to solve a particular problem.

How to draw flowcharts

Clearly understand the process or algorithm you want to represent in the flowchart. Identify the starting point.
Identify the symbols needed. Each symbol represents a specific action or decision point in the process.
Start with the start/end symbols. Place them at the beginning and the end of the flowchart.
Add process, decision symbols as and when necessary. Also include input/output if the process requires a user input or generates output.
Add annotations if needed to provide additional details about specific steps.

Worked Examples

In this section, we would solve the same problems in my previous article using flowcharts.

Problem Statement 1
Write an algorithm to calculate the product of two numbers given by a user

Solution

Problem Statement 2
Write an algorithm that reads 3 numbers and writes them all in a sorted order

Solution

Problem Statement 3
Write an algorithm to print the first 20 numbers in the Fibonacci sequence (Read about the Fibonacci sequence)

Solution

Problem Statement 4
Develop an algorithm to calculate a running sum

If you wrote the Pseudocode for this in my previous article, go ahead and translate this into the flowchart. Drop your shareable link in the comment section.

You can use the following to draw the charts.

Flowcharts serve as a powerful visual tool for representing the logic of an algorithm or process. They offer a clear and concise way to communicate complex ideas, making them an invaluable asset in various fields, including software development, engineering, project management, and problem-solving.

Let's get interactive on Twitter and LinkedIn.

Follow me if you found this content helpful 🤝.

Happy programming 🥂

DEV Community: Angel Oduro-Temeng Twumasi

How to Migrate Azure Snapshots with Ease: Single and Multiple Scenarios

Introduction

Why Migrate Snapshots?

Prerequisites

Migrating a Single Snapshot

Migrating Multiple Snapshots

Reference Links

Conclusion

Getting Started With Terraform For Infrastructure Provisioning 🛠️

Why Terraform?

Understanding the Basics

What is Terraform?

Overview of Architecture and Workflow

Key Components

Providers

Resources

Modules

Setting up your Environment

Writing Your First Configuration

Basic Configuration File

Provider Configuration:

Resource Definition:

Variables:

Outputs:

Writing your first main.tf file

Understanding the Initialization Process and Its Output

Terraform Commands

Practical Example: Setting Up an EC2 Instance with a VPC

Variables and Outputs

Reference Links

Conclusion

Git Branching Strategies for DevOps: Best Practices for Collaboration

Introduction

Prerequisites

Introduction to Git Branching in DevOps

Understanding Git Branching

Key Concepts:

Git Branching Strategies

Trunk-Based Development

Advantages

Disadvantages

GitHub Flow

Advantages

Disadvantages

Git Flow

Advantages

Disadvantages

Feature Branching (Feature-Based Development)

Advantages

Disadvantages

Summary Table

Strategy

Key Feature

Main Advantage

Main Disadvantage

Choosing the Right Strategy

Team Size

Team Size

Recommended Strategies

Reasoning

Deployment Frequency

Deployment Frequency

Recommended Strategies

Reasoning

Best Practices For Collaboration

Effective Communication

Code Reviews and Pull Requests

Handling Conflicts and Merges

Integrating with CI/CD

Helpful links

Conclusion

How to Set Up GitHub Actions for Continuous Integration

Introduction

Benefits of Continuous Integration

Introduction to GitHub Actions

Understanding a Github Action Workflow

Components of a workflow

Build an example workflow

Step-By-Step Guide

Writing your first `main.tf` file