Project 10K

project10k

Developers are always concerned about their code quality. And they try their best to ensure the best quality of their code. If they find some tools that can show them exactly where they need to make changes to improve the quality of the code. There are many of them, but I will explain how you can set up SonarQube locally with docker so that you can evaluate your project code quality. Without wasting any time let’s begin. Prerequisite You must have docker installed in your system. If you don’t have it installed, then please feel free to set up Docker using this link. Docker Container On your root project, create a docker-compose.yml file, and then we will need a database so that Sonarqube can store its analytical data. postgres:
    image: postgres
    restart: always
    environment:
      POSTGRES_PASSWORD: example
    networks:
      - lookup
    ports:
      - 5432:5432
    volumes:
      - postgres:/var/lib/postgresql/data After that, we will need Sonarqube service, sonarqube:
    image: sonarqube:latest
    restart: always
    ports:
      - 9000:9000
    environment:
      SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres
      SONARQUBE_JDBC_USERNAME: postgres
      SONARQUBE_JDBC_PASSWORD: example
    networks:
      - lookup
    depends_on:
      - postgres Don’t worry; I will explain each line. sonarqube:
This defines a service in your Docker Compose file. The name of the service is sonarqube, meaning that this section is describing how the SonarQube container will run.


image: sonarqube:latest
This specifies the Docker image to use for the SonarQube service. In this case, it pulls the latest version of the official SonarQube image from Docker Hub.


restart: always
This ensures that the SonarQube container will automatically restart if it crashes or if the Docker host is rebooted.


ports:
- 9000:9000:
This maps port 9000 on the host machine to port 9000 inside the container. SonarQube’s web interface runs on port 9000, so this makes it accessible from the host machine's browser at http://localhost:9000.


SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres
Defines the JDBC URL to connect SonarQube to a PostgreSQL database.


SONARQUBE_JDBC_USERNAME: postgres:
The username used to authenticate with the PostgreSQL database. In this case, it's postgres.


SONARQUBE_JDBC_PASSWORD: example:
The password used to authenticate the PostgreSQL database, set to example. The final version of our docker-compose.yml file will be the following services:
  postgres:
    image: postgres
    restart: always
    environment:
      POSTGRES_PASSWORD: example
    networks:
      - lookup
    ports:
      - 5432:5432
    volumes:
      - postgres:/var/lib/postgresql/data

  sonarqube:
    image: sonarqube:latest
    restart: always
    ports:
      - 9000:9000
    environment:
      SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres
      SONARQUBE_JDBC_USERNAME: postgres
      SONARQUBE_JDBC_PASSWORD: example
    networks:
      - lookup
    depends_on:
      - postgres

networks:
  lookup:

volumes:
  postgres:
    driver: local Inside your project directory, open a terminal, and to start and run the services do docker-compose up . Setup SonarQube Once the services are running on a browser, go to localhost:9000, and it will open the Sonarqube log-in page. The default username and password is admin. Once you are logged in, it will ask you to set up a new password. After completing these steps, you will be able to see the Sonarqube dashboard. As we are running the Sonarqube locally, we will create a local project. In the below, you will see the marked section that you have to click. It will ask for a project name and a branch name. I will leave the branch name as main. You can choose any branch that you have and create a project. Then we will see a new section where we have to choose Use the global setting  for now. Once we click on  create project, it should ask to generate a token. I will only update the Expires in section and make it to No Expiration. Once we generate a token, it will ask us to select our project coding language; after choosing that, we need to download the scanner zip folder. I have marked the section where you will find it below. Let’s unzip the folder and open the folder; you will find the bin folder, and inside, you will find a sonar-scanner file. Copy the path of that file, and save it in a text file. ~./sonar-scanner-cli-6.1.0.4477-linux-x64/sonar-scanner-6.1.0.4477-linux-x64/bin After that, you need to copy the command given in the Execute the Scanner section. Once you copy that, then concat with the path that you have saved in the file as shown below. ~./sonar-scanner-cli-6.1.0.4477-linux-x64/sonar-scanner-6.1.0.4477-linux-x64/bin/sonar-scanner \
   -Dsonar.projectKey=demo   \
   -Dsonar.sources=.   \
   -Dsonar.host.url=http://localhost:9000   \
   -Dsonar.token=<Your_Token> Once you execute the command in the terminal, it will start analyzing your code. Once it finishes the operation, you should see some analytical information in the Sonarqube dashboard. And then, you should be able to see some metrics, and if you have any issues, you should be able to see the reasons for marking it as an issue. Great, we have completed the setup of our Sonarqube on our project locally. Developers are always concerned about their code quality. And they try their best to ensure the best quality of their code. If they find some tools that can show them exactly where they need to make changes to improve the quality of the code. There are many of them, but I will explain how you can set up SonarQube locally with docker so that you can evaluate your project code quality. Without wasting any time let’s begin. Prerequisite You must have docker installed in your system. If you don’t have it installed, then please feel free to set up Docker using this link . link Docker Container On your root project, create a docker-compose.yml file, and then we will need a database so that Sonarqube can store its analytical data. postgres:
    image: postgres
    restart: always
    environment:
      POSTGRES_PASSWORD: example
    networks:
      - lookup
    ports:
      - 5432:5432
    volumes:
      - postgres:/var/lib/postgresql/data postgres:
    image: postgres
    restart: always
    environment:
      POSTGRES_PASSWORD: example
    networks:
      - lookup
    ports:
      - 5432:5432
    volumes:
      - postgres:/var/lib/postgresql/data After that, we will need Sonarqube service, sonarqube:
    image: sonarqube:latest
    restart: always
    ports:
      - 9000:9000
    environment:
      SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres
      SONARQUBE_JDBC_USERNAME: postgres
      SONARQUBE_JDBC_PASSWORD: example
    networks:
      - lookup
    depends_on:
      - postgres sonarqube:
    image: sonarqube:latest
    restart: always
    ports:
      - 9000:9000
    environment:
      SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres
      SONARQUBE_JDBC_USERNAME: postgres
      SONARQUBE_JDBC_PASSWORD: example
    networks:
      - lookup
    depends_on:
      - postgres Don’t worry; I will explain each line. sonarqube:
This defines a service in your Docker Compose file. The name of the service is sonarqube, meaning that this section is describing how the SonarQube container will run. image: sonarqube:latest
This specifies the Docker image to use for the SonarQube service. In this case, it pulls the latest version of the official SonarQube image from Docker Hub. restart: always
This ensures that the SonarQube container will automatically restart if it crashes or if the Docker host is rebooted. ports:
- 9000:9000:
This maps port 9000 on the host machine to port 9000 inside the container. SonarQube’s web interface runs on port 9000, so this makes it accessible from the host machine's browser at http://localhost:9000. SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres
Defines the JDBC URL to connect SonarQube to a PostgreSQL database. SONARQUBE_JDBC_USERNAME: postgres:
The username used to authenticate with the PostgreSQL database. In this case, it's postgres. SONARQUBE_JDBC_PASSWORD: example:
The password used to authenticate the PostgreSQL database, set to example. sonarqube: This defines a service in your Docker Compose file. The name of the service is sonarqube, meaning that this section is describing how the SonarQube container will run. sonarqube: sonarqube: This defines a service in your Docker Compose file. The name of the service is sonarqube , meaning that this section is describing how the SonarQube container will run. sonarqube image: sonarqube:latest This specifies the Docker image to use for the SonarQube service. In this case, it pulls the latest version of the official SonarQube image from Docker Hub. image: sonarqube:latest image: sonarqube:latest This specifies the Docker image to use for the SonarQube service. In this case, it pulls the latest version of the official SonarQube image from Docker Hub. restart: always This ensures that the SonarQube container will automatically restart if it crashes or if the Docker host is rebooted. restart: always restart: always This ensures that the SonarQube container will automatically restart if it crashes or if the Docker host is rebooted. ports: - 9000:9000: This maps port 9000 on the host machine to port 9000 inside the container. SonarQube’s web interface runs on port 9000, so this makes it accessible from the host machine's browser at http://localhost:9000. ports: ports: - 9000:9000 : - 9000:9000 This maps port 9000 on the host machine to port 9000 inside the container. SonarQube’s web interface runs on port 9000, so this makes it accessible from the host machine's browser at http://localhost:9000 . http://localhost:9000 SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres Defines the JDBC URL to connect SonarQube to a PostgreSQL database. SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres Defines the JDBC URL to connect SonarQube to a PostgreSQL database. SONARQUBE_JDBC_USERNAME: postgres: The username used to authenticate with the PostgreSQL database. In this case, it's postgres. SONARQUBE_JDBC_USERNAME: postgres : SONARQUBE_JDBC_USERNAME: postgres The username used to authenticate with the PostgreSQL database. In this case, it's postgres . postgres SONARQUBE_JDBC_PASSWORD: example: The password used to authenticate the PostgreSQL database, set to example. SONARQUBE_JDBC_PASSWORD: example : SONARQUBE_JDBC_PASSWORD: example The password used to authenticate the PostgreSQL database, set to example . example The final version of our docker-compose.yml file will be the following services:
  postgres:
    image: postgres
    restart: always
    environment:
      POSTGRES_PASSWORD: example
    networks:
      - lookup
    ports:
      - 5432:5432
    volumes:
      - postgres:/var/lib/postgresql/data

  sonarqube:
    image: sonarqube:latest
    restart: always
    ports:
      - 9000:9000
    environment:
      SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres
      SONARQUBE_JDBC_USERNAME: postgres
      SONARQUBE_JDBC_PASSWORD: example
    networks:
      - lookup
    depends_on:
      - postgres

