These binlog files are very storage-intensive, most of the time for a small application each binlog file will be around 1.2GB.

Now imagine if you have 20GB disk-space it will eat up pretty much everything to the point where not a single kb is remaining for the server, if such thing happens, we even can’t run small commands like opening a file or editing a file etcetera.

As you can see in below image where It uses 100% of disk space 🙁

Some blog suggested that we can delete those files using myql> in terminal, however if you don’t have any space left we can’t even run sql in terminal.

The right way to remove binlog files.

If you are a root user to the system you can do following things to get it deleted in proper way.

login to the system via ssh and run below command, it will make you root user.

sudo -su

Run df -h to check current disk space information, it will show you something like below. check /dev/xvda1 section it consume all the space which I have it 🙁

Filesystem      Size  Used Avail Use% Mounted on
udev            236M     0  236M   0% /dev
tmpfs            49M  5.7M   44M  12% /run
/dev/xvda1       20G   20G     0 100% /
tmpfs           244M     0  244M   0% /dev/shm
tmpfs           5.0M     0  5.0M   0% /run/lock
tmpfs           244M     0  244M   0% /sys/fs/cgroup
/dev/loop0       92M   92M     0 100% /snap/core/8689
/dev/loop1       18M   18M     0 100% /snap/amazon-ssm-agent/1480
/dev/loop2       18M   18M     0 100% /snap/amazon-ssm-agent/1566
/dev/loop4       94M   94M     0 100% /snap/core/8935
tmpfs            49M     0   49M   0% /run/user/1000

To get more information about your database usage you can run du -hs /opt/bitnami/mysql/data for me, it’s 16 bg, which is way too much for small application.

16G	/opt/bitnami/mysql/data

To check all the big files (in space allocation) run below command, it will show list of culprits

du -hs /opt/bitnami/*/*/* |sort -rh | head -35

1.1G	/opt/bitnami/mysql/data/binlog.000017
1.1G	/opt/bitnami/mysql/data/binlog.000016
1.1G	/opt/bitnami/mysql/data/binlog.000015
1.1G	/opt/bitnami/mysql/data/binlog.000014
1.1G	/opt/bitnami/mysql/data/binlog.000013
1.1G	/opt/bitnami/mysql/data/binlog.000012
1.1G	/opt/bitnami/mysql/data/binlog.000011
1.1G	/opt/bitnami/mysql/data/binlog.000010
1.1G	/opt/bitnami/mysql/data/binlog.000009
1.1G	/opt/bitnami/mysql/data/binlog.000008
1.1G	/opt/bitnami/mysql/data/binlog.000007
1.1G	/opt/bitnami/mysql/data/binlog.000006
1.1G	/opt/bitnami/mysql/data/binlog.000003
1.0G	/opt/bitnami/mysql/data/binlog.000018
569M	/opt/bitnami/mysql/data/binlog.000004

At this point you even can’t open file via nano etc.txt or preform any other operation in the system as no space is left.

You can delete binlog.000001 to get some space, run rm binlog.000001 once it’s deleted you will be able to run nano command.

Now open binlog.index file using nano binlog.index and remove all the entries of binlog.0xxx from binlog.index file, once done save it and exit.

