Little bit about the project - SwiftWave

SwiftWave is a self-hosted lightweight PaaS solution to deploy and manage your applications on any VPS.

Website - https://swiftwave.org/ Github - https://github.com/swiftwave-org/swiftwave If you like the intiative give it a ⭐ star in GitHub.

Why did I decide to start developing this open source PaaS?

Incentive Motive - I am absolutely exhausted from doing LeetCode. I don't usually enjoy CP or Leetcode, but need to do for placements. I began questioning if I really had a problem being consistent for long time (at-least 6 months). I therefore made an effort to push myself to create a project that I will stick with for a very long period.

Passive Motive - I like development and computer science core concepts so much and on every week build something for just fun or for hackathon. Anyway I don't want to spare money for deployment, so used Heroku, then moved to AWS EC2 (free tier) after getting familarized with linux. Many times my friends reach out to me for deploying in EC2.

While I was learning k8s and preparing for CKA, I amazed by it's internals & started thinking to build something lightweight with cool UI/UX. That's where it all get started.

Target of Building Swiftwave -

• Being lightweight : Swiftwave + Postgres + HAProxy + UDP Proxy = ~180MB of system. So leaving a lot of room for your deployed apps.

• Scalable : This isn't meant for huge-scale operations - Kubernetes handles that. Instead, it's aimed at meeting the needs of small startups, individual users, home labs, and internal company tools.

• Full-Featured: Swiftwave offers a wide range of capabilities. Visit swiftwave.org to explore all the features available in the platform.

Sprint vs Continuous Development

Before this project, I always go in Hackathon Mode for building project, giving all my free time. After launching the project, I often lost the motivation to keep maintaining it.

With Swiftwave, I started the same way but quickly realized this approach wouldn't work long-term. So, I switched it. For the first time, I tried a more structured approach, dedicating a consistent 1 to 1.5 hours daily to the project. This method proved effective. After a year of steady effort, we've successfully released a stable version of Swiftwave.

A small effort every day builds more than occasional bursts of productivity.

DSA is not useless

While I initially expressed disinterest in LeetCode, I don't find Data Structures and Algorithms (DSA) boring or unimportant. Many people think DSA is only useful for job interviews, but that's not the case.

Over the past year, I've applied DSA concepts in various parts of my projects. This experience has shown me that DSA knowledge is crucial in software development. However, it's worth noting that real-world problem-solving often takes more time than the quick solutions expected in interview.

For instance, in Swiftwave, we implemented a feature for uploading code directly to deploy apps. On the frontend, we create a tar archive of the project to send to the server. For NodeJS apps, we needed to exclude the 'node_modules' and other folder by following .gitignore rules.

Our first attempt at this was inefficient, taking about 30 seconds just to scan files, apply ignore rules, and create the archive.

In the end, we used a tree-based method to organize files and handle .gitignore rules. This new approach was much faster, finishing everything in about half a second."

Source Code of tartplus - https://github.com/swiftwave-org/tartplus

Automation is a Must

For those starting an open source project with long-term maintenance in mind, automation is crucial. Initially, it's often a one person project or the work of a very small team.

Alongside maintaining a OSS project, maintainers have their full time job or academics. So, It's vital to automate all repetitive tasks, allowing maintainers to focus solely on coding and reviews.

In swiftwave, we have various things -

• *.swiftwave.xyz DNS Resolver

• APT Repository - http://deb.repo.swiftwave.org/

• RPM Repository - http://rpm.repo.swiftwave.org/

• Custom build images for some one-click apps - https://github.com/swiftwave-org/app-store

• Deployment of documentation and websites

All these processes are automated.

For instance, I usually do a weekly release. I only need to draft and publish the release. Building APT & RPM packages for different architectures and uploading them to the repository server are all automated.

We primarily use Github Actions for nearly all our automation needs.

Testcases boring but gives peace of mind

When I first started contributing to open source last year, I was assigned in some issues for writing test cases for software. I also had to write integration tests during my GSoC'23 project with CircuitVerse. Back then, I found writing tests tedious.

However, now that I'm developing my project, my perspective has changed. I've realized how crucial it is to write tests and increase code coverage. With good coverage, I don't need to manually check if features are affected by changes.

For software like Swiftwave, which users install on their own servers, a buggy release could seriously disrupt their systems. It's essential to ensure nothing breaks in stable releases. Having numerous test cases makes this process smoother and more efficient.

It's not bad at all to reinvent the wheel

Sometimes, creating your own solution can be beneficial. Swiftwave needed a pubsub system and queueing mechanism. While RabbitMQ and Redis are common choices, they use up valuable server resources, leaving less for deployed apps.

My solution? I built an in-memory pubsub and persistent task queueing system with using goroutines. This approach uses minimal resources. As a result, Swiftwave typically runs using only about 45MB of RAM.

Swiftwave with all this things takes ~45MB of ram most of the time.

However, we've kept it flexible. Users can still configure Swiftwave to use Redis or RabbitMQ instead of the built-in system if they prefer.

Changes in POV of Open Source

In the 'Indian YouTube Space', there's often too much focus on just contributing to open source, which might have changed what open source is really about. I used to think this way too.

Contributing to open source shouldn't feel forced. Here's a better approach:

• Start by using open source software

• Keep using it if you like it

• If you find an issue or want a new feature, try to help fix or add it

• Create your own open source projects that can help others

• If a project dependency isn't working well, try to fix its issues

• Engage in conversations and forums, helping others who are stuck

Project Maintainers, Creator become more happy when you use their products.

Why Open Source code matters ?

Swiftwave is primarily built on two key softwares: Docker Swarm and HAProxy.

To develop various features, I had to understand how these tools work. This led me to explore several repositories:

• Docker Engine - https://github.com/moby/moby

• Docker CLI - https://github.com/docker/cli

• Libnetwork - https://github.com/moby/libnetwork

• HAProxy DataplaneAPI - https://github.com/haproxytech/dataplaneapi

One particular challenge was implementing direct SSH support for applications. I delved into the code for 'docker exec', which was quite complex. After grasping the concept, I was able to implement a similar feature in Swiftwave.

The End

Developing Swiftwave has been an exciting and challenging journey that I want to continue long-term. It has been a great learning experience for me.

There's still lot of rooms for improvement in Swiftwave to make it an even more dependable deployment tool. We have many areas we'd like to enhance in the future.

Website - https://swiftwave.org/ Github - https://github.com/swiftwave-org/swiftwave If you like the intiative give it a ⭐ star in GitHub.

Throughout this week, the main tasks involved were -

• Update the docker setup to make it more convenient

• Test the docker setup in all OS [Linux, Mac, Windows]

• Rewrite Documentation

Revamp Docker Setup

The main problems with the current setup are -

1. In the docker file, it copies all the source code and installs dependencies

2. The image and process inside the container run as root user

3. For this reason, whenever some dependencies or codebase changes the docker image rebuild and which takes lots of time

4. As the process runs as a root user, some file changes from the container give permission errors in a code editor.

5. As we install all the dependencies at the time of building the image, there is no possibility to cache the dependencies

Solution -

The solution is inspired by the GitHub Codespaces working principle.

👀 How do codespaces work?

1. It has a Dockerfile of the application

2. It starts the container with a sleep infinity to prevent it from terminating after the start

3. Then, it uses attach or exec to attach the container

4. Then, it runs a setup.sh to install all dependencies and prepare the4 environment

5. Then it runs boot.sh to start the application

🏄 Let's do the same for CircuitVerse project

1. Prepare the Dockerfile. This will only contain the ruby and nodejs environment. As well as it will have a non-root user with the same user id and group id of the host.

   We will provide host's group id and user id by build arguments

    FROM ruby:3.2.1
   
    # Args
    ARG NON_ROOT_USER_ID
    ARG NON_ROOT_GROUP_ID
    ARG NON_ROOT_USERNAME
    ARG NON_ROOT_GROUPNAME
    ARG OPERATING_SYSTEM
   
    # Check mandatory args
    RUN test -n "$NON_ROOT_USER_ID"
    RUN test -n "$NON_ROOT_GROUP_ID"
    RUN test -n "$OPERATING_SYSTEM"
    RUN test -n "$NON_ROOT_USERNAME"
    RUN test -n "$NON_ROOT_GROUPNAME"
   
    # Create app directory
    RUN mkdir /circuitverse
    # Create non-root user directory
    RUN mkdir /home/${NON_ROOT_USERNAME}
    # Create non-root vendor directory
    RUN mkdir /home/vendor
    RUN mkdir /home/vendor/bundle
    # set up workdir
    WORKDIR /circuitverse
   
    # Set shell to bash
    SHELL ["/bin/bash", "-c"]
   
    # install dependencies
    RUN apt-get update -qq && \
     apt-get install -y imagemagick shared-mime-info libvips sudo make cmake netcat libnotify-dev git chromium-driver chromium --fix-missing && apt-get clean
   
    # Setup nodejs and yarn
    RUN curl -sL https://deb.nodesource.com/setup_16.x | bash \
     && apt-get update && apt-get install -y nodejs && rm -rf /var/lib/apt/lists/* \
     && curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - \
     && echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list \
     && apt-get update && apt-get install -y yarn && rm -rf /var/lib/apt/lists/*
   
    # If OPERATING_SYSTEM is Linux, create non-root user
    RUN if [[ "$OPERATING_SYSTEM" == "linux" ]]; then \
        # create non-root user with same uid:gid as host non-root user
        groupadd -g ${NON_ROOT_GROUP_ID} -r ${NON_ROOT_GROUPNAME} && useradd -u ${NON_ROOT_USER_ID} -r -g ${NON_ROOT_GROUPNAME} ${NON_ROOT_USERNAME} \
        && chown -R ${NON_ROOT_USERNAME}:${NON_ROOT_GROUPNAME} /circuitverse \
        && chown -R ${NON_ROOT_USERNAME}:${NON_ROOT_GROUPNAME} /home/${NON_ROOT_USERNAME} \
        && chown -R ${NON_ROOT_USERNAME}:${NON_ROOT_GROUPNAME} /home/vendor \
        && chown -R ${NON_ROOT_USERNAME}:${NON_ROOT_GROUPNAME} /home/vendor/bundle \
        # Provide sudo permissions to non-root user
        && adduser ${NON_ROOT_USERNAME} sudo \
        && echo '%sudo ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers ;\
    fi
   
    # Switch to non-root user
    USER ${NON_ROOT_USERNAME}
   

   For macOS and windows we don't need non-root users because the volume mounting is worked as shared storage. So the permission error will not come

2. Next, we create a setup.sh which will install dependencies and migrate the database

    # !/bin/sh
   
    # Remove tmp folder
    rm -rf /circuitverse/tmp
   
    # Install ruby dependencies
    gem install bundler
    bundle config set --local without "production"
    bundle config set --local path "/home/vendor/bundle"
    bundle install
    # Install node dependencies
    yarn
    # Setup database
    bundle exec rails db:create
    bundle exec rails db:schema:load
    bundle exec rails db:migrate
    bundle exec rails db:seed
    # generate key-pair for jwt-auth
    # if private.pem and public.pem does not exists
    if [ ! -f "/circuitverse/config/private.pem" ] && [ ! -f "/circuitverse/config/public.pem" ]; then
      openssl genrsa -out /circuitverse/config/private.pem 2048
      openssl rsa -in /circuitverse/config/private.pem -outform PEM -pubout -out /circuitverse/config/public.pem
    fi
   

3. Then we create a boot.sh to initiate setup.sh and then start the server

    #!/bin/bash
   
    # Delete server.pid if it exists
    rm -f /circuitverse/tmp/pids/server.pid 2>&1
   
    # Run setup
    echo "Setup project"
    ./bin/docker/setup
   
    if [[ "$OPERATING_SYSTEM" == "linux" || "$OPERATING_SYSTEM" == "mac" ]]; then
      if [ ! -d "${HOST_CURRENT_DIRECTORY%/*}" ]; then
        sudo mkdir -p "${HOST_CURRENT_DIRECTORY%/*}"
      fi
      # Setup symbolic link for solargraph
      if [ ! -L "$HOST_CURRENT_DIRECTORY" ]; then
        sudo ln -s -T /circuitverse "$HOST_CURRENT_DIRECTORY"
      fi
      # Start solargraph server in background
      bundle exec solargraph socket --host="0.0.0.0" --port=3002 &> /dev/null &
    fi
   
    # Start server
    ./bin/dev
   
    # Start bash if previous command exits
    /bin/bash
   

4. Now, we need to prepare the docker-compose.yml. As you can see still now we haven't copied the source code in the image or anywhere.

   We will mount the codebase to the container at /circuitverse location to make it easy to edit files and keep all files in sync

    ....
      web:
        build:
          context: .
          dockerfile: Dockerfile
          args:
            - NON_ROOT_USER_ID=${CURRENT_UID}
            - NON_ROOT_GROUP_ID=${CURRENT_GID}
            - OPERATING_SYSTEM=${OPERATING_SYSTEM}
            - NON_ROOT_USERNAME=${NON_ROOT_USERNAME}
            - NON_ROOT_GROUPNAME=${NON_ROOT_GROUPNAME}
        command: sleep infinity
        volumes:
          - .:/circuitverse:rw
          - ./config/database.docker.yml:/circuitverse/config/database.yml:rw
          - ruby_bundle:/home/vendor/bundle:rw
        cap_add:
          - SYS_ADMIN
        ports:
          - "3000:3000"
          - "3001:3001"
          - "3002:3002"
          - "3035:3035"
          - "3036:3036"
        depends_on:
          - db
          - redis
        environment:
          REDIS_URL: "redis://redis:6379/0"
          CIRCUITVERSE_USE_SOLR: "false"
          DOCKER_ENVIRONMENT: "true"
          NODE_ENV: "development"
          HOST_CURRENT_DIRECTORY: $PWD
          OPERATING_SYSTEM: $OPERATING_SYSTEM
    ....
   

5. Everything is ready. But there is an issue, we can't run this using docker-compose up. We need to set the NON_ROOT_USER_ID NON_ROOT_GROUP_ID OPERATING_SYSTEM environment variables. Also, need to start the server by attaching to it. So write a script for that

    #!/bin/bash
   
    # Detect operating system [linux, macos] with uname
    DETECTED_OS=$(uname -s | tr '[:upper:]' '[:lower:]')
   
    # If operating system is linux
    if [ "$DETECTED_OS" = "linux" ]; then
      # Set environment variables temporary
      export CURRENT_GID=$(id -g)
      export CURRENT_UID=$(id -u)
      export NON_ROOT_USERNAME="user"
      export NON_ROOT_GROUPNAME="user"
      export OPERATING_SYSTEM="linux"
      # Check if docker and docker compose are installed
      if ! command -v docker &>/dev/null; then
        echo "Docker is not installed. Install docker : https://docs.docker.com/engine/install/"
        exit 0
      fi
      # Check if rootless docker is available
      if docker ps &>/dev/null; then
        # Run docker-compose up
        docker compose up -d --build
        # Run docker-compose exec web bash
        docker compose exec web bin/docker/boot
        # Run docker-compose down
        docker compose down
      else
        # Run docker-compose up as root user
        sudo docker compose up -d --build
        # Run docker-compose exec web bash as root user
        sudo docker compose exec web bin/docker/boot
        # Run docker-compose down as root user
        sudo docker compose down
      fi
    fi
   
    # If operating system is macos
    if [ "$DETECTED_OS" = "darwin" ]; then
      # Set environment variables temporary
      export CURRENT_GID="0"
      export CURRENT_UID="0"
      export NON_ROOT_USERNAME="root"
      export NON_ROOT_GROUPNAME="root"
      export OPERATING_SYSTEM="mac"
   
      # Check if docker and docker compose are installed
      if ! command -v docker &>/dev/null; then
        echo "Docker is not installed. Install docker : https://docs.docker.com/engine/install/"
        exit 0
      fi
   
      # Run docker-compose up
      docker compose up -d --build
      # Run docker-compose exec web bash
      docker compose exec web bin/docker/boot
      # Run docker-compose down
      docker compose down
    fi
   

   This one script is responsible to fetch user id and group id and set temporary environment variables.

   This will start the container and then run bin/docker/boot inside the container. And after the container got exited, it run docker compose down to stop other containers as well.

6. 💁 That's all.

Test docker setup

We have tested this docker setup in

• Windows [both Hyper-V and WSL2]

• Linux

• MacOS

It works on all os without any issues.

For Windows, we have written a PowerShell script to support it as well.

# Set environment variables
$env:NON_ROOT_USERNAME = "root";
$env:NON_ROOT_GROUPNAME = "root";
$env:OPERATING_SYSTEM = "windows";
$env:PWD = (Get-Location).Path;
$env:CURRENT_UID = "0";
$env:CURRENT_GID = "0";

# Check if docker is available
if (Get-Command -Name "docker" -ErrorAction SilentlyContinue) {
    # Run docker-compose up
    docker compose up -d --build
    # Run docker-compose exec to boot the image
    docker compose exec web bin/docker/boot
    # Run docker-compose down
    docker compose down
}
else {
    Write-Output "Docker is not available. Follow this documentation to install docker: https://docs.docker.com/desktop/install/windows-install/"
}

You can get more details in this PR - https://github.com/CircuitVerse/CircuitVerse/pull/3913/

Rewrite Documentation

Many changes were made to the project for improving the development experience. So it's very important to update the documentation as well.

We have written the documentation for Remote Development Platforms, as well as separate documentation for each operating system for setting up a docker-based environment + local installation.

Additionally, working on the reviewed PRs. Making some changes on the PR to make it ready to merge.

That's all for this blog. If you liked this subscribe to the newsletter.

🎉 Finally, my project SwiftWave has been published on GitHub.

SwiftWave is a self-hosted lightweight PaaS solution to deploy and manage your applications on any VPS without any hassle

GitHub Link - https://github.com/swiftwave-org/swiftwave

If you like the initiative, star⭐ the project on GitHub.

You can check out the blog on the phase 1 report here: https://blog.circuitverse.org/posts/tanmoy_sarkar_phase_1_report/

You should check other blogs here: https://blog.circuitverse.org/

These two weeks were full of debugging and much more learning. Finally, many issues were resolved in these weeks. So, let's get started.

Week 7

RBS Rails

Finally, the rbs_rails issue was resolved. Discussion thread here.

The main issue was this -

The project previously uses ActionMailer for notifications. While migrating to Noticed Gem, we can't use the same table for notifications as we don't want to drop the data. So used has_noticed_notifications to override the model name to use NoticedNotifications the table.

There were some associations -

 has_many :notifications, as: :notifiable

This line was causing the issue of preventing rbs_rails gem from generating signatures for models.

After replacing the association with

has_many :noticed_notifications

All the issues are fixed!

Running this task rbs_rails:generate_rbs_for_models will generate the signature for models and the signature for dependencies as well.

After this, we can customize those signature files according to our need to add the custom functions we wrote in our models.

As we have previously set up steep gem to verify rbs signature, that speed up the process of writing rbs annotations.

If you haven't yet checked out RBS installation and CI integration with steep, you should check out this blog: https://tanmoy.online/week-4-circuitversegsoc23

The docs provided by RBS https://github.com/ruby/rbs/blob/master/docs/rbs_by_example.md and this blog https://www.honeybadger.io/blog/ruby-rbs-type-annotation/ helps a lot to understand RBS easily.

All PR: https://github.com/CircuitVerse/CircuitVerse/issues/3792

Week 8

This week's main target was to work on Remote Development Platform integrations.

Many changes have been made in the development environment over the last few weeks. So it was necessary to verify the Gitpod setup and integrate new features. As well as integrate Github Codespaces for Remote Development.

We also will look into the improvement of docker-based local development.

Gitpod Remote Development

There is already gitpod setup in the project, but it has broken due to old version of Redis.

Universal APT repository hasn't the latest version of Redis, and sidekiq requires Redis > v7.0. So we added the Redis repository and gpg key, and it was fixed.

curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list
apt-get update && apt-get install redis

Now the GitPod is running, but it's missing all extensions.

After searching, I found that, due to Microsoft's latest Terms & Conditions, external editors or open source VSCode alternatives like VsCodium or Theia IDE can't use Visual Studio Marketplace to fetch Extensions. So there comes Open-VSX Registry, which hosts and distributes VSCode Extension without restriction. For more details, read this blog https://www.gitpod.io/blog/open-vsx

So we move the extensions from Visual Studio Marketplace to Open-VSX Registry.

vscode:
  extensions:
    - dbaeumer.vscode-eslint
    - rebornix.ruby
    - castwide.solargraph
    - wingrunr21.vscode-ruby

But some extensions like Ruby debugger & Ruby Rubocop Revived The extension is still not available on Open-VSX Registry. So here is the workaround, we can generate VSIX file and provide the links.

We can generate VSIX files very quickly.

• Clone extension repository & do npm install

• Install vsce plugin npm install -g @vscode/vsce

• Run vsce package to generate vsix file

• Now, we can upload it somewhere and provide the URL in the extension list.

For more, check this PR: https://github.com/CircuitVerse/CircuitVerse/pull/3892/

Github CodeSpaces Remote Development

Currently, the repository has no Github Codespace configuration so that we will introduce that.

Github Codespaces call this dev container, and we need the dev container configuration to be available to launch the project in the Github Codespaces environment.

We need a docker compose-based setup for our use case because we need Redis & PostgreSQL as databases to start the project.

This documentation was beneficial to understand the configuration - https://docs.github.com/en/codespaces/setting-up-your-project-for-codespaces/adding-a-dev-container-configuration/introduction-to-dev-containers

• First, we create a Dockerfile, which will hold only the Environment to run our project.

    FROM ruby:3.2.1
    # install dependencies
    RUN apt-get update -qq && apt-get install -y imagemagick shared-mime-info libvips && apt-get clean
    RUN curl -sL https://deb.nodesource.com/setup_14.x | bash \
     && apt-get update && apt-get install -y nodejs && rm -rf /var/lib/apt/lists/* \
     && curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - \
     && echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list \
     && apt-get update && apt-get install -y yarn && rm -rf /var/lib/apt/lists/* \
     && apt-get update && apt-get -y install cmake && rm -rf /var/lib/apt/lists/* \
     && apt-get update && apt-get -y install netcat && rm -rf /var/lib/apt/lists/
  

• Then we make a docker-compose.yml file that will contain the service's details

    version: "3.1"
    services:
      db:
        image: postgres
        environment:
          POSTGRES_DB: circuitverse_development
          POSTGRES_PASSWORD: postgres
      web:
        build:
          context: .
          dockerfile: Dockerfile
        ports:
          - "3000:3000"
        depends_on:
          - db
          - redis
        environment:
          REDIS_URL: "redis://redis:6379/0"
          CIRCUITVERSE_USE_SOLR: "false"
          DOCKER_ENVIRONMENT: 'true'
        command: sleep infinity
      redis:
        image: redis:7.0-alpine
  

• You can see the web service will start, and Github Codespace will attach to it. To prevent it from terminating, we used sleep infinity the command

• Now, we require two scripts.

  • setup.sh -> This script will be called when the container starts. Like database migration, dependency installation, etc.

  • boot.sh -> After the successful container setup, this script will start the application.

• Now, we can write devcontainer.json to complete the setup.

    {
        "hostRequirements": {
          "cpus": 4
        },
        "workspaceFolder": "/workspaces/CircuitVerse/",
        "dockerComposeFile": "docker-compose.yml",
        "service": "web",
        "features": {
            "ghcr.io/devcontainers/features/docker-outside-of-docker:1": {}
        },
        "waitFor": "onCreateCommand",
        "postCreateCommand": ".devcontainer/setup.sh",
        "postAttachCommand": {
          "server": ".devcontainer/boot.sh"
        },
        "customizations": {
          "vscode": {
            "extensions": [
                "dbaeumer.vscode-eslint",
                "LoranKloeze.ruby-rubocop-revived",
                "rebornix.Ruby",
                "wingrunr21.vscode-ruby",
                "KoichiSasada.vscode-rdbg"
            ]
          }
        },
  
        "forwardPorts": [3000]
      }
  

• service Key takes the service name, which should the process will attach.

• postAttachCommand Key declares the script, which should will after the setup process.

• We have also configured various extensions to provide convenience for developers. AS Microsoft powers Github Codespace, we have no issue using the extension from Visual Studio Code Marketplace.

For more details, check this PR: https://github.com/CircuitVerse/CircuitVerse/pull/3894/

Docker-based development environment

I have started working on this. Currently, the setup contains Docker configuration to run the app locally. But this is not suitable for faster development.

I have listed the issues here: https://github.com/CircuitVerse/CircuitVerse/issues/3914

I am trying to rebuild the Docker configuration to build a local environment by using the same concept that Github Codespaces used.

Here is the draft PR: https://github.com/CircuitVerse/CircuitVerse/pull/3913

In the next blog, I will explain these stuffs in detail.

🏂 Thank you for getting it a read

You can check out the discussion thread here -> https://github.com/pocke/rbs_rails/issues/260

As this will take a long time to resolve, I moved to the following topic: writing missing integration test cases. It was the first time I listened to integration testing; I only knew about it before that. But it's crazy and can always help keep the UI flow unchanged regardless of changes.

As per the planning, I should cover these workflows by integration testing

• Profile Management

• Group Management

• Assignment management

• Project management

These tasks were pretty straightforward, like automating manual testing. Rails use capybara gem to execute integration testing with the Selenium web driver.

During writing test cases, one problem is that some UI fields like bootstrap-select require one to type and press enter after each entry to take effect. We can achieve this by using send_keys .

To make it easy, we build a function to wrap things

  def fill_in_input(input, with:)
    find(input).send_keys with
  end

Then, we can insert some text in the input and press enter

fill_in_input "#input_id", with: "test@test.com"
fill_in_input "#input_id", with: :enter

You can check out the PR's here -> https://github.com/CircuitVerse/CircuitVerse/issues/3854

GSOC Midterm evaluation is approaching soon. We need to work on wrapping all the work and prepare a blog about all the progress in phase 1 of GSOC.

The official blog is published here -> https://blog.circuitverse.org/posts/tanmoy_sarkar_phase_1_report/

You can find out all the blogs of CircuitVerse here -> https://blog.circuitverse.org/

Thank you for giving it a read.

The main objectives of this week were

• Learn RBS to start working on it

• Generate code coverage report and write the missing unit-tests

• Split Solargraph PR to small PRs for better review

Learn RBS to start working on it

At first, I thought RBS was pretty straightforward, and I needed to write the type signature of defined functions. But that's not enough.

We know Rails use the metaprogramming concept hugely. So it's essential to have some extra type signatures in ActiveModel, ApplicationRecord, and Controllers.

But, I found a much easier way for this at last.

We can generate an untyped version of the *.rbs file for an *rb file

bundle exec rbs prototype rb <ruby_file_path> > <output_rbs_file_path>

After the *rbs file is generated, we can edit the argument type and return type to make it works.

In the coming weeks, I think to complete writing rbs annotations for the codebase.

Generate code coverage report and write the missing unit-tests

As I was learning RBS, I focused on making some active contributions. So picked the next task -> writing unit test for missing code coverage.

I need first to analyze which unit-test cases are missing. I use simplecov with HTMLFormatter which generates coverage reports as HTML.

From the report, It's nice that most of the code has unit tests, and a few codes have only missing tests.

Created this issue to have a track -> CircuitVerse/CircuitVerse#3817

This issue has all the linked PRs

This rspec-rails gem has this great documentation https://rspec.info/features/6-0/rspec-rails/controller-specs/, and it makes the task easier.

Split Solargraph PR to small PRs for better review

Last week, I finalized solargraph-integration PR CircuitVerse/CircuitVerse#3766

See the changes in the PR, it's hard to review this large PR.

So my mentor suggested splitting this PR into smaller PRs. The main problem with smaller PRs was - We usually do a checkout from the master/main branch to do the changes. But in this case, I need the previous PR's file merged before moving. It's not practical as maintainers will do reviews in their free time and there will be a long waiting time. So found a better way.

• Checkout from master/main branch to branch_A

• Do the changes in branch_A and raise Pull Request for changes in branch_A

• Now, Checkout from branch_A to branch_B

• Do the changes in branch_B and raise Pull Request for changes in branch_B

• Do this as many times as we need .......

• After merging PR_A, we need to update branch_B against the master/main branch, which will make PR_B small. Do this until all PRs merge is completed.

We need to make sure that the PR's merged in the same order at the time of raising PR, else merge conflict can be arised

Here is the Issue, where I have listed all the PRs - CircuitVerse/CircuitVerse#3761

That's all for this week. Subscribe to the newsletter for more updates.

The scheduled task for this week was

• Write RBS Annotations for the codebase

RBS

What is RBS?

RBS is a type annotation system introduced in the Ruby programming language. Its purpose is to bring static typing capabilities to Ruby code. We can verify the type signature by using various tools like [steep, rbs, etc.]

RBS is released officially by Ruby.

Interesting Features

• Type Safety: RBS helps catch type-related errors early, improving code reliability.

• Tooling Support: Static type information enables advanced code editors to offer autocompletion and accurate error detection, enhancing developer productivity.

• Documentation and Readability: RBS annotations serve as documentation, making code easier to understand and maintain.

Setup

• Install rbs_rails gem

    gem install rbs_rails
  

• Generate tasks

    bin/rails g rbs_rails:install
  

• Run this to generate the rbs collection configuration file

    bundle exec rbs collection init
  

• Now simply run this to download the required gem's rbs file

    bundle exec rbs collection install
  

• We are going to use steep gem to type checking

• So, install steep gem

    bundle install steep
  

• Create Steepfile with this configuration

    target :app do
      signature "sig"
    end
  

• As per the configuration, it will check sig folder for our writer rbs annotation files for our codebase

Issues

But one problem with RBS is -> As it's fairly new to the market, there is not much support for RBS in all the libraries. So we face various issues regarding that.

In our case, while using rbs validate it was throwing RBS::DuplicatedMethodDefinitionError due to conflicting rbs code of meta-tags and activesupport gem.

After searching for various solutions and taking suggestions from the maintainer, the final solution to fix the issue was -

• Add meta-tags gem to ignore the list of rbs collection configurations like

    gems:
      # Skip loading rbs gem's RBS.
      # It's unnecessary if you don't use rbs as a library.
      - name: rbs
        ignore: true
      - name: steep
        ignore: true
  

• Copy the rbs file of meta-tags gem

• Modify them to remove duplicate definition issue

• And then copy-paste those files in sig/vendor/meta-tags folder

References -

Discussion Thread for the issue - https://github.com/ruby/rbs/issues/1359

PR - https://github.com/CircuitVerse/CircuitVerse/pull/3807/

Undercover CI

Undercover is a great tool to analyze untested code of a commit and do PR reviews.

SimpleCov is mainly used to generate the test details and undercover analyze the generated Lcov file.

Setup SimpleCov to generate the Lcov file

• Install simplecov and simplecov-lcov gem to :test group

• In the config/environments/test.rb file, paste this configuration file at the top

    require "simplecov"
    require "simplecov-lcov"
    SimpleCov::Formatter::LcovFormatter.config.report_with_single_file = true
    SimpleCov.formatter = SimpleCov::Formatter::LcovFormatter
    SimpleCov.start do
      add_filter(/^\/spec\//) # For RSpec, use `test` for MiniTest
      enable_coverage(:branch)
    end
  

• Now we need to load all the code beforehand for this analysis

• So, mark config.eager_load = true in configuration of test environment

• Now when we run our test suite, it will generate lcov file under coverage/lcov/<project_name>.lcov file.

Now, We need to setup undercover CI for PR review

The first and easier option is to use https://undercover-ci.com/ which has simple steps for installation. But the issue here is , it's paid for organization

So,we keep searching and found a opensource project undercover-checkstyle which can review the PR by using undercover CLI tool and use reviewdog to do the PR Review

For this, add undercover-checkstyle gem under :test group in Gemfile

In the CI workflow add this configuration

- uses: aki77/delete-pr-comments-action@v1
  with:
   token: ${{ secrets.GITHUB_TOKEN }}
   bodyContains: "[undercover]"
   noReply: "true"
- name: Run reviewdog
  env:
    REVIEWDOG_GITHUB_API_TOKEN: ${{ secrets.github_token }}
  run: |
    git fetch --no-tags
    reviewdog -reporter=github-pr-review -runners=undercover --fail-on-error

After the setup, it will provide a review of any PR.

Just for example, the github-actions bot will give a review like this. This will also delete previous comments to make the PR Review clean.

PR - CircuitVerse/CircuitVerse#3812 CircuitVerse/CircuitVerse#3818

That's all for this week. Subscribe to the newsletter for more updates.

The main tasks of this week -

• Integrate Vite Rails

• Initialization of RBS

Integrate Vite Rails

Purpose - We are mainly integrating Vite Rails and will move Simulator assets to Vite. Currently, CircuitVerse uses sprockets and esbuild to pack javascript files and serve through the asset pipeline.

So, What's the issue with the current setup?

The issue is mainly with development experience. When the developer modifies any Javascript / SCSS files, esbuild rebuilds the assets, and the user needs to refresh the page to see the changes, which is very time-consuming.

When Vite comes into the picture, It does not build the assets to a single *.js or *.css file.

The main features of Vite

• Lazy Loading: It does not bundle all the javascript in one single file and then serve. It simply sends one entry point file to the browser and will recursively load all the dependency javascript and compiled SCSS files to the browser.

• Hot Reload: Whenever there are any changes in javascript or SCSS files, the Vite client will manage to update that in the browser without refreshing the page. The entire page will be reloaded automatically if the 'Hot Reload' feature can't reflect any browser changes.

The end of the story is it will make the development experience much better than the previous setup.

Integration -

1. Install ruby_rails gem

    bundle install vite_rails
   

2. Run this to generate the configuration files

    bundle exec vite install
   

3. In config/vite.json you can put the Vite dev server's configuration

    {
      "all": {
        "sourceCodeDir": "app/javascript",
        "watchAdditionalPaths": []
      },
      "development": {
        "autoBuild": true,
        "publicOutputDir": "vite-dev",
        "port": 3036
      },
      "test": {
        "autoBuild": true,
        "publicOutputDir": "vite-test",
        "port": 3037
      }
    }
   

4. In the default config, it chooses app/javascript for entry points

5. We remove the simulator.js from esbuild and move to Vite by dragging the file to this directory

6. Now in the *.erb files, we need to replace javascript_tag with vite_javascript_tag

    <%= vite_javascript_tag "simulator" %>
   

7. Here is a catch, Vite loads this javascript and SCSS asynchronously, so the other scripts may fail.

   Assume you have some inline scripts required jQuery, but as Vite loads them asynchronously, the inline scripts will be executed without jQuery and throw a bunch of errors.

   We can resolve the issue by following this.

   1. vite_javascript_tag adds type=module and async tag to Script

   2. After async tags execution defer tags will be executed.

   3. After all assets are loaded, the load event will be fired.

   4. So the flow will be like

      1. Put vite_javascript_tag at the start or head of the HTML

      2. Wherever you have <script src="https://example.com/example.js"> use defer in it

          <script src="https://example.com/example.js" defer>
         

      3. In the usual Script, add the EventListener for load event

          <script>
          window.addEventListener("load", function() {
            // Your code goes here
          })
          </script>
         

      4. That's all

8. Then, we need to add Vite dev server in Procfile.dev to run it with Foreman

    vite: bin/vite dev
   

9. Now we can access the UI as usual, and Vite will take care of asset delivery and Hot Reloads.

PR - https://github.com/CircuitVerse/CircuitVerse/pull/3777

Initialization of RBS

Purpose - We know Ruby is a dynamically typed language. So type checking stuff is not available, which can lead to inconsistency in the codebase and create bugs by mistake. Ruby finally came up with RBS [Type Signature for Ruby], which adds support for static type checking. Which helps to solve two issues

• a) Static Type Checking Validation

• b) LSP Support

  • Some LSP like solargraph added support to provide Language Autocompletion based on the RBS files.

Integration -

1. For Rails, we install rbs_rails better support for Rails

    bundle install rbs_rails
   

2. Add .gem_rbs_collection in the .gitignore

3. Run rbs collection init to generate config files

4. Run rbs collection install to download rbs files of our Gem

5. We can use steep for static type checking

6. So add steep gem

    bundle install steep
   

7. Create Steepfile for its configuration

    target :app do
      signature "sig"
      check "app"
    end
   

8. That's all

But, there is some issue with RBS

1. like ActiveSupport and meta-tags have some overlapped rbs for Object class, so when we run rbs validate , it will give an error for duplicate definitions. Currently managed it by manually deleting the duplicate rbs annotation.

PR - https://github.com/CircuitVerse/CircuitVerse/pull/3807

In the coming week, I hope to finish this RBS stuff and fix the issue described before.

Thanks a lot for reading this blog. If you like to know more about my GSOC journey and want to explore more in development, subscribe to the newsletter.

This was a long time between getting the selection mail and the coding period. It allows me to learn more about some toolkits and libraries in detail required for this project. During this period, we have a couple of online discussions with the mentors to discuss the timeline [if any changes are required] and some topics of the project on which I will work in the coming weeks.

Officially the coding period begins on 29th May 2023

The main goal of these two weeks

• Integrate Ruby Debugger Support

• Integrate Solargraph LSP

And both the integrations should be compatible with the local setup as well as the docker container-based development setup

Integrate Ruby Debugger

Purpose - Currently this project has byebug gem for debugging purposes. Ruby has released its official debugger debug gem which works with various IDEs flawlessly with the visual interface which makes it very easy for developers and contributors to debug the application.

Implementation -

Install debug gem in the project.

Now, we can debug our application with VSCode with local installation by running this command

 bundle exec rdbg --open --nonstop --command -- bundle exec rails server -p 3000This will start the rails server and will attach the debugger with that process.

For debugging with VSCode, install the vscode-rdbg extension from marketplace.

Use v1.0.0 of this extension as the v2.0.0 version has some bugs. The bug has been fixed but the new version has yet not released

Now, in the VSCode we need to provide the settings for the debugger.

{
    "version": "0.1.0",
    "configurations": [
        {
            "type": "rdbg",
            "name": "Attach Debugger",
            "request": "attach"
        }
    ]
}

Now, we can attach to this and set breakpoints and debug the application.

We can also, debug the application with Chrome by providing --open=chrome option.

  bundle exec rdbg -n --open=chrome --command -- bundle exec rails server -p 3000

Now, we have two choices for debugging - any IDE or Chrome

To make it convenient for end-user,

• Created two files Procfile.dev for IDEs and Procfile.chrome.dev for chrome-based debugging

• In the /bin/dev file added chrome_debug flag check. If user provides chrome_debug flag while running the command it will open chrome for debugging else it will allow IDE to attach to the debugger

• /bin/dev for default mode and /bin/dev chrome_debug for chrome-based debugging

Make it compatible with a docker-based setup :

To accomplish this, we use the TCP-based remote debugging feature of debug gem.

In the dev/docker_run we put the command for socket-based debugging by providing host and port [3001]

bundle exec rdbg  --nonstop --open --host 0.0.0.0 --port 3001 -c -- bundle exec rails s -p 3000 -b '0.0.0.0'

So, now the debugger client can attach to the 3001 port and debug the application.

Now we need to expose the port by specifying the port mapping in the docker-compose.yml file

ports:
  - "3000:3000"
  - "3001:3001"

But, in the VSCode we need to add separate config for the debugger client to attach to tcp based remote debugging server

{
  "type": "rdbg",
  "name": "(Docker) Attach debugger [:3001]",
  "request": "attach",
  "debugPort": "localhost:3001",
  "showProtocolLog": true,
  "localfsMap": "/circuitverse:${workspaceFolder}"
}

🏂 Now this setup will allow debugging with VSCode or Chrome or Any other supported IDE with both local and Docker-based installation

Issues & Fixes -

During the integration, initially, it was failing as the Puma was configured to run multiple web workers at a time. For this, the debugger server process also got multiplied and want to start multiple processes either on the same Unix port or the same TCP port and the processes failed.

To resolve the issue, we change the default value of WEB_CONCURRENCY in /config/puma.rb to 0 for the development environment

This fixes the problem.

Pull Request - https://github.com/CircuitVerse/CircuitVerse/pull/3760

Integrate Solargraph LSP

Purpose - Currently, in this project, no Language Server is configured so we can't utilise autocomplete feature of IDE. The project is built on the Ruby on Rails framework which has used metaprogramming too much. So by default, the LSPs can't provide autocomplete or suggestions. So we have planned to integrate Solargraph as a Language Server to enable autocompletion and make it convenient for other contributors while working on this project.

Implementation -

The main gem for this solargraph LSP is solargraph .

We need to write the yard docs for the codebase to enable auto-completion. But in Rails, there are ActiveRecord models and many abstract classes which will make it complex to write yard docs for those. So, there is another gem [kind of extension of solargraph gem] called solargraph-rails which allows us to easily add yard docs for the ActiveRecord models.

We can learn how to write the yard docs from this documentation.

After completion of writing yard docs, we can enable this for many IDEs by the following guide

In VSCode, we can install ruby solargraph extension and got the autocompletion instantly.

For NeoVim, check out this discussion thread

For Sublime Text Editor, check out this discussion thread

For local setup, this works without any issues.

But now we need to make it compatible with a docker-based setup.

Here we utilize the TCP socket-based LSP server feature. Inside the container, we start the solargraph LSP server at port 3002 and expose it to the host

solargraph socket --host=0.0.0.0 --port=3002

Now, in the VSCode or other IDEs, we can configure to use this external solargraph server.

But here an issue comes, The plugin of IDE or Code Editor sends the current path of the file to the LSP server. The container and the current host directory is different, so the LSP fails to resolve and provide autocompletion.

To resolve this issue, I take this approach.

• Pass the current directory to the container by using the environment variable

  • In docker-compose, we can use $PWD to know the current directory path

• In the container, create a symlink at $PWD which points to /circuitverse/ in the container

Visual Representation

Thus the path inside the container resolves and the solargraph provides the autocompletion without any issue.

Checkout the PR, to know more about this approach

Pull Request - https://github.com/CircuitVerse/CircuitVerse/pull/3766

Redis is an open-source, in-memory data structure store, used as a database, cache, and message broker.

Memcached:

Memcached is a distributed, high-performance, in-memory caching system. It is used to temporarily store and serve frequently requested data from memory.

The similarity between Redis and Memcached

• Both are key-value storage

• Both system store data in memory or RAM

• Both Redis and Memcached are capable of running on multiple servers

Data structure

• Redis: This supports various ranges of data types based on the additional module and some built-in support. Some data types: strings, hashes, lists, sets, sorted sets with range queries, bitmaps, hyperlog, and geospatial indexes with radius queries

• Memcached: This support only string as the value in key-value entry

Transactions

• Memcached doesn't support transactions, although its operations are atomic.

• Redis provides out-of-the-box support for transactions to execute commands.

Architecture

• Redis uses a single-core architecture.

• Memcached implements a multi-threaded architecture by utilizing multiple cores.

Is there any speciality in Redis?

I know this portion is a little bit out of topic. But I have seen, in many blogs or youtube videos, shows redis is the key-value store only to just cache or temporary database.

So let's know a little bit about the full potential of Redis.

By enabling different modules, we can achieve the full potential

• RedisJSON to store JSON database directly in Redis.

• RedisGraph is a graph database built on Redis. This graph database uses GraphBlas under the hood for its sparse adjacency matrix graph representation.

• RedisSearch is a high-performance, full-text search engine that is built as a Redis module, offering efficient indexing and querying capabilities for text-based data within Redis.

• RedisTimeSeries is a Redis module for efficiently storing and querying time-series data, providing functionality for querying and analyzing time-stamped data, such as metrics, events, and logs.

• RedisBloom is a Redis module that provides scalable probabilistic data structures, such as Bloom filters, counting filters, and others, to support high-performance and memory-efficient data analysis and storage operations.

After seeing the modules and capability of Redis, we can only think of this

Now, what is best for caching?

Here we need to think about the data structure.

The best case to use Memcached over Redis

• The cached data format is plain string data to cache like HTML pages, CSS, JS or anything other than that.

• The dataset size is going to be very large in future

If these two conditions are satisfied then it will be best to go with Memcached.

In other cases, you can go with Redis.

We have reached the end of this blog.

This blog is intended for those who have learnt Docker Previously and want to revise that.

If you like this blog, give a 👍 and follow for more content.

Dockerfile

It's just a text file that contains instructions for building a Docker image.

It's just to automate the process that you do manually. So if you know how to do a process manually, you can learn it quickly.

Format

INSTRUCTION arguments

Instruction Set

In the below table, I have mentioned some sort terms. dir -> Directory, src -> Source, dst -> Destination

Ex : RUN "apt-get update" -> RUN ["apt-get", "update"] | | ENV <key>=<value> | Set environment variables | | EXPOSE <container_port> | Expose the port of a container to make it accessible in the same network | | ENTRYPOINT <command> | That command will execute as soon as the container boot up | | ENTRYPOINT [<command arg1>, <command arg2>] | We can break the command in command args also.
Ex : RUN "/bin/sh sample.sh" -> RUN ["/bin/sh", "sample.sh"] |

There is one more command, which you see mostly. CMD

The purpose of this command is to run the commands specified in arguments. It also has two formats, for example.

• CMD echo "hello-world."

• CMD ["/bin/sh", "echo", "hello-world"]

You might be confused now about the difference between RUN and CMD.

• RUN runs all the commands specified in the argument

• For CMD there is some particular case.

  • If you have provided some commands to run in docker run command, CMD is going to be ignored.

  • If you have listed multiple CMD statements, only the last CMD will be executed.

  • IF ENTRYPOINT in Dockerfile is provided, CMD it is going to be ignored.

  • In any container deployment platform, you can see the CMD to run manually.

🔵 As the blog's purpose is to give concise details of Dockerfile and CLI, we are not attaching Dockerfile examples here. But will create some blogs on Dockerfile and attach links to them.

Docker CLI

Arguments List

Image Specific Commands

List all local images

docker images

Build Image From Dockerfile in current directory

docker build . -t <tag_name>

Pull an image from Dockerhub

docker pull <image_name>
# example : docker pull redis

Delete an image

docker rmi redis

Remove all unused images

docker image prune

Container Specific Commands

Run a docker container from an image

docker run <image_name>

Now you can refer the Arguments List table to choose your required arguments

I am solving an question for example.

Let's assume, I need to create an container from image of redis with port mapping from container port 6379 to host port 6379 . The name will be redis-instance-1 . Make the instance detachable & run redis-server --requirepass "SECRET_PASSWORD" at its beginning.

docker run --name redis-instance-1 -d -p 6379:6379 redis redis-server --requirepass "SECRET_PASSWORD"

Its important to notice that , you need to pass all the arguments before providing the image name and entrypoint_command

List containers [only Running]

docker ps

List all containers [Stopped + Paused + Running]

docker ps -a

Start or Stop a container

docker start|stop <container_name or container_id>

You can get the Container ID by running the command for list all container

Remove a stopped container

docker rm <container_name or container_id>

Attach to the current process of container

docker attach <container_name or container_id>

Run a command in the container

docker exec <container_name or container_id> <command>

Example : Start a bash terminal in redis instance

docker exec -it redis /bin/sh

❓You may have a question. What's the difference between exec and attach, then

With attach, we attach to the process that's currently running in the container

But with exec, we can run a new process in a container without hampering the running process of the container

Log the data of the current process of the container

docker logs -f <container_name or container_id>

Inspect and grab all the details of a container

docker inspect <container_name or container_id>

It will return the details in an JSON format

Check the stats [CPU, RAM, Network, Storage usage] for all running containers

docker container stats

🏄 You have liked this blog and gained some knowledge, please consider to like & share with your friends.

This blog is focused on the situation when you need to handle a low number of users to access your AI models, like in a hackathon or a prototype of a product which may not be accessed by more than 500s people concurrently. More optimization and robust design are required for production usage. But this blog can be a good starting point.

🏊 Let's discuss the problem with Client-Server architecture.

We all know maximum AI models are resource-hungry operations and take at least from 1 second to up to 5 minutes, especially for large deep learning models.

• The main problem is that we can't run too many requests in a low-end system (2GB RAM, 2vCPUs).

• As we have 2 CPU cores, running more than two threads is impossible. As a result, the system crashed.

• If the processing time of the model exceeds Nginx/web gateway timeout, it will give the user an error and waste the system's resources.

  ---

🏂 Now, What's our approach?

We will take the microservice approach and split our system into three parts. So that user can get a message asap about the request received by the server and later can enquire about the result.

• Flask Web Server

• RabbitMQ as message broker and queue management [It comes as packaged software. We will use a cloud-based free one. I will discuss this in a later part]

• Worker process - will be responsible for running the input data on AI models.

Let's understand the overall architecture of the system by ⏬

Before going into more depth, let's know the process in short

1. The user will send the request to the server

2. The server will create an entry in a table with status processing

3. The server then sends the input and request ID to the RabbitMQ message broker

4. The worker process will receive the request ID and input. It will run the AI model and generate the output based on the received input.

5. Then the worker process will submit the result to the server and mark the request-id status as done.

6. During this, the end-user can request the server for its result. If the result is available to the server, the end-user will get the result else; the end-user will resend the request in a while.

   ---

👀 Detailed Concept

We will first clarify how this will work and solve our issue of limited resources. Then we will move to code.

1️⃣ Process New Request Coming From End-user

As soon as the request is received, the backend will do three tasks one by one

1. Make an entry in the Request Status Track Table to keep track of request

2. Push the request details <Request ID, Input> to the queue

3. Send an acknowledgement message to the user that the request is processing. Also, send the Request ID with the response so that the user can enquire about the result later

2️⃣ Consumer/Worker: Pop Process From Queue and Process It

The consumer/worker listens for new requests, and RabbitMQ is responsible for giving the task to its listeners. It will follow the following steps.

1. The worker will extract the Request ID and Input it from the received payload.

2. The worker will run the input to the AI Modal and prepare the output.

3. Then the worker will update the output and status to done by specifying the request ID. Now, this can be done in two ways -

   • Connect to the database directly

   • Call API of the backend [Recommended]

3️⃣ Fetch Result of Request by the End-user

After a fixed interval(for example, 5 sec), the end-user will request the backend to send the result of his query.

Now the process flow of the backend will be

1. It will check the status of the request by its ID.

2. If the status is still processing, the backend will tell the end-user about its status and will say to them to re-request later.

3. If the status is done, the backend will send the output to the end user.

That's all !

💻 It's Coding Time

⚠ Read This Note Before Approaching Coding Part

Using an actual AI model's code will complicate this writing. We prefer to simulate that by a long-run function.

As an example, we will calculate the factorial of a large number.

def calculate_factorial(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
    return result

For factorial(n), n > 150000, it takes more than 10 seconds to compute

It's perfect for our use case.

🕰 Current Backend In Flask

from flask import Flask, request

# Function to calculate the factorial of a number
def calculate_factorial(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
    return result

# create the Flask app
app = Flask(__name__) 

# route to calculate the factorial of a number
@app.route('/factorial', methods=['GET'])
def factorial_handler():
    no = int(request.args.get('no'))
    result = calculate_factorial(no)
    return str(result)

if __name__ == '__main__':
    app.run(debug=False)

Try to run the 5~6 requests at a time and see what happened

curl http://127.0.0.1:5000/factorial?no=150000

See, the last request takes more than 1 minute 💣💣.

As the processing time of the function increases, the waiting time per user will increase exponentially.

⏰ Time To Rebuild Our Backend

🟠 First, create a cloud-hosted RabbitMQ service

• Go to https://www.cloudamqp.com/ and create a free account

• Create a free RabbitMQ instance

• Click on the name of the instance

• Copy the URL from AMQP details.

🟡 Run An Redis Instance Locally

• You can follow the guide to install Redis in your system. https://redis.io/docs/getting-started/installation/

• Run the Redis server locally by running this command

    redis-server
  

🟢 Prepare the helper functions beforehand

We need to create some functions -

Implementation of publish_to_rabbitMQ(data):

import json
import pika

def publish_to_rabbitMQ(data):
    # Create connection
    connection = pika.BlockingConnection(pika.URLParameters("amqps://yyyyyy:xxxxxxxxx@puffin.rmq2.cloudamqp.com/yyyyyy"))
    channel = connection.channel()
    # Create queue . For now queue name is factorial_process
    channel.queue_declare(queue='factorial_process', durable=True)
    # Publish the message to the queue
    channel.basic_publish(exchange='', routing_key='factorial_process', body=json.dumps(data))
    # Close the connection
    connection.close()

Implementation of create_request(input) :

def create_request(input):
    # Generate a random ID
    random_id = str(uuid.uuid4())
    # Store the request in Redis
    redis_instnace.set(random_id, json.dumps({'input': input, 'status': 'processing', 'output': ''}))
    # Publish the request to RabbitMQ
    publish_to_rabbitMQ({'request_id': random_id, 'input': input})
    # Return the request ID
    return random_id

Implementation of get_request(request_id) :

def get_request(request_id):
    request_data = redis_instnace.get(request_id)
    if request_data:
        return json.loads(request_data)
    return None

Implementation of update_request(request_id, status, output):

def update_request(request_id, status, output):
    request_details = get_request(request_id)
    redis_instnace.set(request_id, json.dumps({'input': request_details['input'], 'status': status, 'output': output}))

🔵 Re-design Flask Backend

• We will remove the processing part from it

• Create two more APIs

  • /factorial/result?id=random: To fetch the results of the request

  • /factorial/update: To update the result and status of the request

from flask import Flask, request
from helpers import create_request, get_request, update_request

# create the Flask app
app = Flask(__name__) 

# route to queue the request
@app.route('/factorial', methods=['GET'])
def factorial_handler():
    no = int(request.args.get('no'))
    id = create_request(no)
    return id

# route to get the result
@app.route('/factorial/result', methods=['GET'])
def factorial_result_handler():
    id = request.args.get('id')
    result = get_request(id)
    return result

# route to update the result
@app.route('/factorial/update', methods=['POST'])
def factorial_update_handler():
    body = request.get_json()
    id = body['id']
    status = body['status']
    output = body['output']
    update_request(id, status, output)
    return 'OK'

if __name__ == '__main__':
    app.run(debug=False)

⚪️ Build The Consumer

import pika
import json
import requests

# Function to calculate the factorial of a number
def calculate_factorial(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
    return result

# Create a callback function
def callback(ch, method, properties, body):
    body = json.loads(body)
    request_id = body['request_id']
    print('Received request with ID: ', request_id)
    input = body['input']
    output = calculate_factorial(input)
    # Update the status to done
    requests.post('http://localhost:5000/factorial/update', json={'id': request_id, 'status': 'done', 'output': output})

def start_consumer():
    # Create connection
    connection = pika.BlockingConnection(pika.URLParameters("amqps://yyyyyy:xxxxxxxxx@puffin.rmq2.cloudamqp.com/yyyyyy"))
    channel = connection.channel()
    # Create queue . For now queue name is factorial_process
    channel.queue_declare(queue='factorial_process', durable=True)
    # Listen to the queue and 
    # call the callback function on receiving a message
    channel.basic_consume(queue='factorial_process', on_message_callback=callback, auto_ack=True)
    # Start consuming
    channel.start_consuming()

if __name__ == '__main__':
    start_consumer()

📢 Let's see that in action

Let's send a request to the backend server.

That's our request id 748879f5-6504-4fbf-823a-74e6c44a3357

The consumer is running 🔥. We can also see the consumer has received the request bearing id 748879f5-6504-4fbf-823a-74e6c44a3357.

We queried the server with the id. But that is still processing.

-> After some time 🕓, we rerun the query. And this time, we got our results. The result is too long to show here. So truncated the output.

curl http://127.0.0.1:5000/factorial/result?id=748879f5-6504-4fbf-823a-74e6c44a3357

> {"input": 150000, "output":"....truncated", "status": "done"}

🚀🚀 Congratulations. That's all.

• You can spin many consumers to make the resulting process much faster.

• Not only AI model, but you can also build many things based on this concept of microservice architecture.

• Whatever, with this design, when your userbase grows results may come a bit late but your backend will not be unresponsive. To make it faster you can spin more consumers.

⚡Some Optimization Tips

• The polling method is acceptable but is not suitable for large users. We can use WebSocket in place of polling to reduce network calls.

• We should consider deleting the processed request records from the database as they have no use.

• We can also consider using an in-memory database like Redis to store the data of requests.

• The endpoints must be secured so the internal consumer/worker can access them.

• Make the consumer/worker dockerize so it can be easy to run multiple consumers using Amazon EKS, ECS, or other services.

  ---

  If you liked this blog, share this blog and subscribe to the newsletter.

It's the ability of a piece of code to automatically update or re-render in response to changes in the data it is bound to.

Let's try to understand clearly by ⏬

Selling Price and Buying Price are two state variables on which the value of Profit depends.

In the case of a Reactive System,

The profit variable will be updated upon any changes in Selling Price or Buying Price.

In the initial state, Selling price is 500 and Buying Price is 300, So the Profit will be (500-300) = 200.

When we update buying Price to 100, the Profit is recalculated automatically and updated to (500-100)=400

In the case of a non-reactive system,

Upon any changes in Selling Price or Buying Price, the profit variable will not be updated until calculateProfit() gets called again.

So, In the initial state, Selling price is 500 and Buying Price is 300, So the Profit will be (500-300) = 200.

When we update buying Price to 100, the Profit remains the same as before. (500-300) = 200

🤔 Where is the Reactivity concept used?

The reactivity concept is in the ❤️ of all modern frontend frameworks (React, Next.js, Vue.js, etc.).

Some important parts where this concept and programming practice are used -

• useState hook of React.js

• re-render widgets when some bounded state variable got updated

🚀🚀 Let us start building a reactive system

Start with a simple non-reactive system

let buyingPrice = 200
let sellingPrice = 500

let profit;

function calculateProfit(){
    profit = sellingPrice - buyingPrice
}

calculateProfit()
console.log("Profit : "+profit) // Profit : 300

// Update the selling price
buyingPrice = 100

// call calculateProfit() to recalculate
calculateProfit()
console.log("Profit : "+profit) // Profit : 400

Let us begin creating a reactive system

Step 1: Create a Dependency Class

Manage the dependencies, who need to be notified when this data got updated or modified.

class DependancyTracker{
    constructor(){
        this.subscribers = []
    }
    // Register the function of dependent code
    depend(){
        if(target && this.subscribers.includes(target) !== true){
            this.subscribers.push(target);
        }
    }
    // Notify the dependent codes to act on update of this data
    notify(){
        for (let i = 0; i < this.subscribers.length; i++) {
            let func = this.subscribers[i];
            func(); // run the function
        }
    }
}

Let's see that in action

let track = new DependancyTracker();
let profit;
let buyingPrice = 200;
let sellingPrice = 400;

function calculateProfit(){
    profit = sellingPrice - buyingPrice
}

// Register the depndent code
target = calculateProfit
track.depend()
target()

// Initial profit 
console.log("Profit : "+profit) // Profit : 200

// Update the selling price
sellingPrice = 500

// Notify all the dependent codes for re-compute
track.notify(); 
// calculateProfit is also an part of the dependent codes.

console.log("Profit : "+profit) // Profit : 300

Step 2: Play with the getter and setter

A dictionary to store initial values

const data = {
    "buyingPrice" : 200
}

Let's set getter and setter for the specified key

let internalvalue = data.buyingPrice;

Object.defineProperty(data, "buyingPrice", {
    get: function() {
        console.log("Get trigerred");
        return internalvalue;
    },
    set: function(val) {
        internalvalue = val;
        console.log("Set trigerred")
    }
})

Let's see that in action

data.buyingPrice=900
console.log(data.buyingPrice)

Output -

Step 3: Create a watch function to make the process a little bit easy

function watch(func){
    target = func;
    target();
    target = null;
}

Step 4: Wrap up !!!

const data = {
    "buyingPrice" : 200,
    "sellingPrice": 400
}

let target = null;

class DependancyTracker{
    constructor(){
        this.subscribers = []
    }
    depend(){
        if(target && this.subscribers.includes(target) !== true){
            this.subscribers.push(target);
        }
    }
    notify(){
        for (let i = 0; i < this.subscribers.length; i++) {
            this.subscribers[i]();
        }
    }
}

Object.keys(data).forEach(key => {
    let internal = data[key];
    let dep = new DependancyTracker()

    Object.defineProperty(data, key, {
        get: function() {
            dep.depend(); // link target function
            return internal;
        },
        set: function(val) {
            internal = val; // set value
            dep.notify(); // notify dependent variables linked funtion
        }
    })

})

// Watch function
function watch(func){
    target = func;
    target();
    target = null;
}

// Link calculateProfit function in watch
watch(() => {
    data.profit = data.sellingPrice - data.buyingPrice
})

console.log("Profit : "+data.profit) // Profit : 200

data.sellingPrice = 700
console.log("Profit : "+data.profit) // Profit : 500

data.sellingPrice = 900
console.log("Profit : "+data.profit) // Profit : 700

Congratulations 🎉🎉

You may have gained an amazing concept from this blog. If you like it, please share it with your friends.

While doing projects, we sometimes want to keep only one instance of a class and don't want to pass the instance of an object by argument in each function.

class ClassA {
      // sample codes
}

object1 = ClassA();
object2 = ClassA();
object3 = ClassA();

In the above example, we want that when we call the ClassA constructor, every time it returns the same instance of an object in memory instead of creating a new thing every time the constructor is called.

When do we need Singleton Class?

Let's discuss the real-life use of singleton class.

• API Client : During website / android / ios / native application development, we usually need to design an API client to establish communication between our app and server. 90% of the time, the API request is protected by some sort of authentication mechanism.

  If we create an instance of an API client for sending each API request, we need to configure the client with authentication details (JWT Key, API Key, Bearer Token, etc.).

  But we don't want to do this thing again and again for each request. Here we can use the concept of Singleton Class and resolve the issue.

• Database Client : Like the issues for API Client, in the case of database client we have a limit on creating instances of objects of particular database clients. So we need to use only a single instance of Database Client / ORM Client in the whole project.

What is the concept behind Singleton Class?

In every programming language, we get a special type of variable static for class, which helps to keep only a single instance of the variable in all object instances of that particular class.

Let's get started learning this

• Let's define a dummy class

  class ExampleA{
    // Class variable
    int counter = 0;
    // Special function to create/get object of instance
    static ExampleA getInstance(){
    }
  }
  

• We need to create a static variable which will store instances of objects of their own class.

  class ExampleA{
    // Static variable
    static ExampleA instance;
    // Class variable
    int counter = 0;   
    // Special function to create/get object of instance
    static ExampleA getInstance(){
    }
  }
  

• But we don't want to create an instance of an object if it does not need anywhere in our program.

    // Static variable
    static ExampleA instance = null;
  

• Now, we came to the main part, designing the getInstance static function. In this function, we will return the instance of already existing object. If no object currently available, we will create

Kindly see the comments of the code to understand

class ExampleA{
  // Static variable
  static ExampleA instance = null;
  // Class variable
  int counter = 0;
  // Special function to create/get the object of instance
  static ExampleA getInstance(){
    // If no instance has already created, create a new one and assign it to an instance variable 
    if(instance == null) instance = ExampleA();
    return instance;
  }
}

• That's All 🎉🎉

Let's implement the logic in Java & Run

Code -

class ExampleA{
    static ExampleA instance;
    int counter = 0;

    public static ExampleA getInstance(){
        if(instance == null){
            instance = new ExampleA();
        }
        return instance;
    }
}

Write little bit driver code to test -

public class testProgram {
    public static void main(String[] args) {
        ExampleA object1 = ExampleA.getInstance();
        object1.counter++;

        ExampleA object2 = ExampleA.getInstance();
        object2.counter++;

        System.out.println(object2.counter);
    }    
}

Let's run the program By object1.counter++, the counter goes from 0 to 1. As the object2 is the same instance, by object2.counter++, the counter goes from 1 to 2.

Output -

2

🏊🏊 Nice, our output comes perfect, which means now in the program, where I want the object, I can simply call ExampleA.getInstance(), and access the function and values of the object.

Best Practice

If the language has concept of public and private methods of class, make sure to make the default constructor to private.

What's your task?

If you leave this after understanding, you gonna face issues..Better write a Singleton Class in your favourite language and post it in a comment for a reference for others.

Thank You 👼👼

Any issue, comment down

FlushMail - Anonymous Temporary Mail Service [Support files/attachment and immediate mail disposal]

You can access this here: https://flushmail.live and the link in the first comment.

Please leave feedback in the comments. If you would like a detailed blog on this project/mailing system or any other topic, feel free to let me know in the comment section.

I am working on its documentation part, ASAP it gets ready I will update that. I am going to extend this one project and have some ideas to work on an email privacy tool. If anyone want to collaborate please give a reply

You can host your product at Zero Cost.

AWS Activate program helps to begin your tech startup journey at zero cost by providing 1000 dollars worth of credit for 2 years of validity.

You can visit AWS Activate for more details.

Eligibility Criteria

• You must have a domain name in the name of your product/startup. You can purchase one at Godaddy
• You need to set up a plain landing page with the details
  • Few lines of description about your product/project
  • What is the USP? [In simple terms, what is the need for your product]
  • Provide contact details in the footer

That's all !

Steps to claim credit

• Build a landing page from HTML Templates or by any drag-and-drop tool like Wix. If you have already skipped this step.
• Purchase one domain from Godaddy, if you haven't.
• Host the website. If you want to host it free of cost, host it in GitHub by Github pages. You can watch this video on how to host a simple website on GitHub pages. youtu.be/A2R-CMMyp64
• Now you are ready to apply.
• Go to aws.amazon.com/activate/ and Click on Join Now.

You may be asked for login. If you haven't an account just create one, AWS has no requirement for a credit card, You can verify the account by providing a debit card, and also AWS doesn't charge automatically from the card. That's a good thing about AWS.

• Provide the details. If you haven't any startup name, just put your product name in the Company Name field and your residence address in Company Address

• On the next page provide your team details. Must provide Linkedin Profile although it's an optional field. It proves the authenticity of the team members

• On the next page it will ask for your Product Details.

  • Try to brief and point answers to the questions
  • Provide a link to the landing page
  • If you have any product demos, try to provide a link to product details. It will lead to quick approval.

• You are done !

• Expect to get the mail of approval within 7~14 days.

If you are interested in software development and technology, add your e-mail to the newsletter so that whenever I publish a new blog you will get instant alerts