networks:
  lookup:

volumes:
  postgres:
    driver: local services:
  postgres:
    image: postgres
    restart: always
    environment:
      POSTGRES_PASSWORD: example
    networks:
      - lookup
    ports:
      - 5432:5432
    volumes:
      - postgres:/var/lib/postgresql/data

  sonarqube:
    image: sonarqube:latest
    restart: always
    ports:
      - 9000:9000
    environment:
      SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres
      SONARQUBE_JDBC_USERNAME: postgres
      SONARQUBE_JDBC_PASSWORD: example
    networks:
      - lookup
    depends_on:
      - postgres

networks:
  lookup:

volumes:
  postgres:
    driver: local Inside your project directory, open a terminal, and to start and run the services do docker-compose up . docker-compose up Setup SonarQube Once the services are running on a browser, go to localhost:9000 , and it will open the Sonarqube log-in page. The default username and password is admin . Once you are logged in, it will ask you to set up a new password. localhost:9000 admin After completing these steps, you will be able to see the Sonarqube dashboard. As we are running the Sonarqube locally, we will create a local project. In the below, you will see the marked section that you have to click. It will ask for a project name and a branch name. I will leave the branch name as main . You can choose any branch that you have and create a project. Then we will see a new section where we have to choose Use the global setting for now. main Use the global setting Once we click on create project , it should ask to generate a token. I will only update the Expires in section and make it to No Expiration . Once we generate a token, it will ask us to select our project coding language; after choosing that, we need to download the scanner zip folder. I have marked the section where you will find it below. create project Expires in No Expiration Let’s unzip the folder and open the folder; you will find the bin folder, and inside, you will find a sonar-scanner file. Copy the path of that file, and save it in a text file. bin sonar-scanner ~./sonar-scanner-cli-6.1.0.4477-linux-x64/sonar-scanner-6.1.0.4477-linux-x64/bin ~./sonar-scanner-cli-6.1.0.4477-linux-x64/sonar-scanner-6.1.0.4477-linux-x64/bin After that, you need to copy the command given in the Execute the Scanner section. Execute the Scanner Once you copy that, then concat with the path that you have saved in the file as shown below. ~./sonar-scanner-cli-6.1.0.4477-linux-x64/sonar-scanner-6.1.0.4477-linux-x64/bin/sonar-scanner \
   -Dsonar.projectKey=demo   \
   -Dsonar.sources=.   \
   -Dsonar.host.url=http://localhost:9000   \
   -Dsonar.token=<Your_Token> ~./sonar-scanner-cli-6.1.0.4477-linux-x64/sonar-scanner-6.1.0.4477-linux-x64/bin/sonar-scanner \
   -Dsonar.projectKey=demo   \
   -Dsonar.sources=.   \
   -Dsonar.host.url=http://localhost:9000   \
   -Dsonar.token=<Your_Token> Once you execute the command in the terminal, it will start analyzing your code. Once it finishes the operation, you should see some analytical information in the Sonarqube dashboard. And then, you should be able to see some metrics, and if you have any issues, you should be able to see the reasons for marking it as an issue. Great, we have completed the setup of our Sonarqube on our project locally.

How to Setup SonarQube Locally Using Docker

Introduction For the last few months, I have been learning HTML, Tailwind CSS, and JavaScript. So, I thought of building a project with these to improve my DOM manipulation concepts. In this article, I will be sharing how I made a Background Color Switcher Project. Let's dive into it !! Prerequisites The Tech Stack I used for building this project is : HTML
Tailwind CSS
JavaScript (Specifically DOM Manipulation) Project Overview So, let's see what this project is all about. A Background Color Switcher This project is a background color switcher in which there are multiple color options available (refer to the above image). Here, if you click on any of the colors, it will be applied to the background. I did this using the basic concepts of DOM Manipulation in JavaScript. Now, let's start building the project together. The project will be done in 3 steps : Setting up HTML Structure
Styling it with Tailwind CSS
Adding functionalities using JavaScript Now, let's understand each of the steps in detail. Setting Up the HTML Structure At first, we will be setting up the HTML Structure, and for that, we will be creating two <div>s: one containing the text "Select The Color You Want To Apply To The Background," and the other containing multiple color boxes. In the second <div> we will create four other <div>s that are the color boxes with the respective color class as their IDs. Here's have a look at it <body>
    <div>Select The Color You Want To Apply To The Background</div>
    <div> 
        <div></div> 
        <div></div>
        <div></div>
        <div></div>
        <div></div>
    </div> You must be wondering why we have added the extra <div> under the second main <div> (check the above code). We will be looking into this in the following sections. So, that was all about creating the HTML structure. Now, let's add styles to this HTML Page using Tailwind CSS. Styling With Tailwind CSS Now, we will add basic styling to our HTML Page. We will start with adding font style, font weight, and basic padding to the heading.
<div class="font-bold text-2xl text-center pt-20 pb-8 sm:pt-28 sm:text-3xl xl:text-4xl xl:pt-48">
Select The Color You Want To Apply To The Background</div>