Run below to remove all fu(king binlog files at once, if you want you can remove mysqld.log files to as it might not be any use.

rm binlog.00*

After this if you run df -h you will get your space back. check /dev/xvda1 section 🙂

Filesystem      Size  Used Avail Use% Mounted on
udev            236M     0  236M   0% /dev
tmpfs            49M  5.7M   44M  12% /run
/dev/xvda1       20G  4.4G   15G  23% /
tmpfs           244M     0  244M   0% /dev/shm
tmpfs           5.0M     0  5.0M   0% /run/lock
tmpfs           244M     0  244M   0% /sys/fs/cgroup
/dev/loop0       92M   92M     0 100% /snap/core/8689
/dev/loop1       18M   18M     0 100% /snap/amazon-ssm-agent/1480
/dev/loop2       18M   18M     0 100% /snap/amazon-ssm-agent/1566
/dev/loop4       94M   94M     0 100% /snap/core/8935
tmpfs            49M     0   49M   0% /run/user/1000

Hope this will be helpful to someone.

I go beyond boundaries that trap me. Attachments and limitations in thinking are removed and I see people as actors playing roles sometimes negative and sometimes positive and scenes as passing phases, sometimes negative and sometimes positive. This experience translates into power in the consciousness as well as in words and actions.

You may check other informative article https://otricks.com/responsiveness-in-reactive-programming/

The post How to delete MySQL binlog files if you don’t have disk space left appeared first on Otricks.com.

Note : This article is technology agnostic and is mostly conceptual.

What is reactive programming?

Reactive Programming is a programming paradigm, which helps you to build a reactive system. It advocates a declarative, event driven programming approach, modeled around ‘data flows’ between computing components.

What is a reactive system?

A reactive system is a system, which has the below key characteristics.

1. Responsive – Ability of a system to respond in a timely manner
2. Resilient – Ability of a system to stay responsive even during failures
3. Elastic – Ability of a system to stay responsive under varying workload
4. Message driven – Reliance on message passing (think data flows) to communicate between different computing components in a system

The key to reactive programming is in understanding the idea of ‘Responsiveness’.

Understanding responsiveness

The word responsive means ‘quick to react‘. Responsiveness is the ability of a system to complete an assigned task, within a given time, appropriate for the task. Please note, the notion of completeness does not mean that the assigned task was successful. It could also mean that a given task could be a failure as well. A responsive system ‘responds‘ within a given time, irrespective of whether the assigned task was successful or unsuccessful.

Responsiveness is one of the primary goals of reactive programming.Let’s understand responsiveness by comparing to a man-made system.

Example man-made system

Bear with me for a moment. The below example is used to highlight important concerns, which I believe are pre-requisites for reactive programming.

Imagine a flower shop which sells the below products,

1. Standard bouquets – Prepackaged bouquets with flower combination chosen by the shop. The shop is keen to sell more of these since they can serve more customers per unit time
2. Custom bouquets – A customer can order a custom combination of flowers based on his/her preference. This product costs extra compared to the standard ones. It also incurs an extra delivery time

This flower shop employs 2 staff who have the below responsibilities,

1. Counter staff – The person responsible for accepting and delivering orders to the customer
2. Packaging staff – The person who is responsible for packaging custom orders. When there are no custom orders, he / she will work on packaging the standard bouquets when required

Given a flower shop system described above, let us define the following times which are inherent in such a system.

1. Queue Wait Time (Customer) – The duration a customer waits in the queue to place an order
2. Service Time – The duration it takes for the flower shop to full-fill an order
3. Custom order queue time – The wait time for a custom order in queue for packaging
4. Custom bouquet packaging time – The duration taken by the bouquet packager to package a custom request
5. Overall Service time – The overall duration for a customer to complete his objective. This duration is the sum of the durations 1 to 4. Note that, duration 3 & 4 above for standard product customers depend on other custom bouquet customers.

Not so responsive system

Let’s assume that the flower shop chooses the following rules for servicing its customers,

1. The counter staff will wait for the customer’s order to be completely delivered, before taking on the next customer
2. Once packaging is complete, the packaging staff hands over the completed order to the counter staff for delivery

Given these conditions , the follow are the characteristics of such a system

1. The customer queue length and time increases with more custom order requests
2. The Overall service time for a standard bouquet customer is dependent on the number of custom bouquet request before him/her
3. The number of customers the flower shop can service per hour, depends on the number of custom orders. As more custom orders come in, the less number of customers can be serviced per unit time.
4. The more the number of custom bouquet requests there are, the more idle time for the counter staff

So given these characteristics, let us ponder about the responsiveness of such a system.

This system is unresponsive, as the customers can’t expect a standard overall service time in the illustration above.

If the number of custom bouquet requests are relatively less , then they may get a better service time. However this is entirely dependent on chance, which is not a desirable property to depend on. This system is also inefficient, because of the idle time of the counter staff. This inefficient design also reduces the throughput (the number of customers served in unit time) of the system.

A responsive system

Let us relook at the above mentioned flower shop with a slight redesign of the operations. The illustration below highlights the important changes made.

Let’s make the below changes in this system,

1. The counter staff will guide the customer to a dedicated wait queue on taking a custom order
2. He/She then places the custom order to the packaging queue, and proceeds to service the next customer
3. On completing a custom bouquet request, the packaging staff delivers the package to the waiting customer, without bothering the counter staff.

Such a system will then have the below characteristics which are different from the previous one in some key aspects.

1. This system serves more customers per unit time, since the counter staff spends less time waiting
2. Quicker service time for a standard bouquet customer since queue wait time is not dependent on the custom bouquet packaging
3. More efficient, since the idle time of the counter staff is very less compared to the previous one

Overall the above system is more responsive than the previous one. Here the standard bouquet customer can expect a overall standard service time in comparison.

Relevance to reactive programming

The flower shop here serves as a metaphor for a computing system. Reactive programming emphasizes the resource oriented view of a computing system. For example the cpu cores, memory, storage subsystems etc. are all resources. These resources also have similar queueing characteristics of the flower shop mentioned above.

A typical software will use a number of these resources (cpu, memory, disc, network) to achieve its intended function. These software also interact with other software at runtime and so on. Such a system, is a network of interconnected, computing components working in coordination to achieve a bigger goal.

Which means any failure / delay due to a lack of resource availability will have a repercussion in the upstream computing component’s responsiveness.

The number of interconnected components is directly proportional to the availability and responsiveness of the computing system, unless carefully designed. A failure / delay in any intermediate component will have a direct impact on the system’s responsiveness and availability.

Reactive programming, requires you to think in terms of data flowing between computing components. This model allows you to build robust software which are responsive to delays and failures.

Responsiveness in reactive programming

Let’s now briefly look at how reactive programming proposes to solve the above mentioned responsiveness problem.

Reactive programming forces the programmer to think of a system, as a set of connected computing components which,

1. Is aware of the limitedness of resources at its disposal
2. Responds to requests in a timely fashion
3. Reacts to data flowing through them
4. Self heal by automatically resisting data flow

Conclusion

We have reached the end of this article. I hope i managed to convey the primary goal of reactive programming, which is ‘responsiveness’. Of course there is more to reactive programming. We can delve into other aspects of reactive programming in a later article. Until then, Bye for now!

The post Reactive Programming : Understanding Responsiveness appeared first on Otricks.com.

The pinning is an optional mechanism that can be used to improve the security of a service or site that relies on SSL Certificates. Pinning allows you to specify a cryptographic identity that should be accepted by users visiting your website

It’s a two-part process, first, we need to get a certificate from our API server where we host our backend services. second, we will need to implement SSL Pinning in the ionic app. Without further ado, let’s start the first part:

Step 1: Get the SSL Certificate from API Server.

Let’s pretend that our API server is otricks.com we can get an SSL certificate for the same, I will show you a very easy way to get it via Firefox browser.

Go to otricks.com or your API endpoint with https

When you click on PEM(cert), it will download otricks-com.pem file which you can convert it to filename.cer file extension. You need to have OpenSSL tool install in your machine, I have it already in my Macbook Pro. You can google it and install it.

Open a terminal window and run below command which will convert .pem a file to .cer file, change “nameOfPemFile.pem ” with your file and adjust the path accordingly. Once you run below command it will convert your pem file to cer file which we need for our next step.

openssl x509 -inform PEM -in /Users/anjum/Downloads/nameOfPemFile.pem -outform DER -out /Users/anjum/Downloads/certificate.cer

Step 2: Create a new Ionic 5 project.

Let’s create a new empty project with the Ionic CLI tool

ionic start sslpinning tabs

Open the project and edit the angular.json file add certificates block something like below. check app => architect => build => assets section. This way Angular will copy our certificates inside www folder of ionic when we build project

{
    "glob": "**/*",
    "input": "src/certificates",
    "output": "certificates"
},

{
  "$schema": "./node_modules/@angular/cli/lib/config/schema.json",
  "version": 1,
  "defaultProject": "app",
  "newProjectRoot": "projects",
  "projects": {
    "app": {
      "root": "",
      "sourceRoot": "src",
      "projectType": "application",
      "prefix": "app",
      "schematics": {},
      "architect": {
        "build": {
          "builder": "@angular-devkit/build-angular:browser",
          "options": {
            "outputPath": "www",
            "index": "src/index.html",
            "main": "src/main.ts",
            "polyfills": "src/polyfills.ts",
            "tsConfig": "tsconfig.app.json",
            "assets": [
              {
                "glob": "**/*",
                "input": "src/assets",
                "output": "assets"
              },
              {
                "glob": "**/*",
                "input": "src/certificates",
                "output": "certificates"
              },
              {
                "glob": "**/*.svg",
                "input": "node_modules/ionicons/dist/ionicons/svg",
                "output": "./svg"
              }
            ],
            "styles": [
              {
                "input": "src/theme/variables.scss"
              },
              {
                "input": "src/global.scss"
              }
            ],
            "scripts": []
          },
          "configurations": {
            "production": {
              "fileReplacements": [
                {
                  "replace": "src/environments/environment.ts",
                  "with": "src/environments/environment.prod.ts"
                }
              ],
              "optimization": true,
              "outputHashing": "all",
              "sourceMap": false,
              "extractCss": true,
              "namedChunks": false,
              "aot": true,
              "extractLicenses": true,
              "vendorChunk": false,
              "buildOptimizer": true,
              "budgets": [
                {
                  "type": "initial",
                  "maximumWarning": "2mb",
                  "maximumError": "5mb"
                }
              ]
            },
            "ci": {
              "progress": false
            }
          }
        },
        "serve": {
          "builder": "@angular-devkit/build-angular:dev-server",
          "options": {
            "browserTarget": "app:build"
          },
          "configurations": {
            "production": {
              "browserTarget": "app:build:production"
            },
            "ci": {
              "progress": false
            }
          }
        },
        "extract-i18n": {
          "builder": "@angular-devkit/build-angular:extract-i18n",
          "options": {
            "browserTarget": "app:build"
          }
        },
        "test": {
          "builder": "@angular-devkit/build-angular:karma",
          "options": {
            "main": "src/test.ts",
            "polyfills": "src/polyfills.ts",
            "tsConfig": "tsconfig.spec.json",
            "karmaConfig": "karma.conf.js",
            "styles": [],
            "scripts": [],
            "assets": [
              {
                "glob": "favicon.ico",
                "input": "src/",
                "output": "/"
              },
              {
                "glob": "**/*",
                "input": "src/assets",
                "output": "/assets"
              }
            ]
          },
          "configurations": {
            "ci": {
              "progress": false,
              "watch": false
            }
          }
        },
        "lint": {
          "builder": "@angular-devkit/build-angular:tslint",
          "options": {
            "tsConfig": [
              "tsconfig.app.json",
              "tsconfig.spec.json",
              "e2e/tsconfig.json"
            ],
            "exclude": ["**/node_modules/**"]
          }
        },
        "e2e": {
          "builder": "@angular-devkit/build-angular:protractor",
          "options": {
            "protractorConfig": "e2e/protractor.conf.js",
            "devServerTarget": "app:serve"
          },
          "configurations": {
            "production": {
              "devServerTarget": "app:serve:production"
            },
            "ci": {
              "devServerTarget": "app:serve:ci"
            }
          }
        },
        "ionic-cordova-build": {
          "builder": "@ionic/angular-toolkit:cordova-build",
          "options": {
            "browserTarget": "app:build"
          },
          "configurations": {
            "production": {
              "browserTarget": "app:build:production"
            }
          }
        },
        "ionic-cordova-serve": {
          "builder": "@ionic/angular-toolkit:cordova-serve",
          "options": {
            "cordovaBuildTarget": "app:ionic-cordova-build",
            "devServerTarget": "app:serve"
          },
          "configurations": {
            "production": {
              "cordovaBuildTarget": "app:ionic-cordova-build:production",
              "devServerTarget": "app:serve:production"
            }
          }
        }
      }
    }
  },
  "cli": {
    "defaultCollection": "@ionic/angular-toolkit"
  },
  "schematics": {
    "@ionic/angular-toolkit:component": {
      "styleext": "scss"
    },
    "@ionic/angular-toolkit:page": {
      "styleext": "scss"
    }
  }
}

Let’s make certificates folder inside src folder and copy your .cer file inside it. please check the screenshot below for the folder structure.

Now open the terminal and run ionic cordova platform add android to add an android platform. It will generate all related files and folders for android. Open the file config.xml and add below code inside the platform block.

<platform name="android">
     <!-- other tags will be here  -->
    <resource-file src="src/certificates/certificate.cer" target="src/certificates/certificate.cer" />
</platform>

Next, we need to include the Cordova plugin for SSL Pinning, for that we will use https://github.com/silkimen/cordova-plugin-advanced-http plugin which is great. Run below commands in the terminal to install the plugin in the project and we will also need ionic native too.

ionic cordova plugin add cordova-plugin-advanced-http

npm install @ionic-native/http

Once done open app.component.ts file and add code inside initializeApp() function check below file

import { Component } from '@angular/core';

import { Platform } from '@ionic/angular';
import { SplashScreen } from '@ionic-native/splash-screen/ngx';
import { StatusBar } from '@ionic-native/status-bar/ngx';

 
import { HTTP } from '@ionic-native/http/ngx'; //<=== Import this 

@Component({
  selector: 'app-root',
  templateUrl: 'app.component.html',
  styleUrls: ['app.component.scss']
})
export class AppComponent {
  constructor(
    private platform: Platform,
    private splashScreen: SplashScreen,
    private statusBar: StatusBar,
    private httpSSL: HTTP //<=== define this too
  ) {
    this.initializeApp();
  }

  initializeApp() {
    this.platform.ready().then(() => {
      this.statusBar.styleDefault();
      this.splashScreen.hide();

      this.platform.ready() 
      .then(() => {
          
          
        this.httpSSL.setServerTrustMode("pinned") //<=== Add this function 
          .then(() => {
              console.log("Congratulaions, you have set up SSL Pinning.")
          })
          .catch(() => {
              console.error("Opss, SSL pinning failed.")
          });
          
          
      })

    });
  }
}

Now create new service folder to keep all our http service at one place something like below and create api.service.ts file

api.service.ts

import { Injectable } from '@angular/core';
import { HTTP } from '@ionic-native/http/ngx';

@Injectable({
  providedIn: 'root'
})
export class ApiService {
    
    readonly  apiEndPoint = 'https://otricks.com/api/user';
    readonly  fakeEndPoint = 'http://www.google.com/api/xyz'
    
    // This will get work with SSL Pinning becuase API endpoint is same as our certificate 
    getDataFromActualAPi(){
        return this.http.get(`apiEndPoint`,{}, {});
    }
    
    
    // This call will be fail as the domain is not correct according to our certificate.
    getDataFromFakeApi(){
        return this.http.get(`fakeEndPoint`,{}, {});
    }

}

When you call this API service in the component getDataFromActualAPi() will return your correct response, however, if you try to call getDataFromFakeApi() the function will fail as the provided certificate is not from this domain.

The system will throw below error message, you can check in the debugger console.

{status: -2, error: "TLS connection could not be established: javax.net…n: Trust anchor for certification path not found."}
error: "TLS connection could not be established: javax.net.ssl.SSLHandshakeException: java.security.cert.CertPathValidatorException: Trust anchor for certification path not found."
status: -2
}

Hope this will help someone 🙂 if you like this article you may want to check how to protect your server

The post How to implement SSL Pinning in Ionic 5? appeared first on Otricks.com.

We have covered all the great features including, world’s best photo from great photographers, best quotes to get motivated and inspire every day, add new abstract patterns to show your creativity and imagination, view the current time and set world clock with a different timezone that could be useful if you are working on multiple locations and want to see a quick time.

New Amazing Tab will be free forever for people like you and me

Features list

• Get amazed with a fresh image every day from world-class photographers.
• Create wallpaper patterns, to show your creative side. save created pattern into a photo album.
• Change wallpaper image or set your own image as a wallpaper image.
• Set Image change on every new tab open or every hour.
• Search images from millions of images and set as wallpaper.
• Get images from already crafted categories to suit your choice.
• Set multiple clocks to have different timezones time with your custom names.
• Set master clock with different styles, such as Rotary clock, Classical clock, Digital clock, and 3D clock.
• Get motivated every day with the best quotes, you can change or add to favorite your quote.
• Set Salat times (Muslim prayer) based on your current location or set the different locations of your choice.

Please download it from the chrome store and provide your feedback.

https://chrome.google.com/webstore/detail/new-amazing-tab/ekbpbniminfcdefejlmipbdcnoblhamb?h1=en

The post Best & free google chrome plugin with HD wallpaper, world time, quotes with many more.. appeared first on Otricks.com.

According to Ubuntu data, there are around at least 20 million users are using Ubuntu and that’s a very big number. It would be a gold mine for attackers who keep trying to get access to your server using a brute-force attack, for those who don’t know what the hack is brute-force attack?. its an attempt to crack username and password, using trial and error approach with the hope to get it correct for multiple time, if you keep your password or username very generic or easy to guess they might get into your system.

It’s a very old attack method, however, it’s still very effective and popular within the hacker community. You can read more about brute-force attack here.https://en.wikipedia.org/wiki/Brute-force_attack

It’s always a better idea to secure your system/service/server from such wicked people. Let’s get it done.

I will be using my Ubuntu 18.04.4 LTS (GNU/Linux 4.15.0-88-generic x86_64) machine.

Update your system first running below commands in the terminal, my assumption is you are already logged in with Root access using SSH.

apt-get update
apt-get upgrade

After a system update add Fail2ban, which is an invasion blocking software framework that protects servers from brute-force attacks, it’s written in the Python.

Fail2Ban scans log files like /var/log/auth.log and bans IP addresses conducting too many failed login attempts. It does this by updating system firewall rules to reject new connections from those IP addresses, for a configurable amount of time.

