DEV Community: Shubham Sethi

Creating a private cloud with just a USB thumbdrive

Shubham Sethi — Sun, 03 Mar 2024 08:29:18 +0000

Ever dreamed of having your own personal cloud, where your files and media are available across all your devices, without breaking the bank? Let me share a game-changing solution that rivals costly alternatives.

Step 1: Connecting an old thumbdrive (aka pendrive) to the router

First things first, I plugged my old pendrive into one of the USB ports on my router. The router detects the USB automatically and this sets the stage for transforming my router into a hub of digital storage. You can also connect your hard drive.

Step 2: Tweak your router's settings

I went into my router's settings using my web browser. Then, I turned on a few things:

FTP Server: This let my Android phone connect to the router. Then to access the new ftp server I insatalled an app called "FtpCafe" which acts as a ftp client, this allows you to upload files from my phone to the pendrive directly.

Samba Server: This made the pendrive show up as a drive on my Mac, so I could get to my files from there.

DMS/DLNA: This one was for my smart TV. With it on, my TV could find and play media files from my personal cloud.
Step 3: Upload Files with FtpCafe

With the "FtpCafe" app, I could easily upload files from my phone to the pendrive connected to the router.

Step 4: Accessing media on your phone

I downloaded the VLC media player app on my Android phone. This let's you connect to the smb server or directly to ftp server and you can stream videos and music from personal cloud whenever you are connected to home wifi.

Step 5: Enjoy media on smart TV

With SMB server on you can also find and play media from personal cloud without any fuss. I tried this on my lg smart tv and it was seamless.

Step 6: Manage files from your mac

Lastly, if I needed to organize stuff on my Mac, I just opened Finder and found my router's Samba server listed as a network drive. From there, I could manage my files, upload new ones, and keep my personal cloud organized.

And just like that, I had created my own personal cloud using nothing more than a router and a pendrive.

Colima - How to use docker without Docker Desktop?

Shubham Sethi — Sat, 10 Sep 2022 18:05:48 +0000

So you want to start using Docker and as a mac user you head over to Install Docker Desktop on Mac .

Setup seems super simple until you see this

Docker Desktop is free for small businesses........but it requires a paid subscription for professional use.

Now what do you do ?
How to leverage the power of Docker on your macOS without paying a hefty subscription fees.

Enter colima

Using colima is simple

brew install colima
brew install docker

That's it.
Now you can go on to use docker without any issues.

But let's dive deeper .

What is colima? Why we needed Docker Desktop at all?

What are containers?

A container is a sandboxed process on our machine that is isolated from all other processes on the host machine. That isolation leverages kernel namespaces and cgroups, features that have been in Linux for a long time. Docker packages these capabilities so that they are easy to use.

So Docker can only be run on Linux OS ?

Yes, Docker as technology can only be run on Linux OS.

How do i use docker on my Mac then ?

You use Docker Desktop.

It does 2 important things

creates Linux VM on your host OS (Windows / Mac)
forwards docker-cli commands from the host OS to created Linux VM

Thus we are able to run and use docker-cli on Windows/Mac even though these OS's do not support docker images/containers.

But since Docker Desktop is no longer free, we need alternatives.

Lima

Lima is tool that launches Linux virtual machines with automatic file sharing, port forwarding, and containerd.
Linux on Mac

Lima uses QEMU which is type-2 hypervisor, which virtualises the host operating system.

Hence we can now run linux virtual machine on top of our mac.

Also it gives use

Filesystem sharing between mac host system and virtual machine
Automatic port forwarding

Lima setup a virtual machine with containerd as container runtime on Mac
We can use nerdctl which docker cli replacement to run our containers.

Colima

Colima : Containers on Linux on Mac.

Colima builds on top of Lima, it configures the Docker CLI and set docker context such that you can use the docker client on macOS after colima start with no additional setup.

Was this article useful to you? I’d love to hear your feedback, so don’t hold back. If you are interested in Kafka, Docker, microservices, or event streaming, or just have any questions, follow me on Twitter.

Sources

Strategy Pattern in Go

Shubham Sethi — Tue, 06 Sep 2022 06:39:05 +0000

Imagine you have to build a program that simulates birds.

There can be different type of birds with different flying behaviours.

A parrot that flies low , an eagle that flies high and ostrich which doesn’t fly at all

We will start with Bird interface.

// Interface
type Bird interface {
    Fly()
    Display()
}

So anything that implements Fly() and Display() is a Bird.

A parrot

type Parrot struct {
    color string
}

func (p *Parrot) Fly() {
    fmt.Println("I can fly")
}

func (p *Parrot) Display() {
    fmt.Printf("I am a Parrot . I have color =%s", p.color)
}

or an Eagle

type Eagle struct {
    color string
}

func (p *Eagle) Fly() {
    fmt.Println("I can fly high")
}

func (p *Eagle) Display() {
    fmt.Printf("I am a Eagle . I have color =%s", p.color)
}

As you can see the Fly() is common mechanism for lot of bids, so we can move this into a common construct.

In Java, we would create an abstract class, which has some common method implemented and later extend the abstract class to implement varying behaviour.

In Go we can do so be creating a type that partially implements Fly() method

//abstracting out just flying behaviour

type FlyStrategy struct {
    doFly FlyBehaviour
}

func (f *FlyStrategy) Fly() {
    f.doFly()
}

We extract out how a bird flies as FlyBehaviour

type FlyBehaviour func()

func FlywithWings() {
   fmt.Println("I am  flying with my wings")
}

func FlyNoWay() {
   fmt.Println("I can't fly")
}

func FlyHigh(){
   fmt.Println("I am  flying high")
}

Now to extend this behaviour in Java we would use extend but Go doesn't support inheritance in the classical sense; instead, in encourages composition as a way to extend the functionality of types. Go supports embedding of structs and interfaces to express a more seamless composition of types.

So to extend FlyStrategy we will simply embed it inside Parrot type

// Implementation of Parrot with FlyStrategy embed
type Parrot struct {
    color string
    FlyStrategy
}

func (p *Parrot) Display() {
    fmt.Printf("I am a Parrot . I have color = %s", p.color)
}

func main() {

    var greenParrot Bird

    greenParrot = &Parrot{
        color:       "green",
        FlyStrategy: FlyStrategy{doFly: FlywithWings},
    }

    greenParrot.Fly()
    greenParrot.Display()

}

Advantage of this pattern is that we can dynamically update flying strategy .

// Interface
type Bird interface {
    Fly()
    Display()
//new
    UpdateFlyStrategy(flyb FlyBehaviour)
}

....
....

type FlyStrategy struct {
    doFly FlyBehaviour
}

func (f *FlyStrategy) Fly() {
    f.doFly()
}

//new
func (f *FlyStrategy) UpdateFlyStrategy(flyb FlyBehaviour) {
    f.doFly = flyb
}

....
....

greenParrot.UpdateFlyStrategy(FlyHigh)
greenParrot.Fly()