Then we will add the required border, background color, width, and height to the color containers. We will also add an id to all the color containers, and in this example, we have kept it the same as its color class <div class="flex flex-col space-y-5 justify-center items-center pb-10 md:flex-row md:space-x-8 xl:space-x-12">
        <div></div> 
        <div class="border-black border-2 w-48 h-48 bg-red-600 button" id="bg-red-600"></div>
        <div class="border-black border-2 w-48 h-48 bg-blue-700 button" id="bg-blue-700"></div>
        <div class="border-black border-2 w-48 h-48 bg-yellow-500 button" id="bg-yellow-500"></div>
        <div class="border-black border-2 w-48 h-48 bg-white button" id="bg-white"></div>
    </div> Now, let's get into the use of the extra div (Check the above code) We have used the extra div to align the color containers at the same level so that the space-y-5 or space-x-8 property works properly as this property is applied only in between the elements not at the starting. Adding Functionality With JavaScript We all know that functionality can be added to the project using a script tag (which contains the JS code) within the body tag. Now, let's add the required functionality step by step. Firstly, we will select the color containers using their class="button" and the body element on which the color is going to be added using query selectors. buttons = document.querySelectorAll(".button");
 body = document.querySelector("body"); We need to run a loop on the buttons thus, fetching one color container at a time. Now, we will add an event listener on the selected color container that will specify its work upon clicking on it. buttons.forEach(function(button){
        button.addEventListener("click" , function(e){
        //Code to be executed on clicking
        }) Now, let's define the function(e) which contains the main code to be executed on clicking on the color container. Inside the function, at first, we call a function named removebg It will take the body element as the argument and will remove any existing bg-color class from the class list of the body element. We did it so that on clicking on a new color container new class can be added to the class list thus giving the body a new background color every time. We will be defining this removebg function further. After calling the removebg function any existing bg-color class will get removed from the class list. Then we will add the required color class (which is present in each element's id) in the body element's class list. buttons.forEach(function(button){
        //console.log(button);
        button.addEventListener("click" , function(e){
            removebg(body); // remove bg color from target element
            body.classList.add(e.target.id);   //Add the required bg colour
        }) Now, the last part that remains is to define the removebg function. This function will accept the body element as a parameter which is stored in the variable sourceElement. Next, we will define a variable sourceClasses that makes an array out of the classes present in the sourceElement. After that, we will run a loop on the array sourceClasses selecting each class, checking whether the class name starts with "bg-" and if that matches, then we will remove it. const removebg = (sourceElement) => {
       let sourceClasses = Array.from(sourceElement.classList);
       sourceClasses.forEach(function(className) {
            if (className.startsWith('bg-')) { // check if class has any background color class
                  body.classList.remove(className); // remove bg color from target element
            }
       });
} And with that, we have successfully built a background color switcher. The link to the GitHub repository containing the whole code and the project website link is attached at the end for your reference. Testing the Project After the code completion, I ran it locally using the npm package and then also deployed the project using Vercel. Here's a preview of my project: https://olibhia-bg-color-switcher.vercel.app/?embedable=true Here's the GitHub Repository containing the whole code: https://github.com/OlibhiaGhosh/Web_Dev_Project1.0?embedable=true Conclusion That was all about the code of this project. I hope I made it simple for all. If you found this blog useful and insightful, share it, and comment down your views on it. Do follow for more such content. Here's how you can connect with me. Email - olibhia0712@gmail.com Socials: Twitter LinkedIn GitHub Thanks for giving it a read!! Introduction For the last few months, I have been learning HTML, Tailwind CSS, and JavaScript. So, I thought of building a project with these to improve my DOM manipulation concepts. In this article, I will be sharing how I made a Background Color Switcher Project. Let's dive into it !! Prerequisites The Tech Stack I used for building this project is : HTML Tailwind CSS JavaScript (Specifically DOM Manipulation) HTML Tailwind CSS JavaScript (Specifically DOM Manipulation) Project Overview So, let's see what this project is all about. A Background Color Switcher This project is a background color switcher in which there are multiple color options available (refer to the above image). Here, if you click on any of the colors, it will be applied to the background. I did this using the basic concepts of DOM Manipulation in JavaScript. Now, let's start building the project together. The project will be done in 3 steps : Setting up HTML Structure Styling it with Tailwind CSS Adding functionalities using JavaScript Setting up HTML Structure Styling it with Tailwind CSS Adding functionalities using JavaScript Now, let's understand each of the steps in detail. Setting Up the HTML Structure At first, we will be setting up the HTML Structure, and for that, we will be creating two <div> s: one containing the text " Select The Color You Want To Apply To The Background, " and the other containing multiple color boxes. <div> Select The Color You Want To Apply To The Background, In the second <div> we will create four other <div> s that are the color boxes with the respective color class as their IDs. <div> <div> Here's have a look at it <body>
    <div>Select The Color You Want To Apply To The Background</div>
    <div> 
        <div></div> 
        <div></div>
        <div></div>
        <div></div>
        <div></div>
    </div> <body>
    <div>Select The Color You Want To Apply To The Background</div>
    <div> 
        <div></div> 
        <div></div>
        <div></div>
        <div></div>
        <div></div>
    </div> You must be wondering why we have added the extra <div> under the second main <div> (check the above code). <div> <div> We will be looking into this in the following sections. So, that was all about creating the HTML structure. Now, let's add styles to this HTML Page using Tailwind CSS. Styling With Tailwind CSS Now, we will add basic styling to our HTML Page. We will start with adding font style, font weight, and basic padding to the heading.
<div class="font-bold text-2xl text-center pt-20 pb-8 sm:pt-28 sm:text-3xl xl:text-4xl xl:pt-48">
Select The Color You Want To Apply To The Background</div> Then we will add the required border, background color, width, and height to the color containers. We will start with adding font style, font weight, and basic padding to the heading. <div class="font-bold text-2xl text-center pt-20 pb-8 sm:pt-28 sm:text-3xl xl:text-4xl xl:pt-48">
Select The Color You Want To Apply To The Background</div> We will start with adding font style, font weight, and basic padding to the heading. <div class="font-bold text-2xl text-center pt-20 pb-8 sm:pt-28 sm:text-3xl xl:text-4xl xl:pt-48">
Select The Color You Want To Apply To The Background</div> Then we will add the required border, background color, width, and height to the color containers. Then we will add the required border, background color, width, and height to the color containers. We will also add an id to all the color containers, and in this example, we have kept it the same as its color class id <div class="flex flex-col space-y-5 justify-center items-center pb-10 md:flex-row md:space-x-8 xl:space-x-12">
        <div></div> 
        <div class="border-black border-2 w-48 h-48 bg-red-600 button" id="bg-red-600"></div>
        <div class="border-black border-2 w-48 h-48 bg-blue-700 button" id="bg-blue-700"></div>
        <div class="border-black border-2 w-48 h-48 bg-yellow-500 button" id="bg-yellow-500"></div>
        <div class="border-black border-2 w-48 h-48 bg-white button" id="bg-white"></div>
    </div> <div class="flex flex-col space-y-5 justify-center items-center pb-10 md:flex-row md:space-x-8 xl:space-x-12">
        <div></div> 
        <div class="border-black border-2 w-48 h-48 bg-red-600 button" id="bg-red-600"></div>
        <div class="border-black border-2 w-48 h-48 bg-blue-700 button" id="bg-blue-700"></div>
        <div class="border-black border-2 w-48 h-48 bg-yellow-500 button" id="bg-yellow-500"></div>
        <div class="border-black border-2 w-48 h-48 bg-white button" id="bg-white"></div>
    </div> Now, let's get into the use of the extra div (Check the above code) div We have used the extra div to align the color containers at the same level so that the space-y-5 or space-x-8 property works properly as this property is applied only in between the elements not at the starting. space-y-5 space-x-8 Adding Functionality With JavaScript We all know that functionality can be added to the project using a script tag (which contains the JS code) within the body tag. script body Now, let's add the required functionality step by step. Firstly, we will select the color containers using their class="button" and the body element on which the color is going to be added using query selectors. class="button" buttons = document.querySelectorAll(".button");
 body = document.querySelector("body"); buttons = document.querySelectorAll(".button");
 body = document.querySelector("body"); We need to run a loop on the buttons thus, fetching one color container at a time. buttons Now, we will add an event listener on the selected color container that will specify its work upon clicking on it. buttons.forEach(function(button){
        button.addEventListener("click" , function(e){
        //Code to be executed on clicking
        }) buttons.forEach(function(button){
        button.addEventListener("click" , function(e){
        //Code to be executed on clicking
        }) Now, let's define the function(e) which contains the main code to be executed on clicking on the color container. function(e) Inside the function, at first, we call a function named removebg removebg It will take the body element as the argument and will remove any existing bg-color class from the class list of the body element. bg-color We did it so that on clicking on a new color container new class can be added to the class list thus giving the body a new background color every time. We will be defining this removebg function further. removebg further. After calling the removebg function any existing bg-color class will get removed from the class list. removebg bg-color Then we will add the required color class (which is present in each element's id) in the body element's class list. buttons.forEach(function(button){
        //console.log(button);
        button.addEventListener("click" , function(e){
            removebg(body); // remove bg color from target element
            body.classList.add(e.target.id);   //Add the required bg colour
        }) buttons.forEach(function(button){
        //console.log(button);
        button.addEventListener("click" , function(e){
            removebg(body); // remove bg color from target element
            body.classList.add(e.target.id);   //Add the required bg colour
        }) Now, the last part that remains is to define the removebg function. removebg This function will accept the body element as a parameter which is stored in the variable sourceElement . sourceElement Next, we will define a variable sourceClasses that makes an array out of the classes present in the sourceElement . sourceClasses sourceElement After that, we will run a loop on the array sourceClasses selecting each class, checking whether the class name starts with "bg-" and if that matches, then we will remove it. sourceClasses const removebg = (sourceElement) => {
       let sourceClasses = Array.from(sourceElement.classList);
       sourceClasses.forEach(function(className) {
            if (className.startsWith('bg-')) { // check if class has any background color class
                  body.classList.remove(className); // remove bg color from target element
            }
       });
} const removebg = (sourceElement) => {
       let sourceClasses = Array.from(sourceElement.classList);
       sourceClasses.forEach(function(className) {
            if (className.startsWith('bg-')) { // check if class has any background color class
                  body.classList.remove(className); // remove bg color from target element
            }
       });
} And with that, we have successfully built a background color switcher. The link to the GitHub repository containing the whole code and the project website link is attached at the end for your reference. Testing the Project After the code completion, I ran it locally using the npm package and then also deployed the project using Vercel. Here's a preview of my project: Here's a preview of my project: Here's a preview of my project: https://olibhia-bg-color-switcher.vercel.app/?embedable=true https://olibhia-bg-color-switcher.vercel.app/?embedable=true Here's the GitHub Repository containing the whole code: Here's the GitHub Repository containing the whole code: Here's the GitHub Repository containing the whole code: https://github.com/OlibhiaGhosh/Web_Dev_Project1.0?embedable=true https://github.com/OlibhiaGhosh/Web_Dev_Project1.0?embedable=true Conclusion That was all about the code of this project. I hope I made it simple for all. If you found this blog useful and insightful, share it, and comment down your views on it. Do follow for more such content. Here's how you can connect with me. Email - olibhia0712@gmail.com olibhia0712@gmail.com Socials: Twitter Twitter LinkedIn LinkedIn GitHub GitHub Thanks for giving it a read!!

How to Make A Background Color Switcher Project Using JavaScript: A Beginner's Guide

This paper is available on arxiv under CC 4.0 license. Authors: (1) Evan Ning, Milton Academy & evan_ning24@milton.edu; (2) David R. Kaeli, Department of Electrical and Computer Engineering & Northeastern University kaeli@ece.neu.edu. Table of Links Introduction Sieve Optimizations Mathematical Optimization Implementation Results and Discussions Conclusions, Source Code & References 6 Conclusions In this paper, we explored how to better parallelize the execution of the Sieve of Eratosthenes. Clearly, both the arithmetic complexity of computation and the storage requirement play a big role in the computation speed of the standard implementation. However, our proposed algorithm is faster and more compact (requiring N/3 auxiliary storage), resulting in a more efficient parallel execution of the Sieve of Eratosthenes. We explored selecting the chunk size to optimize memory usage, which can avoid memory thrashing. Our incremental segmented approach enables us to handle huge numbers, almost approaching infinity. This is crucial for large-scale prime number computations and applications that require extensive use of primes. Memory management in high-performance multi-threaded computations is extremely important. The cache sizes and physical memory constraints can have a huge impact on performance. We encountered this when selecting the size of our scratch memory. What we found is that there are tradeoffs in terms of selecting this size. Next Steps for advancing the Multithreaded Sieve Algorithm Implementation: Prime Data Store File Writing: The current setup is poised for indefinite expansion. However, to efficiently manage and store results, there is a need to implement writing to files, ensuring the preservation of computed data. To address potential memory constraints, the prime base list will be segmented. Each segment will contain up to 125 million primes to prevent memory overflow and ensure efficient retrieval. Custom Big Integer Library: In order to sieve infinitely, a special library for large numbers needs to be created. While there are default big integer libraries, we can customize our own for further optimization. For example, we only divide by 6, so a special operation can be created. Furthermore, a special operation can be created to efficiently mod 6. Incorporation of Multiprocessing: To further optimize the computational process, the implementation of multiprocessing will be explored. This approach is to divide the tasks into multiple computation nodes. However, this comes with its set of challenges. One primary concern is minimizing data transfer between processes, ensuring coherence and consistency in results. Source Code GitHub: https://github.com/evanning1/Multi-thread_Prime_Sieve References [1] R.L. Rivest, A. Shamir, L. Adleman, “A Method for Obtaining Digital Signatures and Public-Key Cryptosystems,” (1978) Massachusetts Institute of Technology, https://people.csail.mit.edu/vinodv/COURSES/MAT302-S12/Rsapaper.pdf [2] Xuedong Luo, “A Practical Sieve Algorithm Finding Prime Numbers,” (1989) Communications of the ACM, 32(3), March 1989, 344–346. https://doi.org/10.1145/62065.62072 [3] Torben Hansen, “Parallel Implementation of the Sieve of Eratosthenes,” F120116 Utrecht University - Institute of Mathematics, https://himsen.github.io/pdf/Project1_parallel_algorithms_Torben.pdf [4] Mário Cordeiro, “Parallelization of the Sieve of Eratosthenes, Faculdade de Engenharia da Universidade, s/n 4200-465 Porto PORTUGAL . [5] Jonathan Sorenson, “An Introduction to Prime Number Sieves,” Computer Sciences Technical Report #909, Department of Computer Sciences University of Wisconsin-Madison, January 2, 1990. [6] POSIX Threads Programming https://hpc-tutorials.llnl.gov/posix/ [7] Research Computing at Northeastern University https://rc-docs.northeastern.edu/en/latest/

Memory Efficient Multithreaded Algorithm: Conclusions, Source Code & References

When we work with only one project, we install needed version and don’t have any issues. But when we start to work with multiple projects with different versions of  OpenTofu - we are in trouble. OpenTofu How could this problem be solved earlier? We downloaded the required version of OpenTofu and placed it somewhere in $PATH. After that we renamed the downloaded file and used it something like this: $ tofu-1.6.0-rc1 -version
OpenTofu v1.6.0-rc1
on darwin_amd64 But this is hard and inconvenient to switch between versions, and we need to remember, which version of OpenTofu has to be used every time. Here is going to help us. tofuenv is an OpenTofu version manager. It allows us to easily install a version, switch between them, and set specific version for specific repository. tofuenv Installing tofuenv tofuenv can be installed to all major operating systems, such as MacOS, Linux and Windows. We can use brew to install tofuenv to the macos: $ brew tap tofuutils/tap
$ brew install tofuenv For linux, we can manually install tofuenv. Check out tofuenv into any path (here is ) ${HOME}/.tofuenv $ git clone --depth=1 https://github.com/tofuutils/tofuenv.git ~/.tofuenv Add to your any way you like: ~/.tofuenv/bin $PATH bash: $ echo 'export PATH="$HOME/.tofuenv/bin:$PATH"' >> ~/.bash_profile zsh: $ echo 'export PATH="$HOME/.tofuenv/bin:$PATH"' >> ~/.zprofile OR you can make symlinks for scripts into a path that is already added to your (e.g. ) Only! tofuenv/bin/* $PATH /usr/local/bin OSX/Linux $ ln -s ~/.tofuenv/bin/* /usr/local/bin On Ubuntu/Debian touching might require sudo access, but you can create or and on next login it will get added to the session or by running it will get added to the current shell session's . /usr/local/bin ${HOME}/bin ${HOME}/.local/bin $PATH . ${HOME}/.profile $PATH $ mkdir -p ~/.local/bin/ 
$ . ~/.profile
$ ln -s ~/.tofuenv/bin/* ~/.local/bin 
$ which tofuenv Run tofuenv to verify installation and check available options: $ tofuenv
tofuenv 1.0.3
Usage: tofuenv <command> [<options>]

Commands:
   install       Install a specific version of OpenTofu
   use           Switch a version to use
   uninstall     Uninstall a specific version of OpenTofu
   list          List all installed versions
   list-remote   List all installable versions
   version-name  Print current version of OpenTofu
   init          Update environment to use tofuenv correctly.
   pin           Write the current active version to ./.opentofu-version In case of any problems, you may refer to official documentation at . tofuenv github repository Installing OpenTofu with tofuenv After we have tofuenv installed, we can install opentofu in the following way. To install specific version of opentofu use the following command: $ tofuenv install 1.6.0-rc1 To install latest stable version we can use specific word : latest $ tofuenv install latest But due to the fact that at the time of writing this article OpenTofu doesn’t have a stable version, installation via word doesn't work. latest Anyway, we can install  the latest available version of OpenTofu 1.6: $ tofuenv install latest:1.6
tofuenv install latest:1.6
Installing OpenTofu v1.6.0-rc1
Downloading release tarball from https://github.com/opentofu/opentofu/releases/download/v1.6.0-rc1/tofu_1.6.0-rc1_darwin_amd64.zip
########################################################################################################################################################### 100.0%
Downloading SHA hash file from https://github.com/opentofu/opentofu/releases/download/v1.6.0-rc1/tofu_1.6.0-rc1_SHA256SUMS
Archive:  /var/folders/nb/k6bv49gd4pd9kyvwwn519_2m0000gn/T/tofuenv_download.XXXXXX.fqdxfWoz/tofu_1.6.0-rc1_darwin_amd64.zip
  inflating: /usr/local/Cellar/tofuenv/1.0.3/versions/1.6.0-rc1/CHANGELOG.md  
  inflating: /usr/local/Cellar/tofuenv/1.0.3/versions/1.6.0-rc1/LICENSE  
  inflating: /usr/local/Cellar/tofuenv/1.0.3/versions/1.6.0-rc1/README.md  
  inflating: /usr/local/Cellar/tofuenv/1.0.3/versions/1.6.0-rc1/tofu  
Installation of tofu v1.6.0-rc1 successful. To make this your default version, run 'tofuenv use 1.6.0-rc1' For now the latest available version of OpenTofu 1.6 is 1.6.0-rc1 and for that reason, it was installed by tofuenv. : If is present in the path, tofuenv will verify the download against OpenTofu published sha256 hash. Also GPG signature will be added for verification as soon as OpenTofu will support it. Note shasum List OpenTofu versions With tofuenv we can list locally installed versions and remote versions, which are available for installation. To list locally installed versions, run the following command: $ tofuenv list
  1.6.0-alpha1
* 1.6.0-rc1 (set by /usr/local/Cellar/tofuenv/1.0.3/version) Asterisk marks the version currently used. To list remote versions, run the following command: $ tofuenv list-remote
1.6.0-rc1
1.6.0-beta5
1.6.0-beta4
1.6.0-beta3
1.6.0-beta2
1.6.0-beta1
1.6.0-alpha5
1.6.0-alpha4
1.6.0-alpha3
1.6.0-alpha2
1.6.0-alpha1 OpenTofu placed binary in GitHub, and GitHub has a strict rate limiting rule for non-authorised users. Because of this, you can catch the 403 error or "GitHub Rate limits exceeded" error. You can set environment variable with your own GitHub token for authentication against GitHub api and drastically increase the rate limits. TOFUENV_GITHUB_TOKEN Switch a version to use To switch between versions, we can use couple of techniques. First of all, with use parameter: use $ tofuenv use 1.6.0-alpha1
Switching default version to v1.6.0-alpha1
Default version (when not overridden by .opentofu-version or TOFUENV_TOFU_VERSION) is now: 1.6.0-alpha1 By default, environment variable is set to true, and if version 1.6.0-alpha2 of OpenTofu isn’t available locally, it will be downloaded and used automatically: TOFUENV_AUTO_INSTALL $ tofuenv use 1.6.0-alpha2
No installed versions of opentofu matched '^1.6.0-alpha2$'. Trying to install a matching version since TOFUENV_AUTO_INSTALL=true
Installing OpenTofu v1.6.0-alpha2
Downloading release tarball from https://github.com/opentofu/opentofu/releases/download/v1.6.0-alpha2/tofu_1.6.0-alpha2_darwin_amd64.zip
########################################################################################################################################################### 100.0%
Downloading SHA hash file from https://github.com/opentofu/opentofu/releases/download/v1.6.0-alpha2/tofu_1.6.0-alpha2_SHA256SUMS
Archive:  /var/folders/nb/k6bv49gd4pd9kyvwwn519_2m0000gn/T/tofuenv_download.XXXXXX.3DyehSoJ/tofu_1.6.0-alpha2_darwin_amd64.zip
  inflating: /usr/local/Cellar/tofuenv/1.0.3/versions/1.6.0-alpha2/CHANGELOG.md  
  inflating: /usr/local/Cellar/tofuenv/1.0.3/versions/1.6.0-alpha2/LICENSE  
  inflating: /usr/local/Cellar/tofuenv/1.0.3/versions/1.6.0-alpha2/README.md  
  inflating: /usr/local/Cellar/tofuenv/1.0.3/versions/1.6.0-alpha2/tofu  
Installation of tofu v1.6.0-alpha2 successful. To make this your default version, run 'tofuenv use 1.6.0-alpha2'
Switching default version to v1.6.0-alpha2
Default version (when not overridden by .opentofu-version or TOFUENV_TOFU_VERSION) is now: 1.6.0-alpha2 Second option is to use file. If that file is present in the directory and contains needed version, it will be used automatically: .opentofu-version project1$ tofu -version
OpenTofu v1.6.0-rc1
on darwin_amd64
project1$ cat .opentofu-version 
1.6.0-rc1

project1$ cd ../project2
project2$ tofu -version
OpenTofu v1.6.0-alpha1
on darwin_amd64
project2$ cat .opentofu-version 
1.6.0-alpha1 That file can be created manually, for example: $ echo 1.6.0-alpha1 > .opentofu-version Or with using special command from tofuenv. That command will save currently used version of opentofu to the file in current directory: pin $ tofu -version
OpenTofu v1.6.0-rc1
on darwin_amd64

$ tofuenv pin
Pinned version by writing "1.6.0-rc1" to ./.opentofu-version Uninstall unneeded versions For the cleanup of unneeded installed version we can use command: uninstall $ tofuenv uninstall 1.6.0-rc1
Uninstall OpenTofu v1.6.0-rc1
OpenTofu v1.6.0-rc1 is successfully uninstalled In conclusion is a great open-source alternative to Terraform. Our team of tofuenv creators (me, and ) believes that OpenTofu will take decisive place in the market, and tofuenv will help everyone to use it successfully. OpenTofu Alexander Sharov Anastasiia Kozlova

How to Manage Multiple OpenTofu Versions With Tofuenv

All You Need to Know About Continuous Integration, GitHub Actions, & Sonar Cloud

ক্রমাগত ইন্টিগ্রেশন, গিটহাব অ্যাকশন এবং সোনার ক্লাউড সম্পর্কে আপনার যা জানা দরকার

Alles, was Sie über kontinuierliche Integration, GitHub-Aktionen und Sonar Cloud wissen müssen

Todo lo que necesita saber sobre integración continua, acciones de GitHub y Sonar Cloud

Tout ce que vous devez savoir sur l'intégration continue, les actions GitHub et Sonar Cloud

निरंतर एकीकरण, गिटहब क्रियाएँ, और सोनार क्लाउड के बारे में आप सभी को पता होना चाहिए

継続的インテグレーション、GitHub アクション、Sonar Cloud について知っておくべきこと

지속적인 통합, GitHub Actions 및 Sonar Cloud에 대해 알아야 할 모든 것

Tudo o que você precisa saber sobre integração contínua, ações do GitHub e Sonar Cloud

Sürekli Entegrasyon, GitHub Eylemleri ve Sonar Cloud Hakkında Bilmeniz Gereken Her Şey

Tất cả những gì bạn cần biết về tích hợp liên tục, hành động GitHub và đám mây Sonar

关于持续集成、GitHub Actions 和 Sonar Cloud，您需要知道的一切

SonarQube is an open-source tool that helps developers continuously inspect the code quality of their projects. It provides code analysis, code coverage, and code duplication detection, along with various other features. With SonarQube, developers can easily detect and fix the technical debt, improving the quality of their code. Prerequisites Any basic programming language knowledge. Basic OOPS concepts understanding The article demonstrates SonarQube Analysis with C# programming language. Learning Objectives How to do SonarQube analysis via the Docker Image How to analyze C# application via the Docker Image Getting Started Running SonarQube on a local machine can sometimes be cumbersome due to the complex setup requirements, but Docker can simplify the process. Docker is a platform for building, shipping, and running container applications. Docker provides an easy-to-use interface for managing and deploying applications and can be used to run SonarQube. In this article, we will explore the steps to run SonarQube via the Docker image: Step 1: Install Docker The first step to running SonarQube via Docker is to install Docker on your machine. Docker provides installation instructions for different operating systems on their website. Step 2: Pull the SonarQube Image Once Docker is installed, the next step is to pull the SonarQube image from the Docker Hub. You can do this by running the following command in the terminal: docker pull sonarqube This command will download the latest SonarQube image from the Docker Hub. Step 3: Run the SonarQube Container Now that the SonarQube image has been downloaded, the next step is to run the SonarQube container. You can do this by running the following command in the terminal: docker run -d --name sonarqube -p 9000:9000 sonarqube This command will start the SonarQube container and expose port 9000 on the host machine. You can access the SonarQube web interface by opening a web browser and navigating to . http://localhost:9000 Step 4: Analyze Code with SonarQube With the SonarQube container up and running, you can now analyze your code by following these steps: Generate a SonarQube analysis report for your codebase. Copy the report to the SonarQube container. Run the SonarQube analysis by executing the following command: docker exec sonarqube /opt/sonar-scanner/bin/sonar-scanner \
   -Dsonar.projectKey=<project_key> \
   -Dsonar.sources=<path_to_code> \
   -Dsonar.host.url=http://localhost:9000 \
   -Dsonar.login=<token> Analyze a C# application using SonarQube via the Docker image Step 1: Add SonarQube Scanner for MSBuild to your project The SonarScanner for MSBuild is a .NET Core tool that helps to integrate SonarQube analysis into the MSBuild process. You can add the SonarScanner for MSBuild to your project by running the following command in the terminal: dotnet tool install --global dotnet-sonarscanner Step 2: Generate a SonarQube Analysis Report Once the SonarScanner for MSBuild is installed, the next step is to generate a SonarQube analysis report for your C# project. You can do this by running the following command in the terminal: dotnet sonarscanner begin /k:"<project_key>" /d:sonar.host.url="http://localhost:9000" /d:sonar.login="<token>" Replace with a unique identifier for your project and the authentication token for your SonarQube instance. <project_key> <token> This command will begin the SonarQube analysis and generate a report for your C# project. Step 3: Build your C# project Next, build your C# project using the following command: dotnet build This command will compile your C# code and create a binary executable. Step 4: Analyze your C# project with SonarQube Once your C# project is built, you can analyze it with SonarQube by running the following command: dotnet sonarscanner end /d:sonar.login="<token>" This command will end the SonarQube analysis and upload the report to your SonarQube instance. Step 5: View the SonarQube Analysis Results Now that the analysis is complete, you can view the results in the SonarQube web interface by navigating to . In the SonarQube interface, you can see information about code quality, code coverage, and other metrics for your C# project. http://localhost:9000 Conclusion That’s it! Following these steps, you can quickly analyze your C# application using SonarQube via the Docker image. SonarQube can help you identify code quality issues and improve the overall maintainability of your codebase. Also published . here

Analyzing Your Code With SonarQube Running via Docker Image

Project Overview is a powerful set of fully responsive and accessible React components and projects. Production-ready hand-crafted Projects and Components built on top of Chakra UI. TemplatesKart It will help you to focus on your business, not on the boilerplate. Demo Link https://templateskart.com How I built it : Next.js Framework : Chakra UI Styling : Framer Motion Animations : Vercel Deployment There are 2 main sections in TemplatesKart 1. ProjectsKart ProjectsKart provides an easy solution to getting the look you want for your website without having to mess around with too much code. User can view project pages and copy code of components. ProjectsKart Page Project Page 2. ComponentsKart It is a list of beautiful and responsive React components to build your application. Some of these components are extracted from and some are built separately. ProjectsKart ComponentsKart Page Component Page Why I built TemplatesKart In 2020, I started learning and I explored multiple React component libraries like . All those libraries are great. But I found the best React component library although was new at that time. It Provides just enough to get started, implements sensible defaults, but is also very extensible and customisable. So I started using it and created multiple small projects with it. So far I built 5 to 10 projects with ChakraUI. Some projects are open source. In my new projects, sometimes i need to copy old components code from my previous projects. But it was a time-consuming process. Because I always need to open codebase of that specific project. So as per my needs and to make copy code process more convenient I created a website. I added all my previous open source projects and most commonly used components. Reactjs AntDesign, MaterialUI, Tailwindcss and ChakraUI ChakraUI ChakraUI TemplatesKart ChakraUI website is open source. Feel free to like and contribute. TemplatesKart Website link: TemplatesKart Github repo: TemplatesKart Code Also Published here

TemplatesKart: Is this the Best Chakra UI Component Library?

In this guide, we are going to deploy a continuous integration process between Jenkins, GitLab, and SonarQube. The end goal will be to review the code quality through SonarQube for GitLab repository using Jenkins. Following is the process flow we need to manage: Push code to GitLab from the local machine. Next, checkout code and run tests in Jenkins, here it is acting as a Continuous Integrator. Generate quality report via SonarQube as a code analyser. Setup Jenkins, SonarQube & GitLabs In case, if you haven't set up the required software yet, go through the below-mentioned steps: Step 1: Make sure that your host machine has enough power to run these components, as GitLab alone requires 4 GB of RAM to perform its operations smoothly. To run all three together, you need at least 8 GB of RAM and 20 GB of hard disk space. Step 2: For SonarQube, you need to set the recommended values as a root user on the host machine: $ sysctl -w vm.max_map_count= $ sysctl -w fs.file-max= $ ulimit -n $ ulimit -u 262144 65536 65536 4096 Step 3: For this guide, we are going to use a simple docker-compose.yml file. However, you are free to edit the file as per your requirement. Before launching the containers, please make sure that you change the value of , , , and . Although, along with this, you can also modify the define ports in the file. GITLAB_SECRETS_DB_KEY_BASE GITLAB_HOST SONARQUBE_JDBC_PASSWORD POSTGRES_PASSWORD version: services:
   jenkins:
       image: jenkinsci/jenkins:lts
       container_name: jenkins-container
       restart: always
       ports:
           - - volumes:
       - - environment:
       - gitlab:
       image: gitlab/gitlab-ce:latest
       container_name: gitlab-container
       restart: always
       environment:
           - GITLAB_SECRETS_DB_KEY_BASE=long-and-random-alphanumeric-string
           - GITLAB_HOST=your-host-ip-here
           - GITLAB_PORT= - GITLAB_SSH_PORT= ports:
           - - volumes:
       - - - sonarqube:
       image: sonarqube: -community
       container_name: sonar-container
       restart: always
       networks:
           - sonarnet
       environment:
           - SONARQUBE_JDBC_USERNAME=sonar
           - SONARQUBE_JDBC_PASSWORD=your-strong-password-here
           - SONARQUBE_JDBC_URL=jdbc:postgresql: ports:
       - - volumes:
       - - - - postgressdb:
       image: postgres: container_name: postgres-container
       restart: always
       networks:
           - sonarnet
       environment:
           - POSTGRES_USER=sonar
           - POSTGRES_PASSWORD=your-strong-password-here
           - POSTGRES_DB=sonarqube
       volumes:
       - - networks:
   sonarnet:
    driver: bridge "3.2" "8080:8080" '50000:50000' '/var/run/docker.sock:/var/run/docker.sock' '/data/jenkins/jenkins_home:/var/jenkins_home' "JENKINS_OPTS=--prefix=/jenkins" 10080 10022 "10080:80" "10022:22" '/data/gitlab/config:/etc/gitlab' '/data/gitlab/logs:/var/log/gitlab' '/data/gitlab/data:/var/opt/gitlab' 7.9 .2 //postgressdb:5432/sonarqube "9000:9000" "9092:9092" '/data/sonar/sonarqube_conf:/opt/sonarqube/conf' '/data/sonar/sonarqube_data:/opt/sonarqube/data' '/data/sonar/sonarqube_extensions:/opt/sonarqube/extensions' '/data/sonar/sonarqube_bundled-plugins:/opt/sonarqube/lib/bundled-plugins' 12.1 '/data/postgresql/sonarqube_db:/var/lib/postgresql' '/data/postgresql/postgresql_data:/var/lib/postgresql/data' Now, run the following command to launch the stack: $ docker-compose up -d Note that the installation process is going to take some time, so sit back and have some coffee. You deserve it! Step 4: Now, to verify if all systems are up and running, run this command: $ docker ps

CONTAINER ID    IMAGE                     COMMAND             CREATED         STATUS                  PORTS                                                   NAMES
f54e223417fa    gitlab/gitlab-ce:latest minute ago minute ago (healthy) /tcp, : -> /tcp, : -> /tcp   gitlab-container f03f69b8    sonarqube minute ago minute ago : -> /tcp                                  sonar-container f554da39fc    jenkinsci/jenkins:lts minute ago minute ago : -> /tcp, : -> /tcp        jenkins-container "/assets/wrapper" 1 1 443 0.0 .0 .0 10022 22 0.0 .0 .0 10080 80 9102 "./bin/run.sh" 1 1 0.0 .0 .0 9000 9000 05 "/bin/tini --..." 1 1 0.0 .0 .0 8080 8080 0.0 .0 .0 50000 50000 If all went well, then you can access all three of them by following mentioned URLs: Jenkins - http://your-ip-address:8080 SonarQube - http://your-ip-address:9000 GitLab - http://your-ip-address:10080 As you are visiting your Jenkins environment for the first time, it is going to prompt you to enter the administrator password, which was generated during the installation process. To access the password from the container, you can run the following command: $ docker exec -it <your-jinkins-container-id> cat / /jenkins_home/secrets/initialAdminPassword
$ gSzHTGfbtXSpcBXMyJ6gzmNfNH7BjhK23 var Once you enter the password, you can select the option . Wait until the download finishes. Install suggested plugin For SonarQube, the default username and password are admin and admin, respectively. Whereas, for GitLab, you will be prompted to enter the new password for the default username root. Configuring Jenkins Pipeline with SonarQube and GitLab integration We will begin with SonarQube. To connect it with Jenkins, you need to generate the token to access the SonarQube instance. SonarQube Configuration: Login into the SonarQube dashboard and go to the Administrator tab. In the Security drop-down menu, select User tab as shown in the below image: Here you will find Administrator user, for which you are going to generate the access token: In the pop-up that displays on your screen, enter the desired name and click on the button. Copy the newly generated token and save it somewhere safe, as you won’t be able to view/copy the generated token again. Generate To establish a connection between GitLab and Jenkins, again, we need to generate an access token, which can be done as mentioned below: GitLab Configuration: To generate an access token, go to your GitLab dashboard and follow . Once you have the token with you, copy it for further use. Dashboard > Setting > Access Tokens This guide assumes that you have already done the basic setup for Jenkins. Now, let’s move to configure GitLab and SonarQube in the Jenkins server. Integrating SonarQube and GitLabs in Jenkins: First, we are going to integrate SonarQube. Go and search for SonarQube. Dashboard > Manage Jenkins > Manage Plugins Make sure you restart Jenkins once the plugin is successfully installed. Once the restart is completed, you have to set up Sonar Scanner, which is a standalone tool used for scanning the source code and send the result to SonarQube Server. Here you are going to install it in the Jenkins container itself, although you are free to launch a separate container for the same purpose. $ docker exec -it <your-jinkins-container-id> bash

$ cd / /jenkins_home

$ wget https: $ unzip sonar-scanner-cli -linux.zip var //binaries.sonarsource.com/Distribution/sonar-scanner-cli/sonar-scanner-cli-4.2.0.1873-linux.zip -4.2 .0 .1873 Go back to the Manage Jenkins page and select Global Tool Configuration. In this page, find SonarQube Scanner and add complete the installation: Don’t forget to uncheck as you have to define the installation path of Sonar Scanner explicitly. Install automatically As Jenkins and SonarQube are running in separate docker containers, we need to create a Webhook at SonarQube Server so that both can communicate with each other. To do so, follow : Dashboard > Administrator > Configuration > Webhook Lastly, you have to add the access token you generated on your SonarQube server in Jenkins. Follow the URL or go to , as shown below: http://your-ip-addr-here:8080/credentials/store/system/ Dashboard > Credentials > System Click on link and select “Secret Text” field under : Add Credentials Kind In the Secret field, paste the generated token from SonarQube that you previously created. Now, add the SonarQube server to your Jenkins environment. Go to . Find on the page and add the required details as mentioned below: Dashboard > Manage Jenkins > Configure System SonarQube server Now, you have to add Gitlab in Jenkins, visit . Here, you are going to add the access token you previously created to your Jenkins server. Although, you can also use with username and password. Dashboard > Credentials > System Kind As you are through with the SonarQube and GitLab integration in Jenkins, it’s time to manage other dependencies. In this guide, we are going to use a simple NodeJs application; hence it’s time to install NodeJS on your Jenkins Server. NodeJS Environment in Jenkins: To install NodeJS plugin, go to and search and select NodeJS. Click on the button, as shown in the figure below. Dashboard > Manage Jenkins > Manage Plugins > Available Install without restart Upon successful installation of NodeJS plugin in Jenkins, make sure that you restart Jenkins. To configure NodeJS plugin, go to and find "NodeJS". Click on NodeJS installation button and add the necessary details, as shown in the figure: Dashboard > Manage Jenkins > Global Tool Configuration Give a name and select the NodeJS version as per your requirement; you can also install Global NPM packages and set the refresh rate depending upon the project requirements. Once done, you need to save the configuration. As we are through with the gruesome part of installing and configuring the environment, it’s time to create the project pipeline. Creating Jenkins Pipeline Here you are going to create a pipeline using Declarative Scripted Pipeline. Follow the below steps to get started: Go to Jenkins’ Dashboard and click on the “New Item” link. Now, enter the item name and select option as shown in the figure: Step 1 - Create a New Job Pipeline The below-mentioned simple pipeline script helps you to pull the code from GitLab, quality check via SonarQube, and use NodeJS. Step 2 - Pipeline pipeline {
agent any
tools {nodejs }
stages {
 stage( ) {
  steps {
   git branch: , : , : }
 }
   stage( ) {
   steps {
       script {
       def scannerHome = tool ;
           withSonarQubeEnv( ) {
           sh sonarqube }
           }
       }
   }
   stage( ) {
   steps {
       nodejs(nodeJSInstallationName: ){
           sh }
       }
   }
}
} "nodenv" "Code Checkout from GitLab" 'master' credentialsId 'gitlab_access_token' url 'http://your-ip-here:10080/root/test-project.git' 'Code Quality Check via SonarQube' 'sonarqube' "sonarqube-container" "${tool(" ")}/bin/sonar-scanner \
           -Dsonar.projectKey=test-node-js \
           -Dsonar.sources=. \
           -Dsonar.css.node=. \
           -Dsonar.host.url=http://your-ip-here:9000 \
           -Dsonar.login=your-generated-token-from-sonarqube-container" "Install Project Dependencies" 'nodenv' "npm install" Make sure that you change the values of GitLab repo URL, SonarQube host URL, and its access token. Add the above-mentioned pipeline script and save it, as shown in the below figure: Now, as you have saved the pipeline script, it’s time to build your application in Jenkins. Go to . Step 3 - Run Pipeline Dashboard > YOUR PROJECT > Build Now As soon as you click the link, Jenkins will start building project as per pipeline script. In Build History, you will see the progress bar for the current build along with the Stage View: Build Now If your build runs successfully, you will be able to see the time taken by each stage, in : Stage View Also, you can visit the SonarQube dashboard to see the project code report, by visiting the link named as "SonarQube" on project pipeline page. That’s it! You have successfully created a Jenkins Pipeline while using SonarQube and GitLab. Now, every time you push the code to the repo, you can build the project, which will show the code quality.

Workflow Automation: Jenkins Pipeline with Sonarqube and Gitlab

In this post I want to show you how you can use your together with . Furthermore I want to also introduce you into a really awesome, cutting edge Test Management Suite for Jira which I use a lot. Bitbucket pipelines Jira Cloud Xray Test Management for Jira Cloud You might have read my last post about — if not you’ll have the chance later on, because I do refer to some configuration. Deploy a React App to Heroku with Bitbucket pipelines Initial Situation In most enterprises we don’t want to change workflows in production environment directly. Instead we have a test instance or project where we build stuff first and then present it to the business. In this article we’ll assume we have the following simple workflow and a rule for transition issues from to . This rule checks if the user is in the Project Role of (we’ll assume the user is 😉🙄). “Backlog” “In Progress” Administrator Now that we have implemented the Jira workflow the way the business needs it, we need to test the workflow. Sure, you could say, let’s do it manually because it’s a quick test. But in most cases we do have more complex scenarios, don’t we? I want to show you, how you can test your Workflow automatically with a small (Python) running on . Pytest app Bitbucket Pipelines In addition to that I want to introduce the app — a cutting edge Test Management Suite for Jira. There we will write a Test Plan and trigger the Bitbucket Pipeline. Xray Test Management for Jira Cloud Disclaimer For simplicity’s sake, we will omit appropriate authentication or code formatting. What we will do here will work, but it should not be used in any production environment. Prerequisites To get started we need to prepare some stuff first to make sure that everything is working fine. What we need for this tutorial is: Python3 installed on your local machine – see documentation Python IDE installed – in my case this is from Jetbrains PyCharm generated – Jira API token see documentation generated – Xray API token see documentation generated – Bitbucket App Password see documentation Let's Get Started! Step 1 — Create a Python app: Yes, this time round we’ll build a small Python app which does nothing more than transition an Jira issue from one status to another. Therefore, you need to: Open up PyCharm Create a new Python Project Make sure you use as your Python environment Pipenv After we’ve created our Python app we need to install at least two python packages. Head over to: → → Settings Project:<your-app-name> Project Interpreter Install and via the little + sign on the right side jira-3.0a2 pytest In the project root create a folder with the name and within the folder create a file called The file will look pretty simple and we do manage all stuff e.g. authentication, within this file. tests test_transition.py. jira JIRA, JIRAError

jira = JIRA(
    options={ : },
    basic_auth=( , ),
) from import "server" "https://<domain>.atlassian.net" "<E-MAILADDRESS>" "<API-TOKEN>" At first we need to load the Jira library for authentication and using all the Jira methods we need to update and transition issues. After we’ve imported all we need, we can authenticate to our Jira Cloud instance. It is important that you use the API token mentioned above in the prerequisites. Jira Cloud doesn’t allow you to use basic authentication with username and password anymore. Next we add the test itself directly below the authentication. The steps are: Get the issue(s) Execute the transition — at least try If correct assert the new issue status ( ) In Progress If not correct assert the current issue status ( ) Backlog issue = jira.issue( ) :
        jira.transition_issue(issue, ) JIRAError: issue.fields.status.name == issue.fields.status.name == : def test_in_progress () "<ISSUE-KEY>" try "In Progress" except assert "Backlog" return assert "In Progress" At this point we already can test our Python app. To do that we need to create a Run Configuration: Go to → Run Edit configurations Click on symbol → choose (absolute path to your test file) + pytest Add the and (absolute path of tests folder) Script Path Working Directory After that we can right-click our folder and choose Our result should look something like this: tests pytest in tests. Step 2 — Upload the app to Bitbucket: For this please read my where I explain in detail how you can setup your code repository and how to enable pipelines for it. previous post After you’ve setup your Bitbucket repository, open a terminal, make sure you are in the root directory of your Python app, and type the following lines: git init
git add .
git commit -m git remote add origin https://username@bitbucket.org/username/name-of-your-repository.git
git push -u origin master "initial commit" When you refresh the browser page, you should see all the files and folders of the app you’ve just commited to the git repository. Now that we have everything up and running, add the following : bitbucket-pipeline.yml image: python:3.8.3
pipelines:
  default:
    - step:
        caches:
          - pip
        name: Run tests
        script:
          -  |
             pip install pipenv
             pip --version
             pipenv install pipenv run python3 -m pytest --junitxml= -result.xml test_transition.py token=$(curl -H -X POST --data https://xray.cloud.xpand-it.com/api/v1/authenticate| tr -d )
             curl -H -H --data @ -result.xml echo "Test my amazing script" test export "Content-Type: application/json" "{ \"client_id\": \" \",\"client_secret\": \" \" }" $client_id $client_secret '"' "Content-Type: text/xml" "Authorization: Bearer " $token test "https://xray.cloud.xpand-it.com/api/v1/import/execution/junit?projectKey=TP&testPlanKey=<ISSUE-KEY>" echo "done" Puuhh! 😵 Let's go through this step by step: We install because it takes care of everything you need to work with your app and it is just awesome! pipenv We install all libraries added to our Project and therefore to the Pipfile with pipenv install We run our test(s) with the special parameter — = (important use double dashes infront of junitxml!) junitxml <filename>.xml We get our token with the credentials mentioned above Xray Cloud App We push the to the Xray Cloud App test-result.xml Finally we specify the and our which we will create in a second. Project Key Xray Test Plan Step 3 — Install and configure Xray: Installing Xray is really easy and straight forward. Go to in your Settings menu on the top right Apps Go to and search for Xray Find new Apps Click on the Card and install the App via Try Free In app marketplace side in Jira Cloud Step 4 — Create a Test Plan and a Task: First we create a new Project. You can choose any type of Project Type, all will work with Xray. In our case we create a with the name and the key Classic — Kanban Project Test project TP. If you’ve never used Xray before and need help setting up your project, they got awesome documentation here: Quick Setup - Xray Cloud Documentation - Xray (getxray.app) After configuring our Project we need to create two issues. - This one will receive all Test Execution and Test issues which will automatically be created when triggering the pipeline (see our pipeline.yml) Test Plan - This one is our Task with the Workflow we want to Test. Task Step 5 — Trigger Bitbucket Pipelines via Jira Automation: So let’s do the following: Go to Project Settings Choose Automation Create a New rule For the trigger we will use Issue transitioned: Next, we add a . Under the section we pick New Action Notification Send web request. : Webhook URL https://api.bitbucket.org/2.0/repositories/{workspace}/{repo_slug}/pipelines/ In the text area just add the following JSON: { : { : , : , : }
} "target" "ref_type" "branch" "type" "pipeline_ref_target" "ref_name" "master" For more details take a look at the REST API Endpoint in the official documentation . Now that we have everything setup, let’s grab some popcorn and let’s enjoy what we’ve just build. Our Jira Board should look something like this Let’s move the issue in our from to . This should trigger our pipeline! Go to your Bitpucket pipeline — you should see that the build just has started. TP-1 Test Plan Backlog In Progress After the pipeline tasks are successfully done let’s head back to Jira. Our Task was transitioned to thanks to our Python app. Now we know that the business team will be happy and we can prove to them even before the presentation that everythings works as requested. In Progress Xray automatically created a Test Execution and a Test for us. Even more we’ve pushed the results to the Test Plan. — Result after running the Bitbucket pipeline Test Plan — Created after running the Bitbucket pipeline Test Execution About Jodocus The team brings its expertise in business processes, ALM, DevOps and Cloud to you! We make our clients’ lives easier by fitting the tools to your needs. Jodocus is a Cloud First Solution Partner with a focus on Business Processes. We help teams of all kind to digitize their Workflows and use the power of collaboration to elevate their daily work. Our expertise is to smoothly integrate Atlassian tools into your companies‘ toolset and get your teams ready for teamwork! Jodocus About Xray is the leading Quality Assurance and Test Management app for Jira. Improve the quality of your systems through effective and efficient testing that runs through the entire software development lifecycle. supports both manual and automated tests and provides powerful reports to ensure full requirements coverage. More than 4.5 million testers, developers and QA managers trust Xray to manage 100+ million test cases each month. is a mission-critical tool at over 5,000 companies in 70+ countries, including 137 of the Global 500. Xray Xray Xray Hope you liked it, even more I hope it helps you! Please let me know! Also published at https://medium.com/jodocus-blog/test-automation-of-jira-cloud-workflows-using-bitbucket-pipelines-and-xray-test-management-3ff316b03e25

How to Use BitBucket Pipelines and Xray Test Management to Test Automation of Jira Cloud Workflows

This series of articles teach you step-by-step, how to deploy an AI model on the embedded platform, and here we take opensource RT-Thread IoTOS as an example. Development Environment The development process is based on the STM32H743ZI-Nucleo board and the STM32CubeMX.AI tool is used, as it supports automatically generating various embedded projects (including but not limited to MDK, STM32CubeIDE, etc.) based on a trained AI Model (Keras/TF-Lite only). The tool is easy to get started and is suitable for embedded AI start-up development. 1. Preparation 1.1 Install Development Environment The operating system I use is Ubuntu 18.04. This tutorial also applies to Windows environments, with exactly the same experimental steps. The following development tools are used in this experiment: STM32CubeMx STM32CubeIDE STM32CubeProgrammer The STM32Cube may cause the following errors in the ubuntu environment: After installation, When running the executable files under the ‘bin’ folder in the terminal, an error is reported: the main class “com.st.app.Main” cannot be found or loaded, so you need to change Ubuntu’s default Open-JDK into Oracle JDK, as shown below: 1# sudo tar zxvf jdk-8u172-linux-x64.tar.gz -C /usr/lib/jvm 2# sudo update-alternatives — install /usr/bin/java java /usr/lib/jvm/jdk1.8.0_172/bin/java 300 3# sudo update-alternatives — config java 4# java -version Start by cloning the following open source repositories to the local: Github: https://github.com/Lebhoryi/Edge_AI/tree/master/Project1 In this experiment, I chose the simplest Linear Regression Tensor Flow2 Demo as an example, and the model-related source file specifications are as follows: contains three different ways to construct the network tf2_linear_regression.ipynb contains different ways to train models tf2_Linear Regressions 'Extended.ipynb Note that there are 3 ways to build the model: Sequence Functional API Subclasses When you import the AI model into CubeMx, you will encounter the following errors if you use the network model generated in the latter two ways: The temporary solution is to build a neural network in the form of a , and the trained AI Model is saved as Keras format, with a suffix of .h5, such as keras_model.h5. 1INVALID MODEL: Couldn't load Keras model /home/lebhoryi/RT-Thread/Edge_AI/Project1/keras_model.h5, 2error: Unknown layer: Functional Sequence The sample model I have saved, you can directly download the model for experiments, Here’s the link download The neural network model structure trained in this example is as follows: 2. Generate Project by CubeMX AI Select the STM32H743ZI Nucleo development board in CubeMX, where there are no restrictions on board models. 2.1 Open CubeMX 2.2 Install CUBE-AI Software Package Open in the menu bar, select , and then select the latest version of the plug-in in the column, and click in the lower right corner after installation. Help Embedded Software Packages Manager X-CUBE-AI STMicroelectronicSTs Close Import plug-in in your project: X-CUBE-AI The following interface appears: Next, select the serial port for communication, and here we select serial 3 because this serial port is used as the virtual serial port of the ST link. 2.3 Import AI Model to Project Before burning the AI model to the development board, you need to analyze the Model to see if it can be converted to the embedded project properly, and the model we use in this experiment is simple and can be analyzed more quickly, with the results as follows: Next, we’ll validate the converted embedded project on the board, in which the CubeMX AI tool automatically generates the embedded project based on the AI model you imported. It burns the compiled executable file into the board and verifies the running results through STlink’s virtual serial port. Since Ubuntu does not support MDK, I have to choose to automatically generate the STM32CubeIDE project here. The validated result is shown as follows: 2.4 Generate Project We just verified the project results in the previous step, now we are going to generate project source code, as shown in the following image: The generated Project folder tree looks like this: At this point, we are finishing most of the works, the rest we need to do is debugging. 1(base) #( 07/03/20@10:51 am )( lebhoryi@RT-AI ):~/RT-Thread/Edge_AI@master✗✗✗ 2   tree -L 2 ./Project1 3./Project1 4├── DNN  # CubeMX Generate Project Path 5│   ├── DNN.ioc  # CubeMX file 6│   ├── Drivers 7│   ├── Inc 8│   ├── Middlewares 9│   ├── network_generate_report.txt 10│   ├── Src 11│   ├── Startup 12│   ├── STM32CubeIDE 13│   ├── STM32H743ZITX_FLASH.ld 14│   └── STM32H743ZITX_RAM.ld 15├── image  # Related picture save folder 16│   ├── mymodel1.png   # model 17│   └── STM32H743.jpg  # H743 18├── model  # model Save path 19│   └── keras_model.h5 20├── Readme.md 21├── tf2_linear_regression.ipynb 22└── tf2_ Regressions_Extended.ipynb 3. Code Debugging To get to know STM32CubeIDE, please refer to this link . here 3.1 Import Project Select the File option →import: Select the path of the previous export project: The interface for a successful import looks like this: We can then use the STM32Cube IDE to debug the generated project. 3.2 Generate bin File The corresponding bin file is automatically generated during compilation, which can be burned to the board later by the stm32cubeProgramer tool. 3.3 Burn.bin File Open , click in the upper right corner, then select and select the file we want to open. STM32CubeProgramming connect Open file .bin The dialogue for successful burning: 3.4 Others In the ubuntu system, we can use the serial tool to view the running results of the final program, as follows: Before using the cutecom connection serial port, remember to disconnect the STM32Programer and the development board, otherwise there will be an error when opening the serial-port. cutecom RT-Thread Information: | | | | Website Github Twitter Facebook Youtube

Stories, News & Mentions about PROJECT10K

Project10k’s Stories on HackerNoon