Fail2Ban comes out-of-the-box ready to read many standard log files, such as those for sshd and Apache, and is easily configured to read any log file of your choosing, for any error you wish.

Though Fail2Ban is able to reduce the rate of incorrect authentication attempts, it cannot eliminate the risk presented by weak authentication. Set up services to use only two factor, or public/private authentication mechanisms if you really want to protect services.

apt-get install fail2ban

Copy the configuration file and do changes

sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local

sudo nano /etc/fail2ban/jail.local

Change the ban time from 600 (10 minutes) to 604800 (7 days) is guess this would be more than enough to have peaceful nights 🙂

Nest step is to install logwatch is the tool the aggregate all system logs and make meaningful decisions.

apt-get install logwatch

Logwatch can be configurated to trigger a daily email of your logs.

nano /etc/cron.daily/00logwatch

Add below line at the bottom of the cron job file and replace the example email with your own address.

/usr/sbin/logwatch --output mail --mailto mail@example.com --detail high

The post How to secure your Ubuntu server from brute-force attacks?. appeared first on Otricks.com.

While working on angularjs to angualr 9 or ionic to ionic 5, I have a variety of node versions in different projects. Node community has also faced similar problems, to rescue there is a package to manage different versions of the node in a single computer, without uninstalling or re-installing your required version.

You can install https://github.com/nvm-sh/nvm in your computer to manage node

Once install its very easy to change your desire node version. To download, compile, and install the latest release of the node, do this:

nvm install node # "node" is an alias for the latest version

The post Manage Multiple version of Node in a single machine appeared first on Otricks.com.