Getting Started with Sockets Concurrently in GoLang

Alice Williams — Wed, 15 Jul 2020 06:35:22 +0000

Getting Started with Sockets Concurrently in GoLang

What are sockets?

Sockets, or 'Web Sockets', are a TCP-based internet protocol for real-time and persistent connections between a server and one or more client(s). This protocol is faster than standard HTTP connections, allows for a two-way back-and-forth transfer of data between server and clients. Initialized with a HTTP upgrade request as a handshake operation, after which all parties, server and clients, may send data at any time, from either direction, at any time. Generally used for applications such as social feeds, chat clients, multiplayer games, multimedia streaming, and collaborative development sessions.

Why GoLang?

Concurrency, the biggest advantage to our use-case, socket programming, given it's asynchronous design. Along with the fact that GoLang is an extremely modern high-level language making development of established applications quick and efficient. Plus I just love the simplistic elegance of the language! :) Don't know GoLang? Well, this is a great low-level project to see some basic concepts at play, especially goroutines, GoLang's concurrency feature.

Project Start

This tutorial is based off of my open-source repository.

Create a new project folder and initialize a new git repository to track changes, even if only stored locally by opening a shell or command-line window within your new project folder and running, git init. Make two sub-folders in your project folder, for the server and client. Initialize a GoLang module in each folder by running, go mod init, within each folder, you may need to supply the path if you're outside of your GOPATH. Create two new files, each called, main.go, as the application entry-points, inside of each sub-folder.

Socket Server

The 'Hello World' step:

package main

import (
    "fmt"
)

const (
    connHost = "localhost"
    connPort = "8080"
    connType = "tcp"
)

func main() {
    fmt.Println("Starting " + connType + " server on " + connHost + ":" + connPort)

}

Listening and the main loop:

package main

import (
    "fmt"
    "os"
    "net"
)

const (
    connHost = "localhost"
    connPort = "8080"
    connType = "tcp"
)

func main() {
    fmt.Println("Starting " + connType + " server on " + connHost + ":" + connPort)
    l, err := net.Listen(connType, connHost+":"+connPort)
    if err != nil {
        fmt.Println("Error listening:", err.Error())
        os.Exit(1)
    }
    defer l.Close()

    for {

    }
}

Accept client connections:

package main

import (
    "fmt"
    "os"
    "net"
)

const (
    connHost = "localhost"
    connPort = "8080"
    connType = "tcp"
)

func main() {
    fmt.Println("Starting " + connType + " server on " + connHost + ":" + connPort)
    l, err := net.Listen(connType, connHost+":"+connPort)
    if err != nil {
        fmt.Println("Error listening:", err.Error())
        os.Exit(1)
    }
    defer l.Close()

    for {
        c, err := l.Accept()
        if err != nil {
            fmt.Println("Error connecting:", err.Error())
            return
        }
        fmt.Println("Client connected.")

        fmt.Println("Client " + c.RemoteAddr().String() + " connected.")
    }
}

Handling clients concurrently:

package main

import (
    "bufio"
    "fmt"
    "log"
    "net"
    "os"
)

const (
    connHost = "localhost"
    connPort = "8080"
    connType = "tcp"
)

func main() {
    fmt.Println("Starting " + connType + " server on " + connHost + ":" + connPort)
    l, err := net.Listen(connType, connHost+":"+connPort)
    if err != nil {
        fmt.Println("Error listening:", err.Error())
        os.Exit(1)
    }
    defer l.Close()

    for {
        c, err := l.Accept()
        if err != nil {
            fmt.Println("Error connecting:", err.Error())
            return
        }
        fmt.Println("Client connected.")

        fmt.Println("Client " + c.RemoteAddr().String() + " connected.")

        go handleConnection(c)
    }
}

func handleConnection(conn net.Conn) {
    buffer, err := bufio.NewReader(conn).ReadBytes('\n')

    if err != nil {
        fmt.Println("Client left.")
        conn.Close()
        return
    }

    log.Println("Client message:", string(buffer[:len(buffer)-1]))

    conn.Write(buffer)

    handleConnection(conn)
}

Testing without a client:

If you're developing on Linux you can test your new socket server application without writing the client application first. Start your socket server with, go run main.go, from the server sub-folder within your shell. Now run, nc localhost 8080, replacing the host and port number if needed. There are applications to run the nc (netcat) command on Windows, however, I don't know the best of options here.

Socket Client

The 'Hello World' step:

package main

import (
    "fmt"
)

const (
    connHost = "localhost"
    connPort = "8080"
    connType = "tcp"
)

func main() {
    fmt.Println("Connecting to " + connType + " server " + connHost + ":" + connPort)
}

Connecting to the server:

package main

import (
    "fmt"
)

const (
    connHost = "localhost"
    connPort = "8080"
    connType = "tcp"
)

