Golang: Combining Signals by OR, AND

Hậu Xe — Thu, 16 Aug 2018 04:26:07 +0000

In Golang if we want to avoid goroutine leaks, usually we use a special done channel to signal to a specific goroutine that it needs to be closed. And if we work with many modules which have it’s own done channels then we may want to combine those signals into one signal in form of OR or AND logic

The OR combining signals

If any of the signals is received then emit the combined signal

The implementation below use a number of 2 is maximum channels to be combined, you can change to any number you want:

// OR function combines all signal from channels into a single channel with Or condition
func OR(channels ...<-chan interface{}) <-chan interface{} {
    switch len(channels) {
    case 0:
        return nil
    case 1:
        return channels[0]
    }
    orDone := make(chan interface{})
    go func() {
        defer close(orDone)
        switch len(channels) {
        case 2:
            select {
            case <-channels[0]:
            case <-channels[1]:
            }
        default:
            select {
            case <-channels[0]:
            case <-channels[1]:
            case <-channels[2]:
            case <-OR(append(channels[3:], orDone)...):
            }
        }
    }()
    return orDone
}

The first case of switch statement is check if length of channels is 0, we will block forever by returning a nil channel, this is correct behavior when there no signal at all

The second case of switch statement is if only one channel is passed into this function we will simply return it!

Then we create a orChan for combining all signals from channel, then fork a new goroutine for combine at most 2 channel into orChan

Notice that when we recursively call OR function, we pass orChan again to this function because of logic OR, we need to respect the orChan from previous combination

The AND combining signals

If all of the signals is received then emit the combined signal

The implementation use a very excited knowledge in Golang: in the select statement if right-hand side of a written channel is a receiving channel , the select statement will wait for all receiving channels to be complete before sending to the left-hand side channel

// AND function combines all signal from channels into a single channel with And condition
func AND(channels ...<-chan interface{}) <-chan interface{} {
    switch len(channels) {
    case 0:
        return nil
    case 1:
        return channels[0]
    }
    andDone := make(chan interface{})
    collector := make(chan interface{}, len(channels))
    go func() {
        defer close(andDone)
        switch len(channels) {
        case 2:
            select {
            case collector <- <-channels[0]:
            case collector <- <-channels[1]:
            }
        default:
            select {
            case collector <- <-channels[0]:
            case collector <- <-channels[1]:
            case collector <- <-channels[2]:
            case collector <- <-AND(channels[3:]...):
            }
        }
    }()
    return andDone
}

It’s very similar to the OR implementation version with 3 important different points:

We create a buffered collector channel for collecting signals from combining channels
We pass collector channel as left-hand side in select statement
We recursively call AND function without pass in andChan into it’s parameter list, because we’re waiting for all signals, there no need to respect to this signal again

I implemented those function into this Repo, feel free to use it by yourself! Thanks

Golang: HTTP Serve static files correctly

Hậu Xe — Tue, 14 Aug 2018 09:25:55 +0000

The EasyWay

Handle static files in Golang is very straightforward just one line of code to do this:

http.Handle("/", http.StripPrefix(strings.TrimRight(path, "/"), http.FileServer(http.Dir(directory))))

where path is http path and directory is the static directory you want to serve over http

But, there is a problem, by accessing to root url you can expose your directory structure to public as well =_=:

listing directory

The code is:
https://gist.github.com/hauxe/09cd680deb9c8c4e36d61568db57647b

We need to do something to prevent this danger

First Don’t use default HTTP File server, we’ll create our custome http file server and reject which request accessing to directory path:
https://gist.github.com/hauxe/f88a87f4037bca23f04f6d100f6e08d4#file-http_static_custom_http_server-go

The custom rule that I chose is: if accessing to a directory, and if that directory contains index.html, return it, otherwise return error

Second Register HTTP File server with this custom struct:

fileServer := http.FileServer(FileSystem{http.Dir(directory)})

http.Handle("/", http.StripPrefix(strings.TrimRight(path, "/"), fileServer))

If you access it again:

Successfully prevents

Put a index.html file into statics folder and run example again with new code:

After put index.html

Full working code:
https://gist.github.com/hauxe/f2ea1901216177ccf9550a1b8bd59178#file-http_static_correct-go

I have made a Repo for this purpose which return the http handler for it

Forem: Hậu Xe

Golang: Combining Signals by OR, AND

The OR combining signals

The AND combining signals

Golang: HTTP Serve static files correctly

The EasyWay