DEV Community: Ramesh0807

Let's explore OOP concepts using the example of a Royal Enfield motorcycle

Ramesh0807 — Fri, 11 Aug 2023 15:45:35 +0000

Object-Oriented Programming (OOP) is a programming paradigm that revolves around the concept of organizing data and code into objects, which are instances of classes. OOP encourages the use of classes and objects to model real-world entities and their interactions

Class: A class is a blueprint for creating objects. In the context of a Royal Enfield bike, we can define a Bike class.

class Bike {
  constructor(model, color) {
    this.model = model;
    this.color = color;
    this.speed = 0;
  }

  start() {
    console.log(`${this.color} ${this.model} bike is started.`);
  }

  accelerate(speed) {
    this.speed += speed;
    console.log(`Accelerating to ${this.speed} km/h.`);
  }

  brake() {
    this.speed = 0;
    console.log("Brakes applied. Bike is stopped.");
  }
}

Object: An object is an instance of a class. Here, we can create two instances of the Bike class.

const classic350 = new Bike("Classic 350", "Black");
const bullet500 = new Bike("Bullet 500", "Desert Storm");

Encapsulation: Encapsulation is the concept of bundling data (attributes) and methods (functions) that operate on that data within a single unit, i.e., the class. In our example, the Bike class encapsulates the bike's attributes (model, color, speed) and methods (start, accelerate, brake).

Inheritance: Inheritance allows a class (subclass or derived class) to inherit the properties and behaviors of another class (superclass or base class). For example, we can create a RoyalEnfield subclass that inherits from the Bike class and adds specific features.

class RoyalEnfield extends Bike {
  constructor(model, color, variant) {
    super(model, color);
    this.variant = variant;
  }

  displayDetails() {
    console.log(`Model: ${this.model}, Color: ${this.color}, Variant: ${this.variant}`);
  }
}

Polymorphism: Polymorphism allows objects of different classes to be treated as objects of a common super class. It allows methods with the same name to have different implementations in different classes. In our example, the Bike and RoyalEnfield classes can both have an accelerate method, but they might behave differently.

classic350.start();        // Output: Black Classic 350 bike is started.
classic350.accelerate(60); // Output: Accelerating to 60 km/h.

bullet500.start();         // Output: Desert Storm Bullet 500 bike is started.
bullet500.accelerate(70);  // Output: Accelerating to 70 km/h.

const thunderbirdX = new RoyalEnfield("Thunderbird X", "Blue", "X Series");
thunderbirdX.start();      // Output: Blue Thunderbird X bike is started.
thunderbirdX.displayDetails(); // Output: Model: Thunderbird X, Color: Blue, Variant: X Series

These are some of the fundamental OOP concepts demonstrated through the example of a Royal Enfield bike. OOP provides a structured and organized way to model and interact with real-world entities in a software application.

Decrease the size of EBS volume in your EC2 instance

Ramesh0807 — Mon, 21 Nov 2022 19:42:09 +0000

How to decrease volume size? one of my friend ask me this question.

You might be wondering, can we decrease EBS volume size? The answer is NO. It is impossible to decrease EBS volume size. When you have 100GB EBS and you decide to modify it into 30GB you will get error : The size of a volume can only be increased, not decreased. That’s terrible …

But don’t worry. We could also do the trick to decrease EBS volume size. However, it is not easy task as it is not a straightforward. Here is the trick :

Snapshot the volume
Create a new smaller EBS volume
Attach the new volume
Format the new volume
Mount the new volume
Copy data from old volume to the new volume
Prepare the new volume
Detach and unmount old volume

Getting started

Let’s exercise.

Assume we have :

Instance named my-instance in ap-southeast-1a zone
100GB EBS volume size named old-volume
We wish to decrease into 30GB and name it new-volume We would need to shutdown the instance to prevent inconsistencies.

Create a new smaller EBS volume

Make sure instance is shutdown
Go to Elastic Block Store Volumes
Click Create Volume
Choose the same volume type same with your old volume
Enter your desired size; In our case 30.
Choose availability zone; The volume will be available to instance in the same availability zone, which is ap-southeast-1a .
Add tag with Key : Name and value : new-volume

Attach the new volume

Right click on the new volume.
Click Attach Volume.
Choose instance name my-instance .
Click Attach.

We could start the instance and login to SSH. List all available volume with lsblk. The new volume is in /dev/xvdf.

Format the new volume

Check whether the volume have any data or not using command sudo file -s /dev/xvdf .
If it is displaying /dev/xvdf: data, it means the volume is empty. We could format the volume.
If it is displaying other than above output, it means the volume have data. DO NOT format the volume if you saw this output.
Format the volume using command sudo mkfs -t ext4 /dev/xvdf .

Mount the new volume

Create directory to mount using command sudo mkdir /mnt/new-volume .
Mount new volume into directory using command sudo mount /dev/xvdf /mnt/new-volume.
Check volume with command df -h; The new volume should be mounted now.

Copy data from old volume to the new volume

Use rysnc to copy from old volume to the new volume sudo rsync -axv / /mnt/new-volume/.
Relax and wait until it’s finished. Get a coffee!

Prepare new volume

Install grub on new-volume using command sudo grub-install --root-directory=/mnt/new-volume/ --force /dev/xvdf.
Unmount new-volume sudo umount /mnt/new-volume.
Check UUID using command blkid .
Copy UUID from /dev/xvda1 (paste anywhere to backup this UUID); This is your old UUID.
Use tune2fs to replace UUID sudo tune2fs -U COPIED_UUID /dev/xvdf; COPIED_UUID is the string value from point 4.
Check the system label from old-volume using command sudo e2label /dev/xvda1 ; It will display string like cloudimg-rootfs .
Replace new-volume label with old-volume label using command sudo e2label /dev/xvdf cloudimg-rootfs .
We can logout SSH now.

Detach old volume

 1.  Stop instance `my-instance`
 2.  Detach `old-volume`
 3.  Detach `new-volume`
 4.  Attach new-volume to `/dev/sda1`
 5.  Start instance my-instance

After we finish all steps above, we could check our instance by login into SSH.

We could delete old-volume and snapshot-old-volume if our system works correctly. I prefer to keep snapshot for a week / month before deleting it.

Conclusion

We cannot straightforward decreasing the size of EBS volume. All we can do is to create a new smaller volume.

Hope it’s help!

Springboot version upgrade - my sql error

Ramesh0807 — Mon, 05 Oct 2020 14:36:17 +0000

https://stackoverflow.com/questions/64206933/springboot-version-upgrade-my-sql-error

why need Scheduler?

Ramesh0807 — Fri, 11 Sep 2020 04:49:05 +0000

Importance of switching on/ off the instance using a scheduler: In our early days, we were running our instances 24/7. One fine day we realized that we needed the instances to be up and running only for 10-12 hours per day i.e during our normal working hours. Thereby we were paying unnecessarily for the unused 12-14 hours.
Our first approach was to turn instances on/off manually, but we later realized that this was prone to human errors. Additionally, as we were expanding, the manual effort required to turn them on/off was quite high and unnecessary too.
With all this in mind we moved on to schedulers and this step has given us a huge cost saving of around 70 %(approximately) and also saves us approximately 10 man-hours per week.

Scheduler:
The Scheduler is a solution that enables customers to easily configure custom start and stop schedules for their Amazon EC2. The solution is easy to deploy and can help reduce operational costs for both development and production environments.

Normal instance scheduler
Scheduler implementation in IaaS(Infrastructure as a service):

• When we create an instance on EC2, a unique instance ID gets created and this doesn’t change throughout the life of the instance.
• EC2 instance id is passed to the lambda function to start/stop EC2 instance as per schedule.

Scheduler implementation in PaaS(Platform-as-a-service):
• AWS Elastic Beanstalk Environment has a unique id for each application (which is different from the instance id).
• Initially we configured our scheduler in the same way as Iaas i.e scheduler pointing to the instance ID. However, we faced our 1st challenge when we deployed a new version of our application.
New way of implementation for scheduler (PaaS):

• Due to the deployment a new instance ID had got generated but the scheduler was pointing to the old instance ID. Hence the scheduler didn’t work.
• We tackled this issue by using the environment ID instead of Instance ID. This way the scheduler was always pointing to the intended environment id.

Components of the solution:
1. Cloud watch - triggers the script to start and stop the services as per schedule
2. Lambda function - executes the script file
3. Cloudwatch - stores the log files

The benefit of new solution:
1. Customers who use this solution to run instances only during regular business hours can save up to 70%(approximately) compared to running those instances 24 hours a day.
2. Easy to configure and monitor,
3. using the same trigger script both Environment and EC2 instance can be started/stopped
4. No need to configure DynamoDb
5. No manual efforts required and hence a lot of time saved from a Programmer’s perspective

Challenge from usability:
• Server/Application should be up and running during the standard office hours on all working days. i.e Monday to Friday 9 AM to 10 PM IST.
• Hence 2 lambda functions have been created - one to start the server and the other to stop the server. Appropriate log files have been created for monitoring servers on and off times.
• So if someone wants to use the application during the scheduled downtime, the application needs to be brought up manually by logging in to AWS. To make it easier we are trying to create a mobile service to perform the same on Adhoc basis.

Conclusion:
• Input parameters to the cloud watch/lambda utilities should be determined based on the implementation model i.e Iaas or Paas. Only this will ensure the successful functioning of the scheduler.