File weblug-0.1.obscpio of Package weblug

Overview Repositories Revisions Requests Users Attributes Meta

File weblug-0.1.obscpio of Package weblug (Revision c68a46f0ccc9b35197d2e0c52af5cc66)

Currently displaying revision c68a46f0ccc9b35197d2e0c52af5cc66 , Show latest

07070100000000000081A400000000000000000000000163ADAE74000001F1000000000000000000000000000000000000001600000000weblug-0.1/.gitignore# ---> Go
# If you prefer the allow list template instead of the deny list, see community template:
# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
#
# Binaries for programs and plugins
*.exe
*.exe~
*.dll
*.so
*.dylib
/weblug

# Test binary, built with `go test -c`
*.test

# Output of the go coverage tool, specifically when used with LiteIDE
*.out

# Dependency directories (remove the comment below to include it)
# vendor/

# Go workspace file
go.work

07070100000001000081A400000000000000000000000163ADAE7400000436000000000000000000000000000000000000001300000000weblug-0.1/LICENSEMIT License

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
07070100000002000081A400000000000000000000000163ADAE7400000103000000000000000000000000000000000000001400000000weblug-0.1/Makefiledefault: all
all: weblug

weblug: cmd/weblug/weblug.go cmd/weblug/config.go
	go build -o weblug $^

static: cmd/weblug/weblug.go cmd/weblug/config.go
	CGO_ENABLED=0 go build -ldflags="-w -s" -o weblug $^

test: weblug
	sudo bash -c "cd test && ./blackbox.sh"
07070100000003000081A400000000000000000000000163ADAE7400000361000000000000000000000000000000000000001500000000weblug-0.1/README.md# weblug

Simple webhook receiver program. `weblug` is is a configurable webhook receiver that allows users to define custom programs and script to be executed when a webhook is triggered.

The configuration happens via a simple [yaml file](weblug.yaml).

`weblug` supports multiple webhooks, limitations for concurrent web hooks to be executed, background execution and running webhooks as separate user (`uid`/`gid`). And all of this in a tidy, easy-to-use yaml file!

## Usage

To use `weblug` you need to define webooks in a yaml file. See [weblug.yaml](weblug.yaml) for an example configuration. Then run

./weblug YAML-FILE

This starts the webserver and listens for incoming webhooks.

Note: for custom `uid`/`gid` webhooks, the program needs to run as root.

## Build

make               # Build weblug
    make static        # Make a static binary
07070100000004000041ED00000000000000000000000163ADAE7400000000000000000000000000000000000000000000000F00000000weblug-0.1/cmd07070100000005000041ED00000000000000000000000163ADAE7400000000000000000000000000000000000000000000001600000000weblug-0.1/cmd/weblug07070100000006000081A400000000000000000000000163ADAE7400000D5D000000000000000000000000000000000000002000000000weblug-0.1/cmd/weblug/config.gopackage main

import (
	"fmt"
	"io/ioutil"
	"os/exec"
	"sync/atomic"
	"syscall"

"gopkg.in/yaml.v2"
)

type Config struct {
	Settings ConfigSettings `yaml:"settings"`
	Hooks    []Hook         `yaml:"hooks"`
}

type ConfigSettings struct {
	BindAddress string `yaml:"bind"` // Bind address for the webserver
}

type Hook struct {
	Name           string `yaml:"name"`        // name of the hook
	Route          string `yaml:"route"`       // http route
	Command        string `yaml:"command"`     // Actual command to execute
	Background     bool   `yaml:"background"`  // Run in background
	Concurrency    int    `yaml:"concurrency"` // Number of allowed concurrent runs
	concurrentRuns int32  // Number of current concurrent runs
	UID            int    `yaml:"uid"`    // UID to use when running the command
	GID            int    `yaml:"gid"`    // GID to use when running the command
	Output         bool   `yaml:"output"` // Print program output
}

func (cf *Config) SetDefaults() {
	cf.Settings.BindAddress = ":2088"
}

// Check performs sanity checks on the config
func (cf *Config) Check() error {
	if cf.Settings.BindAddress == "" {
		return fmt.Errorf("no bind address configured")
	}
	for _, hook := range cf.Hooks {
		if hook.Name == "" {
			return fmt.Errorf("hook without name")
		}
		if hook.Route == "" {
			return fmt.Errorf("hook %s with no route", hook.Name)
		}
		if hook.Command == "" {
			return fmt.Errorf("hook %s with no command", hook.Name)
		}
		if hook.Concurrency < 1 {
			hook.Concurrency = 1
		}
	}

return nil
}

func (cf *Config) LoadYAML(filename string) error {
	content, err := ioutil.ReadFile(filename)
	if err != nil {
		return err
	}
	if err := yaml.Unmarshal(content, cf); err != nil {
		return err
	}
	return cf.Check()
}

// Tries to lock a spot. Returns false, if the max. number of concurrent runs has been reached
func (hook *Hook) TryLock() bool {
	res := int(atomic.AddInt32(&hook.concurrentRuns, 1))
	if res > hook.Concurrency {
		atomic.AddInt32(&hook.concurrentRuns, -1)
		return false
	}
	return true
}

func (hook *Hook) Unlock() {
	atomic.AddInt32(&hook.concurrentRuns, -1)
}

// Split a command into program arguments, obey quotation mark escapes
func cmdSplit(command string) []string {
	null := rune(0)
	esc := null // Escape character or \0 if not escaped currently
	ret := make([]string, 0)
	buf := "" // Current command

for _, char := range command {
		if esc != null {
			if char == esc {
				esc = null
			} else {
				buf += string(char)
			}
		} else {
			// Check for quotation marks
			if char == '\'' || char == '"' {
				esc = char
			} else if char == ' ' {
				ret = append(ret, buf)
				buf = ""
			} else {
				buf += string(char)
			}
		}
	}
	// Remaining characters
	if buf != "" {
		ret = append(ret, buf)
		buf = ""
	}
	return ret
}

// Run executes the given command and return it's return code. It also respects the given concurrency number and will block until resources are free
func (hook *Hook) Run() error {
	split := cmdSplit(hook.Command)
	args := make([]string, 0)
	if len(split) > 1 {
		args = split[1:]
	}
	cmd := exec.Command(split[0], args...)
	if hook.UID > 0 || hook.GID > 0 {
		cmd.SysProcAttr = &syscall.SysProcAttr{}
		cmd.SysProcAttr.Credential = &syscall.Credential{Uid: uint32(hook.UID), Gid: uint32(hook.GID)}
	}
	if hook.Output {
		buf, ret := cmd.Output()
		fmt.Println(string(buf))
		return ret
	}
	return cmd.Run()
}
07070100000007000081A400000000000000000000000163ADAE7400001265000000000000000000000000000000000000002000000000weblug-0.1/cmd/weblug/weblug.go/*
 * weblug main program
 */
package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
)

var cf Config

type Handler func(http.ResponseWriter, *http.Request)

func usage() {
	fmt.Println("weblug is a simple webhook receiver")
	fmt.Printf("Usage: %s [OPTIONS] YAML1[,YAML2...]\n\n", os.Args[0])
	fmt.Println("OPTIONS")
	fmt.Println("  -h, --help                Print this help message")
	fmt.Println()
	fmt.Println("The program loads the given yaml files for webhook definitions")
}

// awaits SIGINT or SIGTERM
func awaitTerminationSignal() {
	sigs := make(chan os.Signal, 1)
	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
	go func() {
		sig := <-sigs
		fmt.Println(sig)
		os.Exit(1)
	}()
}

// Perform sanity check on hooks
func sanityCheckHooks(hooks []Hook) error {
	uid := os.Getuid()
	for _, hook := range hooks {
		// If a hook sets a custom uid or gid, ensure we're running as root, otherwise print a warning
		if hook.UID != 0 && uid != 0 {
			fmt.Fprintf(os.Stderr, "Warning: Hook '%s' sets 'uid = %d' but we're not running as root\n", hook.Name, hook.UID)
		}
		if hook.GID != 0 && uid != 0 {
			fmt.Fprintf(os.Stderr, "Warning: Hook '%s' sets 'gid = %d' but we're not running as root\n", hook.Name, hook.GID)
		}
	}
	return nil
}

func main() {
	cf.SetDefaults()
	if len(os.Args) < 2 {
		usage()
	}
	for _, arg := range os.Args[1:] {
		if arg == "" {
			continue
		} else if arg == "-h" || arg == "--help" {
			usage()
			os.Exit(0)
		} else {
			if err := cf.LoadYAML((arg)); err != nil {
				fmt.Fprintf(os.Stderr, "yaml error: %s\n", err)
				os.Exit(1)
			}
		}
	}

if len(cf.Hooks) == 0 {
		fmt.Fprintf(os.Stderr, "error: no webhooks defined\n")
		os.Exit(2)
	}

// Sanity check
	if err := sanityCheckHooks(cf.Hooks); err != nil {
		fmt.Fprintf(os.Stderr, "hook sanity check failed: %s\n", err)
		os.Exit(3)
	}

// Create default handlers
	http.HandleFunc("/health", createHealthHandler())
	http.HandleFunc("/health.json", createHealthHandler())
	http.HandleFunc("/index", createDefaultHandler())
	http.HandleFunc("/index.htm", createDefaultHandler())
	http.HandleFunc("/index.html", createDefaultHandler())
	http.HandleFunc("/robots.txt", createRobotsHandler())

// Register hooks
	for i, hook := range cf.Hooks {
		if hook.Route == "" {
			fmt.Fprintf(os.Stderr, "Invalid hook %s: No route defined\n", hook.Name)
		}
		if hook.Concurrency < 1 {
			hook.Concurrency = 1
		}
		log.Printf("Webhook %d: '%s' [%s] \"%s\"\n", i, hook.Name, hook.Route, hook.Command)
		http.HandleFunc(hook.Route, createHandler(hook))
	}

awaitTerminationSignal()

log.Printf("Launching webserver on %s", cf.Settings.BindAddress)
	log.Fatal(http.ListenAndServe(cf.Settings.BindAddress, nil))
}

// create a http handler function from the given hook
func createHandler(hook Hook) Handler {
	return func(w http.ResponseWriter, r *http.Request) {
		log.Printf("GET %s %s", r.RemoteAddr, hook.Name)

// Check for available slots
		if !hook.TryLock() {
			log.Printf("ERR: \"%s\" max concurrency reached", hook.Name)
			// Return a 503 - Service Unavailable error
			w.Header().Add("Content-Type", "application/json")
			w.Header().Add("Retry-After", "120") // Suggest to retry after 2 minutes
			w.WriteHeader(503)
			fmt.Fprintf(w, "{\"status\":\"fail\",\"reason\":\"max concurrency reached\"}")
			return
		}

if hook.Background { // Execute command in background
			w.Header().Add("Content-Type", "application/json")
			w.WriteHeader(200)
			fmt.Fprintf(w, "{\"status\":\"ok\"}")
			go func() {
				defer hook.Unlock()
				if err := hook.Run(); err != nil {
					log.Printf("Hook \"%s\" failed: %s", hook.Name, err)
				} else {
					log.Printf("Hook \"%s\" completed", hook.Name)
				}
			}()
		} else {
			defer hook.Unlock()
			if err := hook.Run(); err != nil {
				log.Printf("ERR: \"%s\" exec failure: %s", hook.Name, err)
				w.Header().Add("Content-Type", "application/json")
				w.WriteHeader(500)
				fmt.Fprintf(w, "{\"status\":\"fail\",\"reason\":\"program error\"}")
			} else {
				w.Header().Add("Content-Type", "application/json")
				w.WriteHeader(200)
				fmt.Fprintf(w, "{\"status\":\"ok\"}")
			}
		}
	}
}

func createHealthHandler() Handler {
	return func(w http.ResponseWriter, r *http.Request) {
		w.Header().Add("Content-Type", "application/json")
		w.WriteHeader(200)
		fmt.Fprintf(w, "{\"status\":\"ok\"}")
	}
}

func createDefaultHandler() Handler {
	return func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(200)
		fmt.Fprintf(w, "weblug - simple webhook handler")
	}
}

func createRobotsHandler() Handler {
	return func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(200)
		fmt.Fprintf(w, "User-agent: *\nDisallow: /")
	}
}
07070100000008000081A400000000000000000000000163ADAE740000003D000000000000000000000000000000000000001200000000weblug-0.1/go.modmodule weblug/m/v2

go 1.18

require gopkg.in/yaml.v2 v2.4.0
07070100000009000081A400000000000000000000000163ADAE7400000168000000000000000000000000000000000000001200000000weblug-0.1/go.sumgopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
0707010000000A000041ED00000000000000000000000163ADAE7400000000000000000000000000000000000000000000001000000000weblug-0.1/test0707010000000B000081ED00000000000000000000000163ADAE74000005C5000000000000000000000000000000000000001C00000000weblug-0.1/test/blackbox.sh#!/bin/bash
# Blackbox tests for weblug

cleanup() {
    # kill all processes whose parent is this process
    pkill -P $$
}
trap cleanup EXIT

if [[ $EUID != 0 && $UID != 0 ]]; then
	echo -e "(!!) WARNING: Cannot UID and GID webhook tests, because we're not running as root (!!)\n"
	echo -e "Continuing in 3 seconds\n\n\n"
	sleep 3
fi

rm -f testfile
../weblug test.yaml &
sleep 1

## Check touch webhook, which creates "testfile"

echo -e "\n\nChecking 'testfile' webhook ... "

curl http://127.0.0.1:2088/webhooks/touch
if [[ ! -f testfile ]]; then
	echo "Testfile doesn't exist after running webhook touch"
	exit 1
fi
rm -f testfile

## Check background webhook, that sleeps for 5 seconds but returns immediately

echo -e "\n\nChecking 'background' webhook ... "

timeout 2 curl http://127.0.0.1:2088/webhooks/background

## Check concurrency webhook, that allows only 2 requests at the same time (but sleeps for 5 seconds)

echo -e "\n\nChecking 'concurrency' webhook ... "

timeout 10 curl http://127.0.0.1:2088/3 &
timeout 10 curl http://127.0.0.1:2088/3 &
! timeout 2 curl http://127.0.0.1:2088/3

## Check UID and GID webhooks, but only if we're root

echo -e "\n\nChecking 'uid/gid' webhook ... "

# Skip this test, if we're not root
if [[ $EUID == 0 || $UID == 0 ]]; then
	 curl http://127.0.0.1:2088/webhooks/uid
	 curl http://127.0.0.1:2088/webhooks/gid
else
	echo "Cannot UID and GID webhook tests, because we're not running as root"
fi

echo -e "\n\nall good"
0707010000000C000081A400000000000000000000000163ADAE74000002BB000000000000000000000000000000000000001A00000000weblug-0.1/test/test.yaml---
settings:
  bind: "127.0.0.1:2088"    # bind address for webserver

hooks:
  - name: 'touch hook'
    route: "/webhooks/touch"
    command: "touch testfile"
  - name: 'hook background'
    route: "/webhooks/background"
    command: "sleep 5"
    background: True
  - name: 'hook three'
    route: "/3"
    command: "sleep 5"
    concurrency: 2
  - name: 'hook uid'
    route: "/webhooks/uid"
    command: "bash -c 'echo uid=$UID gid=$GID; if [[ $UID != 10 ]]; then exit 1; fi'"
    uid: 10
    output: True
  - name: 'hook gid'
    route: "/webhooks/gid"
    command: "bash -c 'GID=`id -g`; echo uid=$UID gid=$GID; if [[ $GID != 10 ]]; then exit 1; fi'"
    uid: 10
    gid: 10
    output: True
0707010000000D000081A400000000000000000000000163ADAE7400000400000000000000000000000000000000000000001700000000weblug-0.1/weblug.yaml---
## Weblug example config

settings:
  bind: "127.0.0.1:2088"    # bind address for webserver
  #bind: ":2088"            # bind to all addresses

# hook definition. A hook needs to define the HTTP endpoint ("route") and the
# command that will be executed, once this route is executed
hooks:
  - name: 'hook one'
    route: "/webhooks/1"
    command: "sleep 5"
    background: True        # Terminate http request immediately
    concurrency: 2          # At most 2 parallel processes are allowed
  - name: 'hook two'
    route: "/webhooks/2"
    command: "bash -c 'sleep 5'"
    concurrency: 5          # At most 5 parallel processes are allowed
  - name: 'hook 3'
    route: "/webhooks/data/3"
    command: "bash -c 'echo $UID $GID'"
    uid: 100                # Run command as system user id (uid) 100
    gid: 200                # Run command with system group id (gid) 200
    concurrency: 1          # No concurrency. Returns 500 on parallel requests
    output: True            # Print program output to console
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!33 blocks

Places

File weblug-0.1.obscpio of Package weblug (Revision c68a46f0ccc9b35197d2e0c52af5cc66)

Places