func main() {
    fmt.Println("Connecting to " + connType + " server " + connHost + ":" + connPort)
}
    conn, err := net.Dial(connType, connHost+":"+connPort)
    if err != nil {
        fmt.Println("Error connecting:", err.Error())
        os.Exit(1)
    }

Handling input and relaying response:

package main

import (
    "fmt"
)

const (
    connHost = "localhost"
    connPort = "8080"
    connType = "tcp"
)

func main() {
    fmt.Println("Connecting to " + connType + " server " + connHost + ":" + connPort)Getting Started with Sockets in GoLang
}
    conn, err := net.Dial(connType, connHost+":"+connPort)
    if err != nil {
        fmt.Println("Error connecting:", err.Error())
        os.Exit(1)
    }
    reader := bufio.NewReader(os.Stdin)

    for {
        fmt.Print("Text to send: ")

        input, _ := reader.ReadString('\n')

        message, _  := bufio.NewReader(conn).ReadString('\n')

        log.Print("Server relay:", message)
    }

Testing the client:

Run your socket server with, go run main.go, from the server project sub-folder on your shell or command-line. Now open another shell or command-line session within the client folder and run, go run main.go here as well to start the client application. Any text entered into the client will be sent to the server, displayed with a timestamp, and relayed back, being displayed again.

This tests the basic functionality of the socket server-client interface and can be extended upon by expanding the server.go handleConnection function. Each client is handled concurrently by the server and as many clients may connect as your system can handle running, you may also connect through other local systems or over the internet if you expose the port to traffic.

Wrapping up

Well now you have stand-alone socket server and client interfaces, in pure standard-library GoLang! So what's next you ask? The sky's the limit, write an IRC-style chat client or a streaming application, just take it one step at a time, and that's one reason we started with a new git repository to manage all those changes you'll start adding.

My open-source Github repository the code for this tutorial is stored in has further line-by-line documentation.

All The Best and Happy Coding!
By, Alice Williams

Raspberry Pi 4 Model B 8GB - Dev Workstation - Performance & Review

Alice Williams — Wed, 15 Jul 2020 03:13:17 +0000

Raspberry Pi 4 Model B 8GB - Dev Workstation - Performance & Review

The Computer:

Single-board computers, what I'd once personally brushed off and completely ignored as little more than a child's learning toy, has now completely replaced my Windows 10 laptop with WSL2 for everything from software development to general usage: from web browsing to checking my email, from debugging my latest project shameless plug to resizing images. This little computer has really impressed me, especially since overclocking the quad-core CPU from a meager 1.5GHz to a still stable 2.0GHz!

With the case, fan, and heat-sinks the cooling has been no issue whatsoever and the computer runs with the same steady purr for a week straight with no noticeable drop off or change in performance. Be it the lightweight Linux system, nature of single-board systems, or state of modern computing but I find that rather impressive considering that computers in the past would get memory leaks or crash after just hours of up-time.

Performance:

Unfortunately the 64-bit version of the OS it ships with, Rasberry OS or formerly Raspbian, a Debian distribution, is still in beta development. However, with the 32-bit version of Rasberry OS Lite, along with a window manager and desktop environment, I've managed to run upon the most stable and light-weight system I've ever worked with to date and it rarely idles above 1GB of ram usage, even after I left it idling for a week to test for memory leaks! It can handle Chrome and even has support for VS Code via a community project, has support for image editing through an open-source project, 3D modeling even with Blender! Plus office support through nothing else but Libre Office.

There are some occasional slow-downs or catches, generally when the window browser grows cluttered and multiple applications are running like VS Code and Libre Office, however, in those scenarios there is almost always something I can close down to bring the system back to a reasonable speed. Surprisingly it's amazingly plug-and-play as well and getting started with the system took less than thirty minutes flat, and has given me no trouble whatsoever with any devices whatsoever.

Conclusion:

For a Linux workstation, primarily for development and related needs, this smol device has been incredibly more than I expected, I'd highly recommend it and have already ordered two more for use as other devices in my home. The guide I followed to get the Raspberry Lite OS along with a window manager and desktop environment can be found here, it's definitely worth taking a glance at as they do a very detailed benchmark of various environment setups and their performances. Various options are available from headless environments to full or lite versions of OS's, if anyone out there has OS recommendations or is running something particularly suited to the device please do reach out!

Never in my life did I think I'd consider replacing what I once used an entire full-sized desktop computer for with a computer that is the size of my wallet. It really shows how far computers have come over time and I'm really looking forward to trying out other single-board computers out there!

All The Best and Happy Tinkering!
By, Alice Williams

Forem: Alice Williams

Getting Started with Sockets Concurrently in GoLang

Getting Started with Sockets Concurrently in GoLang

What are sockets?

Why GoLang?

Project Start

Socket Server

Socket Client

Wrapping up

Raspberry Pi 4 Model B 8GB - Dev Workstation - Performance & Review

Raspberry Pi 4 Model B 8GB - Dev Workstation - Performance & Review

The Computer:

Performance:

Conclusion: