:tophat: Small self-contained pure-Go web server with Lua, Markdown, HTTP/2, QUIC, Redis and PostgreSQL support

Overview

Build GoDoc License Go Report Card FOSSA Status

Web server with built-in support for QUIC, HTTP/2, Lua, Markdown, Pongo2, HyperApp, Amber, Sass(SCSS), GCSS, JSX, BoltDB (built-in, stores the database in a file, like SQLite), Redis, PostgreSQL, MariaDB/MySQL, rate limiting, graceful shutdown, plugins, users and permissions.

All in one small self-contained executable.

Distro Packages

Packaging status

Quick installation (development version)

Requires Go 1.14 or later.

Clone algernon outside of GOPATH:

git clone https://github.com/xyproto/algernon
cd algernon
go build -mod=vendor

This may also work:

go get -u github.com/xyproto/algernon

Releases and pre-built images

See the release page for releases for a variety of platforms and architectures.

The docker image is a total of 9MB.

Technologies

Written in Go. Uses Bolt (built-in), MySQL, PostgreSQL or Redis (recommended) for the database backend, permissions2 for handling users and permissions, gopher-lua for interpreting and running Lua, http2 for serving HTTP/2, QUIC for serving over QUIC, blackfriday for Markdown rendering, amber for Amber templates, Pongo2 for Pongo2 templates, Sass(SCSS) and GCSS for CSS preprocessing. logrus is used for logging, goja-babel for converting from JSX to JavaScript, tollbooth for rate limiting, pie for plugins and graceful for graceful shutdowns.

Design decisions

  • HTTP/2 over SSL/TLS (https) is used by default, if a certificate and key is given.
    • If not, regular HTTP is used.
  • QUIC ("HTTP over UDP", supported by Chromium) can be enabled with a flag.
  • /data and /repos have user permissions, /admin has admin permissions and / is public, by default. This is configurable.
  • The following filenames are special, in prioritized order:
    • index.lua is Lua code that is interpreted as a handler function for the current directory.
    • index.html is HTML that is outputted with the correct Content-Type.
    • index.md is Markdown code that is rendered as HTML.
    • index.txt is plain text that is outputted with the correct Content-Type.
    • index.pongo2, index.po2 or index.tmpl is Pongo2 code that is rendered as HTML.
    • index.amber is Amber code that is rendered as HTML.
    • index.hyper.js or index.hyper.jsx is JSX+HyperApp code that is rendered as HTML
    • data.lua is Lua code, where the functions and variables are made available for Pongo2, Amber and Markdown pages in the same directory.
    • If a single Lua script is given as a commandline argument, it will be used as a standalone server. It can be used for setting up handlers or serving files and directories for specific URL prefixes.
    • style.gcss is GCSS code that is used as the style for all Pongo2, Amber and Markdown pages in the same directory.
  • The following filename extensions are handled by Algernon:
    • Markdown: .md (rendered as HTML)
    • Pongo2: .po2, .pongo2 or .tpl (rendered as any text, typically HTML)
    • Amber: .amber (rendered as HTML)
    • Sass: .scss (rendered as CSS)
    • GCSS: .gcss (rendered as CSS)
    • JSX: .jsx (rendered as JavaScript/ECMAScript)
    • Lua: .lua (a script that provides its own output and content type)
    • HyperApp: .hyper.js or .hyper.jsx (rendered as HTML)
  • Other files are given a mimetype based on the extension.
  • Directories without an index file are shown as a directory listing, where the design is hardcoded.
  • UTF-8 is used whenever possible.
  • The server can be configured by commandline flags or with a lua script, but no configuration should be needed for getting started.

Features and limitations

  • Supports HTTP/2, with or without HTTPS (browsers may require HTTPS when using HTTP/2).
  • Also supports regular HTTP.
  • Can use Lua scripts as handlers for HTTP requests.
  • The Algernon executable is compiled to native and is reasonably fast.
  • Works on Linux, OS X and 64-bit Windows.
  • The Lua interpreter is compiled into the executable.
  • Live editing/preview when using the auto-refresh feature.
  • The use of Lua allows for short development cycles, where code is interpreted when the page is refreshed (or when the Lua file is modified, if using auto-refresh).
  • Self-contained Algernon applications can be zipped into an archive (ending with .zip or .alg) and be loaded at start.
  • Built-in support for Markdown, Pongo2, Amber, Sass(SCSS), GCSS and JSX.
  • Redis is used for the database backend, by default.
  • Algernon will fall back to the built-in Bolt database if no Redis server is available.
  • The HTML title for a rendered Markdown page can be provided by the first line specifying the title, like this: title: Title goes here. This is a subset of MultiMarkdown.
  • No file converters needs to run in the background (like for SASS). Files are converted on the fly.
  • If -autorefresh is enabled, the browser will automatically refresh pages when the source files are changed. Works for Markdown, Lua error pages and Amber (including Sass, GCSS and data.lua). This only works on Linux and OS X, for now. If listening for changes on too many files, the OS limit for the number of open files may be reached.
  • Includes an interactive REPL.
  • If only given a Markdown filename as the first argument, it will be served on port 3000, without using any database, as regular HTTP. Handy for viewing README.md files locally.
  • Full multithreading. All available CPUs will be used.
  • Supports rate limiting, by using tollbooth.
  • The help command is available at the Lua REPL, for a quick overview of the available Lua functions.
  • Can load plugins written in any language. Plugins must offer the Lua.Code and Lua.Help functions and talk JSON-RPC over stderr+stdin. See pie for more information. Sample plugins for Go and Python are in the plugins directory.
  • Thread-safe file caching is built-in, with several available cache modes (for only caching images, for example).
  • Can read from and save to JSON documents. Supports simple JSON path expressions (like a simple version of XPath, but for JSON).
  • If cache compression is enabled, files that are stored in the cache can be sent directly from the cache to the client, without decompressing.
  • Files that are sent to the client are compressed with gzip, unless they are under 4096 bytes.
  • When using PostgreSQL, the HSTORE key/value type is used (available in PostgreSQL version 9.1 or later).
  • No external dependencies, only pure Go.
  • Requires Go >= 1.14 or GCC >= 10 (gccgo).

Q&A

Q:

What is the benefit of using this? In what scenario would this excel? Thanks. -- [email protected].

A:

Good question. I'm not sure if it excels in any scenario. There are specialized web servers that excel at caching or at raw performance. There are dedicated backends for popular front-end toolkits like Vue or React. There are dedicated editors that excel at editing and previewing Markdown, or HTML.

I guess the main benefit is that Algernon covers a lot of ground, with a minimum of configuration, while being powerful enough to have a plugin system and support for programming in Lua. There is an auto-refresh feature that uses Server Sent Events, when editing Markdown or web pages. There is also support for the latest in Web technologies, like HTTP/2, QUIC and TLS 1.3. The caching system is decent. And the use of Go ensures that also smaller platforms like NetBSD and systems like Raspberry Pi are covered. There are no external dependencies, so Algernon can run on any system that Go can support.

The main benefit is that is is versatile, fresh, and covers many platforms and use cases.

For a more specific description of a potential benefit, a more specific use case would be needed.

Utilities

  • Comes with the alg2docker utility, for creating Docker images from Algernon web applications (.alg files).
  • http2check can be used for checking if a web server is offering HTTP/2.

Installation

OS X
  • brew install algernon
  • Install Homebrew, if needed.
Arch Linux
  • Install algernon from AUR, using your favorite AUR helper.
Any system where go is available

This method is using the latest commit from the main branch:

go get -u github.com/xyproto/[email protected]

If needed, first:

  • Set the GOPATH. For example: export GOPATH=~/go
  • Add $GOPATH/bin to the path. For example: export PATH=$PATH:$GOPATH/bin

Overview

Running Algernon:

Screenshot of an earlier version:


The idea is that web pages can be written in Markdown, Pongo2, Amber, HTML or JSX (+React), depending on the need, and styled with CSS, Sass(SCSS) or GCSS, while data can be provided by a Lua script that talks to Redis, BoltDB, PostgreSQL or MariaDB/MySQL.

Amber and GCSS is a good combination for static pages, that allows for more clarity and less repetition than HTML and CSS. It˙s also easy to use Lua for providing data for the Amber templates, which helps separate model, controller and view.

Pongo2, Sass and Lua also combines well. Pongo2 is more flexible than Amber.

The auto-refresh feature is supported when using Markdown, Pongo2 or Amber, and is useful to get an instant preview when developing.

The JSX to JavaScript (ECMAscript) transpiler is built-in.

Redis is fast, scalable and offers good data persistence. This should be the preferred backend.

Bolt is a pure key/value store, written in Go. It makes it easy to run Algernon without having to set up a database host first. MariaDB/MySQL support is included because of its widespread availability.

PostgreSQL is a solid and fast database that is also supported.

Screenshots

Markdown can easily be styled with Sass or GCSS.


This is how errors in Lua scripts are handled, when Debug mode is enabled.


One of the poems of Algernon Charles Swinburne, with three rotating tori in the background. Uses CSS3 for the Gaussian blur and three.js for the 3D graphics.


Screenshot of the prettify sample. Served from a single Lua script.


JSX transforms are built-in. Using React together with Algernon is easy.

Samples

The sample collection can be downloaded from the samples directory in this repository, or here: samplepack.zip.

Getting started

Run Algernon in "dev" mode

This enables debug mode, uses the internal Bolt database, uses regular HTTP instead of HTTPS+HTTP/2 and enables caching for all files except: Pongo2, Amber, Lua, Sass, GCSS, Markdown and JSX.

  • algernon -e

Then try creating an index.lua file with print("Hello, World!") and visit the served web page in a browser.

Enable HTTP/2 in the browser (for older browsers)
  • Chrome: go to chrome://flags/#enable-spdy4, enable, save and restart the browser.
  • Firefox: go to about:config, set network.http.spdy.enabled.http2draft to true. You might need the nightly version of Firefox.
Configure the required ports for local use
  • You may need to change the firewall settings for port 3000, if you wish to use the default port for exploring the samples.
  • For the auto-refresh feature to work, port 5553 must be available (or another host/port of your choosing, if configured otherwise).
Prepare for running the samples
git clone https://github.com/xyproto/algernon
make -C algernon
Launch the "welcome" page
  • Run ./welcome.sh to start serving the "welcome" sample.
  • Visit http://localhost:3000/
Create your own Algernon application, for regular HTTP
  • mkdir mypage
  • cd mypage
  • Create a file named index.lua, with the following contents: print("Hello, Algernon")
  • Start algernon --httponly --autorefresh.
  • Visit http://localhost:3000/.
  • Edit index.lua and refresh the browser to see the new result.
  • If there were errors, the page will automatically refresh when index.lua is changed.
  • Markdown, Pongo2 and Amber pages will also refresh automatically, as long as -autorefresh is used.
Create your own Algernon application, for HTTP/2 + HTTPS
  • mkdir mypage
  • cd mypage
  • Create a file named index.lua, with the following contents: print("Hello, Algernon")
  • Create a self-signed certificate, just for testing:
  • openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 3000 -nodes
  • Press return at all the prompts, but enter localhost at Common Name.
  • For production, store the keys in a directory with as strict permissions as possible, then specify them with the --cert and --key flags.
  • Start algernon.
  • Visit https://localhost:3000/.
  • If you have not imported the certificates into the browser, nor used certificates that are signed by trusted certificate authorities, perform the necessary clicks to confirm that you wish to visit this page.
  • Edit index.lua and refresh the browser to see the result (or a Lua error message, if the script had a problem).

Basic Lua functions

// Return the version string for the server.
version() -> string

// Sleep the given number of seconds (can be a float).
sleep(number)

// Log the given strings as information. Takes a variable number of strings.
log(...)

// Log the given strings as a warning. Takes a variable number of strings.
warn(...)

// Log the given strings as an error. Takes a variable number of strings.
err(...)

// Return the number of nanoseconds from 1970 ("Unix time")
unixnano() -> number

// Convert Markdown to HTML
markdown(string) -> string

// Return the directory where the REPL or script is running. If a filename (optional) is given, then the path to where the script is running, joined with a path separator and the given filename, is returned.
scriptdir([string]) -> string

// Return the directory where the server is running. If a filename (optional) is given, then the path to where the server is running, joined with a path separator and the given filename, is returned.
serverdir([string]) -> string

Lua functions for handling requests

// Set the Content-Type for a page.
content(string)

// Return the requested HTTP method (GET, POST etc).
method() -> string

// Output text to the browser/client. Takes a variable number of strings.
print(...)

// Return the requested URL path.
urlpath() -> string

// Return the HTTP header in the request, for a given key, or an empty string.
header(string) -> string

// Set an HTTP header given a key and a value.
setheader(string, string)

// Return the HTTP headers, as a table.
headers() -> table

// Return the HTTP body in the request (will only read the body once, since it's streamed).
body() -> string

// Set a HTTP status code (like 200 or 404). Must be used before other functions that writes to the client!
status(number)

// Set a HTTP status code and output a message (optional).
error(number[, string])

// Serve a file that exists in the same directory as the script. Takes a filename.
serve(string)

// Serve a Pongo2 template file, with an optional table with template key/values.
serve2(string[, table)

// Return the rendered contents of a file that exists in the same directory as the script. Takes a filename.
render(string) -> string

// Return a table with keys and values as given in a posted form, or as given in the URL.
formdata() -> table

// Return a table with keys and values as given in the request URL, or in the given URL (`/some/page?x=7` makes the key `x` with the value `7` available).
urldata([string]) -> table

// Redirect to an absolute or relative URL. May take an HTTP status code that will be used when redirecting.
redirect(string[, number])

// Permanent redirect to an absolute or relative URL. Uses status code 302.
permanent_redirect(string)

// Transmit what has been outputted so far, to the client.
flush()

Lua functions for formatted output

// Output rendered Markdown to the browser/client. The given text is converted from Markdown to HTML. Takes a variable number of strings.
mprint(...)

// Output rendered Amber to the browser/client. The given text is converted from Amber to HTML. Takes a variable number of strings.
aprint(...)

// Output rendered GCSS to the browser/client. The given text is converted from GCSS to CSS. Takes a variable number of strings.
gprint(...)

// Output rendered HyperApp JSX to the browser/client. The given text is converted from JSX to JavaScript. Takes a variable number of strings.
hprint(...)

// Output rendered React JSX to the browser/client. The given text is converted from JSX to JavaScript. Takes a variable number of strings.
jprint(...)

// Output rendered HTML to the browser/client. The given text is converted from Pongo2 to HTML. The first argument is the Pongo2 template and the second argument is a table. The keys in the table can be referred to in the template.
poprint(string[, table])

// Output a simple HTML page with a message, title and theme.
// The title and theme are optional.
msgpage(string[, string][, string])

Lua functions related to JSON

Tips:

  • Use JFile(filename) to use or store a JSON document in the same directory as the Lua script.
  • A JSON path is on the form x.mapkey.listname[2].mapkey, where [, ] and . have special meaning. It can be used for pinpointing a specific place within a JSON document. It's a bit like a simple version of XPath, but for JSON.
  • Use tostring(userdata) to fetch the JSON string from the JFile object.
// Use, or create, a JSON document/file.
JFile(filename) -> userdata

// Takes a JSON path. Returns a string value, or an empty string.
jfile:getstring(string) -> string

// Takes a JSON path. Returns a JNode or nil.
jfile:getnode(string) -> userdata

// Takes a JSON path. Returns a value or nil.
jfile:get(string) -> value

// Takes a JSON path (optional) and JSON data to be added to the list.
// The JSON path must point to a list, if given, unless the JSON file is empty.
// "x" is the default JSON path. Returns true on success.
jfile:add([string, ]string) -> bool

// Take a JSON path and a string value. Changes the entry. Returns true on success.
jfile:set(string, string) -> bool

// Remove a key in a map. Takes a JSON path, returns true on success.
jfile:delkey(string) -> bool

// Convert a Lua table, where keys are strings and values are strings or numbers, to JSON.
// Takes an optional number of spaces to indent the JSON data.
// (Note that keys in JSON maps are always strings, ref. the JSON standard).
json(table[, number]) -> string

// Create a JSON document node.
JNode() -> userdata

// Add JSON data to a node. The first argument is an optional JSON path.
// The second argument is a JSON data string. Returns true on success.
// "x" is the default JSON path.
jnode:add([string, ]string) ->

// Given a JSON path, retrieves a JSON node.
jnode:get(string) -> userdata

// Given a JSON path, retrieves a JSON string.
jnode:getstring(string) -> string

// Given a JSON path and a JSON string, set the value.
jnode:set(string, string)

// Given a JSON path, remove a key from a map.
jnode:delkey(string) -> bool

// Return the JSON data, nicely formatted.
jnode:pretty() -> string

// Return the JSON data, as a compact string.
jnode:compact() -> string

// Sends JSON data to the given URL. Returns the HTTP status code as a string.
// The content type is set to "application/json; charset=utf-8".
// The second argument is an optional authentication token that is used for the
// Authorization header field.
jnode:POST(string[, string]) -> string

// Alias for jnode:POST
jnode:send(string[, string]) -> string

// Same as jnode:POST, but sends HTTP PUT instead.
jnode:PUT(string[, string]) -> string

// Fetches JSON over HTTP given an URL that starts with http or https.
// The JSON data is placed in the JNode. Returns the HTTP status code as a string.
jnode:GET(string) -> string

// Alias for jnode:GET
jnode:receive(string) -> string

// Convert from a simple Lua table to a JSON string
JSON(table) -> string

Lua functions for making HTTP requests

Quick example: GET("http://ix.io/1FTw")

// Create a new HTTP Client object
HTTPClient() -> userdata

// Select Accept-Language (ie. "en-us")
hc:SetLanguage(string)

// Set the request timeout (in milliseconds)
hc:SetTimeout(number)

// Set a cookie (name and value)
hc:SetCookie(string, string)

// Set the user agent (ie. "curl")
hc:SetUserAgent(string)

// Perform a HTTP GET request. First comes the URL, then an optional table with
// URL parameters, then an optional table with HTTP headers.
hc:Get(string, [table], [table]) -> string

// Perform a HTTP POST request. It's the same arguments as for `Get`, except
// the fourth optional argument is the POST body.
hc:Post(string, [table], [table], [string]) -> string

// Like `Get`, except the first argument is the HTTP method (like "PUT")
hc:Do(string, string, [table], [table]) -> string

// Shorthand for HTTPClient():Get()
GET(string, [table], [table]) -> string

// Shorthand for HTTPClient():Post()
POST(string, [table], [table], [string]) -> string

// Shorthand for HTTPClient():Do()
DO(string, string, [table], [table]) -> string

Lua functions for plugins

// Load a plugin given the path to an executable. Returns true on success. Will return the plugin help text if called on the Lua prompt.
Plugin(string)

// Returns the Lua code as returned by the Lua.Code function in the plugin, given a plugin path. May return an empty string.
PluginCode(string) -> string

// Takes a plugin path, function name and arguments. Returns an empty string if the function call fails, or the results as a JSON string if successful.
CallPlugin(string, string, ...) -> string

Lua functions for code libraries

These functions can be used in combination with the plugin functions for storing Lua code returned by plugins when serverconf.lua is loaded, then retrieve the Lua code later, when handling requests. The code is stored in the database.

// Create or uses a code library object. Optionally takes a data structure name as the first parameter.
CodeLib([string]) -> userdata

// Given a namespace and Lua code, add the given code to the namespace. Returns true on success.
codelib:add(string, string) -> bool

// Given a namespace and Lua code, set the given code as the only code in the namespace. Returns true on success.
codelib:set(string, string) -> bool

// Given a namespace, return Lua code, or an empty string.
codelib:get(string) -> string

// Import (eval) code from the given namespace into the current Lua state. Returns true on success.
codelib:import(string) -> bool

// Completely clear the code library. Returns true on success.
codelib:clear() -> bool

Lua functions for file uploads

// Creates a file upload object. Takes a form ID (from a POST request) as the first parameter.
// Takes an optional maximum upload size (in MiB) as the second parameter.
// Returns nil and an error string on failure, or userdata and an empty string on success.
UploadedFile(string[, number]) -> userdata, string

// Return the uploaded filename, as specified by the client
uploadedfile:filename() -> string

// Return the size of the data that has been received
uploadedfile:size() -> number

// Return the mime type of the uploaded file, as specified by the client
uploadedfile:mimetype() -> string

// Save the uploaded data locally. Takes an optional filename. Returns true on success.
uploadedfile:save([string]) -> bool

// Save the uploaded data as the client-provided filename, in the specified directory.
// Takes a relative or absolute path. Returns true on success.
uploadedfile:savein(string)  -> bool

Lua functions for the file cache

// Return information about the file cache.
CacheInfo() -> string

// Clear the file cache.
ClearCache()

// Load a file into the cache, returns true on success.
preload(string) -> bool

Lua functions for data structures

Set
// Get or create a database-backed Set (takes a name, returns a set object)
Set(string) -> userdata

// Add an element to the set
set:add(string)

// Remove an element from the set
set:del(string)

// Check if a set contains a value
// Returns true only if the value exists and there were no errors.
set:has(string) -> bool

// Get all members of the set
set:getall() -> table

// Remove the set itself. Returns true on success.
set:remove() -> bool

// Clear the set
set:clear() -> bool
List
// Get or create a database-backed List (takes a name, returns a list object)
List(string) -> userdata

// Add an element to the list
list:add(string)

// Get all members of the list
list:getall() -> table

// Get the last element of the list
// The returned value can be empty
list:getlast() -> string

// Get the N last elements of the list
list:getlastn(number) -> table

// Remove the list itself. Returns true on success.
list:remove() -> bool

// Clear the list. Returns true on success.
list:clear() -> bool

// Return all list elements (expected to be JSON strings) as a JSON list
list:json() -> string
HashMap
// Get or create a database-backed HashMap (takes a name, returns a hash map object)
HashMap(string) -> userdata

// For a given element id (for instance a user id), set a key
// (for instance "password") and a value.
// Returns true on success.
hash:set(string, string, string) -> bool

// For a given element id (for instance a user id), and a key
// (for instance "password"), return a value.
// Returns a value only if they key was found and if there were no errors.
hash:get(string, string) -> string

// For a given element id (for instance a user id), and a key
// (for instance "password"), check if the key exists in the hash map.
// Returns true only if it exists and there were no errors.
hash:has(string, string) -> bool

// For a given element id (for instance a user id), check if it exists.
// Returns true only if it exists and there were no errors.
hash:exists(string) -> bool

// Get all keys of the hash map
hash:getall() -> table

// Remove a key for an entry in a hash map
// (for instance the email field for a user)
// Returns true on success
hash:delkey(string, string) -> bool

// Remove an element (for instance a user)
// Returns true on success
hash:del(string) -> bool

// Remove the hash map itself. Returns true on success.
hash:remove() -> bool

// Clear the hash map. Returns true on success.
hash:clear() -> bool
KeyValue
// Get or create a database-backed KeyValue collection (takes a name, returns a key/value object)
KeyValue(string) -> userdata

// Set a key and value. Returns true on success.
kv:set(string, string) -> bool

// Takes a key, returns a value.
// Returns an empty string if the function fails.
kv:get(string) -> string

// Takes a key, returns the value+1.
// Creates a key/value and returns "1" if it did not already exist.
// Returns an empty string if the function fails.
kv:inc(string) -> string

// Remove a key. Returns true on success.
kv:del(string) -> bool

// Remove the KeyValue itself. Returns true on success.
kv:remove() -> bool

// Clear the KeyValue. Returns true on success.
kv:clear() -> bool

Lua functions for external databases

// Query a PostgreSQL database with a SQL query and a connection string
PQ([string], [string]) -> table

The default connection string is host=localhost port=5432 user=postgres dbname=test sslmode=disable and the default SQL query is SELECT version(). Database connections are re-used if they still answer to .Ping(), for the same connection string.

Lua functions for handling users and permissions

// Check if the current user has "user" rights
UserRights() -> bool

// Check if the given username exists (does not look at the list of unconfirmed users)
HasUser(string) -> bool

// Check if the given username exists in the list of unconfirmed users
HasUnconfirmedUser(string) -> bool

// Get the value from the given boolean field
// Takes a username and field name
BooleanField(string, string) -> bool

// Save a value as a boolean field
// Takes a username, field name and boolean value
SetBooleanField(string, string, bool)

// Check if a given username is confirmed
IsConfirmed(string) -> bool

// Check if a given username is logged in
IsLoggedIn(string) -> bool

// Check if the current user has "admin rights"
AdminRights() -> bool

// Check if a given username is an admin
IsAdmin(string) -> bool

// Get the username stored in a cookie, or an empty string
UsernameCookie() -> string

// Store the username in a cookie, returns true on success
SetUsernameCookie(string) -> bool

// Clear the login cookie
ClearCookie()

// Get a table containing all usernames
AllUsernames() -> table

// Get the email for a given username, or an empty string
Email(string) -> string

// Get the password hash for a given username, or an empty string
PasswordHash(string) -> string

// Get all unconfirmed usernames
AllUnconfirmedUsernames() -> table

// Get the existing confirmation code for a given user,
// or an empty string. Takes a username.
ConfirmationCode(string) -> string

// Add a user to the list of unconfirmed users
// Takes a username and a confirmation code
// Remember to also add a user, when registering new users.
AddUnconfirmed(string, string)

// Remove a user from the list of unconfirmed users
// Takes a username
RemoveUnconfirmed(string)

// Mark a user as confirmed
// Takes a username
MarkConfirmed(string)

// Removes a user
// Takes a username
RemoveUser(string)

// Make a user an admin
// Takes a username
SetAdminStatus(string)

// Make an admin user a regular user
// Takes a username
RemoveAdminStatus(string)

// Add a user
// Takes a username, password and email
AddUser(string, string, string)

// Set a user as logged in on the server (not cookie)
// Takes a username
SetLoggedIn(string)

// Set a user as logged out on the server (not cookie)
// Takes a username
SetLoggedOut(string)

// Log in a user, both on the server and with a cookie
// Takes a username
Login(string)

// Log out a user, on the server (which is enough)
// Takes a username
Logout(string)

// Get the current username, from the cookie
Username() -> string

// Get the current cookie timeout
// Takes a username
CookieTimeout(string) -> number

// Set the current cookie timeout
// Takes a timeout number, measured in seconds
SetCookieTimeout(number)

// Get the current server-wide cookie secret. This is used when setting
// and getting browser cookies when users log in.
CookieSecret() -> string

// Set the current server-side cookie secret. This is used when setting
// and getting browser cookies when users log in. Using the same secret
// makes browser cookies usable across server restarts.
SetCookieSecret(string)

// Get the current password hashing algorithm (bcrypt, bcrypt+ or sha256)
PasswordAlgo() -> string

// Set the current password hashing algorithm (bcrypt, bcrypt+ or sha256)
// ‘bcrypt+‘ accepts bcrypt or sha256 for old passwords, but will only use
// bcrypt for new passwords.
SetPasswordAlgo(string)

// Hash the password
// Takes a username and password (username can be used for salting sha256)
HashPassword(string, string) -> string

// Change the password for a user, given a username and a new password
SetPassword(string, string)

// Check if a given username and password is correct
// Takes a username and password
CorrectPassword(string, string) -> bool

// Checks if a confirmation code is already in use
// Takes a confirmation code
AlreadyHasConfirmationCode(string) -> bool

// Find a username based on a given confirmation code,
// or returns an empty string. Takes a confirmation code
FindUserByConfirmationCode(string) -> string

// Mark a user as confirmed
// Takes a username
Confirm(string)

// Mark a user as confirmed, returns true on success
// Takes a confirmation code
ConfirmUserByConfirmationCode(string) -> bool

// Set the minimum confirmation code length
// Takes the minimum number of characters
SetMinimumConfirmationCodeLength(number)

// Generates a unique confirmation code, or an empty string
GenerateUniqueConfirmationCode() -> string

Lua functions that are available for server configuration files

// Set the default address for the server on the form [host][:port].
// May be useful in Algernon application bundles (.alg or .zip files).
SetAddr(string)

// Reset the URL prefixes and make everything *public*.
ClearPermissions()

// Add an URL prefix that will have *admin* rights.
AddAdminPrefix(string)

// Add an URL prefix that will have *user* rights.
AddUserPrefix(string)

// Provide a lua function that will be used as the permission denied handler.
DenyHandler(function)

// Return a string with various server information.
ServerInfo() -> string

// Direct the logging to the given filename. If the filename is an empty
// string, direct logging to stderr. Returns true on success.
LogTo(string) -> bool

// Returns the version string for the server.
version() -> string

// Logs the given strings as INFO. Takes a variable number of strings.
log(...)

// Logs the given strings as WARN. Takes a variable number of strings.
warn(...)

// Logs the given string as ERROR. Takes a variable number of strings.
err(...)

// Provide a lua function that will be run once, when the server is ready to start serving.
OnReady(function)

// Use a Lua file for setting up HTTP handlers instead of using the directory structure.
ServerFile(string) -> bool

// Get the cookie secret from the server configuration.
CookieSecret() -> string

// Set the cookie secret that will be used when setting and getting browser cookies.
SetCookieSecret(string)

Functions that are only available for Lua server files

This function is only available when a Lua script is used instead of a server directory, or from Lua files that are specified with the ServerFile function in the server configuration.

// Given an URL path prefix (like "/") and a Lua function, set up an HTTP handler.
// The given Lua function should take no arguments, but can use all the Lua functions for handling requests, like `content` and `print`.
handle(string, function)

// Given an URL prefix (like "/") and a directory, serve the files and directories.
servedir(string, string)

Commands that are only available in the REPL

  • help displays a syntax highlighted overview of most functions.
  • webhelp displays a syntax highlighted overview of functions related to handling requests.
  • confighelp displays a syntax highlighted overview of functions related to server configuration.

Extra Lua functions

// Pretty print. Outputs the values in, or a description of, the given Lua value(s).
pprint(...)

// Takes a Python filename, executes the script with the `python` binary in the Path.
// Returns the output as a Lua table, where each line is an entry.
py(string) -> table

// Takes one or more system commands (possibly separated by `;`) and runs them.
// Returns the output lines as a table.
run(string) -> table

// Lists the keys and values of a Lua table. Returns a string.
// Lists the contents of the global namespace `_G` if no arguments are given.
dir([table]) -> string

Markdown

Algernon can be used as a quick Markdown viewer with the -m flag.

Try algernon -m README.md to view README.md in the browser, serving the file once on a port >3000.

In addition to the regular Markdown syntax, Algernon supports setting the page title and syntax highlight style with a header comment like this at the top of a Markdown file:

<!--
title: Page title
theme: dark
code_style: lovelace
replace_with_theme: default_theme
-->

Code is highlighted with highlight.js and several styles are available.

The string that follows replace_with_theme will be used for replacing the current theme string (like dark) with the given string. This makes it possible to use one image (like logo_default_theme.png) for one theme and another image (logo_dark.png) for the dark theme.

The theme can be light, dark, redbox, bw, github, wing, material, neon, default, werc or a path to a CSS file. Or style.gcss can exist in the same directory.

An overview of available syntax highlighting styles can be found at the Chroma Style Gallery.

HTTPS certificates with Let's Encrypt and Algernon

Follow the guide at certbot.eff.org for the "None of the above" web server, then start algernon with --cert=/etc/letsencrypt/live/mydomain.space/cert.pem --key=/etc/letsencrypt/live/mydomain.space/privkey.pem where mydomain.space is replaced with your own domain name.

First make Algernon serve a directory for the domain, like /srv/mydomain.space, then use that as the webroot when configuring certbot with the certbot certonly command.

Remember to set up a cron-job or something similar to run certbot renew every once in a while (every 12 hours is suggested by certbot.eff.org). Also remember to restart the algernon service after updating the certificates. A way to refresh the certificates without restarting Algernon will be implemented in the future.

Releases

Requirements

  • go 1.14 or later is supported.
  • For go 1.10, 1.11, 1.12 and 1.13 + gcc-go <10 version 1.12.7 of Algernon is the latest supported version.

Access logs

Can log to a Combined Log Format access log with the --accesslog flag. This works nicely together with goaccess.

Example usage

Serve files in one directory:

algernon --accesslog=access.log -x

Then visit the web page once, to create one entry in the access.log.

The wonderful goaccess utility can then be used to view the access log, while it is being filled:

goaccess --no-global-config --log-format=COMBINED access.log

If you have goaccess setup correctly, running goaccess without any flags should work too:

goaccess access.log

.alg files

.alg files are just renamed .zip files, that can be served by Algernon. There is an example application here: wercstyle.

Logo license

Thanks to Egon Elbre for the two SVG drawings that I remixed into the current logo (CC0 licensed).

Listening to port 80 without running as root

For Linux:

sudo setcap cap_net_bind_service=+ep /usr/bin/algernon

Other resources

General information

0-0

Comments
  • reduce external dependencies?

    reduce external dependencies?

    it is possible to reduce the external dependcy like this? https://github.com/xyproto/algernon/blob/93349dfc4d3daa5351c51551e8a8b9f0633bdc90/themes/html.go#L88

    I like your project, but hard-coded external dependencies are not acceptable to me. :}

    opened by bodsch 25
  • Teal Support

    Teal Support

    Might be interesting to support Teal so that you can have typed lua code. Would make it easier to build larger, more complex apps with Algernon.

    Disclaimer: I am far more experienced with Go, and even somewhat with TS, compared to Lua.

    enhancement 
    opened by tooolbox 21
  • libc.so.6: version `GLIBC_2.32' not found

    libc.so.6: version `GLIBC_2.32' not found

    I am currently revising my ansible roles for algernon and creating various tests with different operating systems. In the process I noticed that algernon as of 1.12.11 does not work with CentOS 8, OracleLinux 8, debain9/10, ubuntu 20.04.

    Here I get the following error:

    # /usr/local/bin/algernon --help
    /usr/local/bin/algernon: /lib64/libc.so.6: version `GLIBC_2.32' not found (required by /usr/local/bin/algernon)
    
    • CentOS and OracleLinux ship with a glibc 2.28:
    # rpm -qa | grep glibc
    glibc-2.28-127.el8.x86_64
    

    With Debian it looks similar:

    • debian9:
    # dpkg -l | grep libc6
    ii libc6:amd64 2.24-11+deb9u4
    
    • ubuntu 20.04
    # dpkg -l | grep libc6
    ii libc6:amd64 2.31-0ubuntu9.1
    

    Up to version 1.12.8 all versions worked fine.

    Were there such profound changes that a glibc > 2.31 is needed?

    enhancement 
    opened by bodsch 20
  • Support for raw SQL when using PostgreSQL or MariaDB/MySQL

    Support for raw SQL when using PostgreSQL or MariaDB/MySQL

    It's not clear how the DB integration works-

    Do you have to use the built in methods to write/access data or can you write SQL queries? Or do you have to write Lua code to make the connection? Also, how to imports/require work for external Lua modules?

    Thanks

    enhancement 
    opened by mphuie 18
  • MSSQL Query Support

    MSSQL Query Support

    I quite like the server you've put together, it checks a few boxes I'm interested in for a particular project.

    I see you have PQ() for doing arbitrary Postgres queries. I need to support MSSQL; perhaps we could add a MSQ() function? Seems straightforward, basically copying lua/pquery/pquery.go and importing the appropriate driver.

    Let me know what you think.

    enhancement 
    opened by tooolbox 14
  • redirect() and status() not setting HTTP status?

    redirect() and status() not setting HTTP status?

    I've been trying to get a simple webapp up and running with Algernon, but I can't seem to get the redirect() and status() Lua functions to work. The problem appears to be that although they set the Location: header correctly, they don't set the HTTP status (it's always 200), so no redirect.

    Here's /logout/index.lua:

    if Username() ~= '' then
        Logout(Username())
    end
    
    redirect('http://localhost:3000/login/')
    -- status(302)
    -- setheader('Location', 'http://localhost:3000/login/')
    

    And here's what httpie says:

    # http http://localhost:3000/logout/
    HTTP/1.1 200 OK
    Content-Length: 63
    Content-Type: text/html; charset=utf-8
    Date: Tue, 12 Jul 2016 18:41:24 GMT
    Location: http://localhost:3000/login/
    Server: Algernon 1.0
    X-Content-Type-Options: nosniff
    X-Xss-Protection: 1; mode=block
    
    <a href="http://localhost:3000/login/">Moved Permanently</a>.
    

    I had a look at the source code, but I couldn't figure it out.

    Additionally, I think 301 (Moved Permanently) should probably be changed to 302 (Found). I believe that if you do, say, a 301 redirect from your logout page to your homepage, on subsequent attempts to visit /logout, the browser might skip that URL and go directly to /.

    opened by deanishe 11
  • Login cookies clear after server restart

    Login cookies clear after server restart

    If a user has been logged in using SetUsernameCookie/SetLoggedIn but then we restart the algernon server, UsernameCookie no longer returns the logged in username. Is there a way around this? We'd like the server to retain logins (or at least re-use the set cookie) after reboot.

    Thanks!!

    bug 
    opened by seansbox 10
  • Markdown not parsing reference links

    Markdown not parsing reference links

    I added a second place with same link, so changed it to a reference link:

    [ROWeb]:(http://algernon.roboticoverlords.org/)
    

    And what Algernon parsed that to was:

    /Users/buildslave/Library/Containers/org.roboticoverlords.algernon/Data/Documents/Algernon/(http:/algernon.roboticoverlords.org/)
    
    opened by scrumit 10
  • please vendor dependencies

    please vendor dependencies

    please vendor the dependencies of algernon, so that it is less likely to break when dependencies change.

    glide is a great tool for this.

    if you don't wish to vendor dependencies directly in algernon (which i would recommend you do), please at least create package log files with e.g. glide, so that dependency versions are pinned.

    opened by mischief 9
  • Add Teal Capabilities

    Add Teal Capabilities

    This PR adds Teal support to Algernon, as per #58

    • On startup, loads Teal as well as other required Lua modules into the VM
    • Recognizes the .tl extension for scripts and executes them
    • Looks for index.tl as a directory index file

    I realized, in the course of adding these features, it complicated the implementation to put them behind a feature flag, and also didn't match Algernon's ethos of "everything and the kitchen sink". So, it's just a straightforward feature add.

    I noted that the builtin Lua function error() has been overwritten by Algernon, which I think is not ideal and perhaps should be reverted, (what if you use a module that calls it?) but in the meantime I renamed it to throw().

    Currently there's no caching in production mode. The reasons are twofold: I don't really personally need it at the moment, and I realize it's also rather complicated because the first request compiles and saves to disk, and subsequent requests hit disk, with the appropriate per-file mutex behavior. I don't know @xyproto if you want to take that on since you're more familiar with the codebase, or if not, perhaps you can give suggestions on the best way to implement. But generally, I'm inclined to make the whole caching functionality a separate PR.

    Currently, data.tl is not supported, nor serverconf.tl or anything else, just Teal handler files. I'm not sure how vital those are and if they can simply be added down the road.

    enhancement 
    opened by tooolbox 7
  • pongo not injecting lua lists when using serve2()

    pongo not injecting lua lists when using serve2()

    Using Algernon 1.12.2. If I create an empty folder with these two files:

    index.po2:

    TEXT TEST: {{ testtext }}
    {% for k, v in testlist %}
    LIST TEST: {{ v }}
    {% endfor %}
    

    data.lua:

    testtext = "TEST"
    testlist = { "ITEM_1", "ITEM_2" }
    

    When I browse to the folder it works great:

    TEXT TEST: TEST
    LIST TEST: ITEM_1
    LIST TEST: ITEM_2
    

    HOWEVER, when I add the following file:

    index.lua:

    serve2("index.po2", { testtext="TEST", testlist={ "ITEM_1", "ITEM_2"} })
    

    If I restart the server, and refresh the folder in the browser, I instead get this:

    TEXT TEST: TEST
    

    If doesn't show the list, only the text. It doesn't seem to detect that testlist has contents.

    Thoughts? I can't seem to find a workaround.

    Thanks!

    bug 
    opened by seansbox 7
  • native modules don't work, and *aren't mentioned not working*

    native modules don't work, and *aren't mentioned not working*

    for example, I would like to use Candran, which like Teal does some preproccessing, and results in vanilla lua (it's really cool, supports lua 5.4 features, and a lot of nice syntax shorthands, and preprocessor macros, yet can compile down to lua 5.1)...but algernon doesn't support native modules... I set the package.path and package.cpath in code, i require() the module, that much works...but it has a dependendy, lpeglabel which is a native compiled .so file...(unlike normal lpeg which has LuLPeg and LPegLJ, I'm not aware of any pure-lua implementations of lpeglabel) and if I try to normally include Candran, the way which works with normal lua, I get

    ERRO[0000] Error in test.lua (interpreted as a server script):
    /home/jan6/lua//lua_modules/share/lua/5.1/candran.lua:6158: module lpeglabel not found:
    	no field package.preload['lpeglabel']
    	stat /home/jan6/lua//lua_modules/share/lua/5.1/lpeglabel.lua: no such file or directory
    	stat /home/jan6/lua//lua_modules/share/lua/5.1/lpeglabel/init.lua: no such file or directory
    	stat ./lpeglabel.lua: no such file or directory
    	stat /usr/local/share/lua/5.1/lpeglabel.lua: no such file or directory
    	stat /usr/local/share/lua/5.1/lpeglabel/init.lua: no such file or directory, 
    stack traceback:
    	[G]: in function 'require'
    	/home/jan6/lua//lua_modules/share/lua/5.1/candran.lua:6158: in function '_'
    	/home/jan6/lua//lua_modules/share/lua/5.1/candran.lua:7014: in function </home/jan6/lua//lua_modules/share/lua/5.1/candran.lua:0>
    	[G]: in function 'require'
    	test.lua:21: in main chunk
    	[G]: ? 
    

    so it seems to only be looking for .lua file, instead of .so

    apparently gopherlua doesn't support package.loadlib but algernon doesn't mention that, and it's annoying having to go on a hunt for whether any given part of the program itself, doesn't support something, or if it's just the program being buggy

    I assume it would be possible to instead have a Plugin that runs it through another lua interpreter...but that seems quite annoying workaround, and assumes the host has it's own lua available...

    or alternatively, would be required to manually compile candran code and send to the server, instead of being able to have the whole source be included in the .alg, which also sucks...

    documentation 
    opened by Jan69 2
  • Integrate pure-go Svelte compiler just like plenti

    Integrate pure-go Svelte compiler just like plenti

    The project Plenti(https://github.com/plentico/plenti) has built-it pure-go Svelte compiler, I'm dreaming an algernon version of built-in Svelete compiler.

    enhancement 
    opened by diyism 3
  • [Feature Request] to close response stream early

    [Feature Request] to close response stream early

    In nginx-lua/openresty, I can close the http response early (avoid my users waiting) and continue doing things that cost time on my server:

    ngx.say("bye bye, my user")
    ngx.eof()
    local http=require"httpc".create()
    http:request{method="GET", url="https://a web page of very long content"}
    local data,err=http:read"*a"
    

    Does the algernon web server have such an API? for example "end()":

    print("bye bye, my user")
    flush()
    end()
    hc = HTTPClient()
    hc:Get("https://a web page of very long content")
    
    enhancement 
    opened by diyism 5
  • question: can Algernon be configured to run over SSL but with a self-signed cert

    question: can Algernon be configured to run over SSL but with a self-signed cert

    I am experimenting with Algernon to use it as an Auth0 simulator for running in CI. For this I need it to run over SSL to avoid cors problems but also receive connections over http3 from the dotnet core identity framework.

    So, running with these args but the cert validation always results in mismatch name on the self signed cert.

    algernon \
      --verbose \
      --nobanner \
      --nodb \
      --nocache \
      --server \
      -u \
      --servername=auth0.local.net \
      --cert=$rootDir/app/sim/cert.pem \
      --key=$rootDir/app/sim/key.pem \
      --log=$rootDir/log/auth0sim.log \
      --accesslog=$rootDir/log/auth0sim.access.log \
      --internal=$rootDir/log/auth0sim.internal.log \
      $rootDir/app/sim :443
    
    question 
    opened by esumerfd 0
  • Command line arg --internal=filename ignores filename

    Command line arg --internal=filename ignores filename

    Starting the server like this:

    algernon --verbose --accesslog=ssl.log --internal=algernon.log
    

    Writes the internal log to a file called internal.log while the ServerInfo() says

    Internal log file:	algernon.log
    

    : algernon --version Algernon 1.14.0

    planning-to-reproduce-the-issue 
    opened by esumerfd 3
  • Authrefresh crashes randomly at startup

    Authrefresh crashes randomly at startup

    With this startup command I am am seeing these stack traces about 1 in 5 times. If I rerun it might work or might fail with a longer stack trace.

    : algernon --version Algernon 1.14.0

    Command executed:

    algernon --server --autorefresh  --cert app/sim/cert.pem  --key app/sim/key.pem  app/sim :3000
    
    Server directory:	app/sim
    Server address:		:3000
    Database:		Bolt (/var/folders/s6/ztxj9rzx6bn4zmczqj627z000000gn/T/algernon.db)
    Options:		[Auto-refresh, Server]
    Cache mode:		Off
    TLS certificate:	app/sim/cert.pem
    TLS key:		app/sim/key.pem
    Event server:		:5553
    Request limit:		10/sec per visitor
    Large file threshold:	44040192 bytes
    Large file timeout:	10 sec
    panic: close of closed channel
    
    goroutine 142 [running]:
    github.com/xyproto/symwalk.WalkLimit.func2()
    	gopath/pkg/mod/github.com/xyproto/[email protected]/walker.go:78 +0xaf
    created by github.com/xyproto/symwalk.WalkLimit
    	gopath/pkg/mod/github.com/xyproto/[email protected]/walker.go:75 +0x219
    

    This is the longer stack trace if it helps:

    goroutine 1 [running]:
    github.com/xyproto/symwalk.WalkLimit({0xc000044700, 0x34}, 0xc0000120a8, 0x64)
    	gopath/pkg/mod/github.com/xyproto/[email protected]/walker.go:115 +0x305
    github.com/xyproto/symwalk.Walk(...)
    	gopath/pkg/mod/github.com/xyproto/[email protected]/walker.go:26
    github.com/xyproto/recwatch.Subfolders({0xc000044700, 0x34})
    	gopath/pkg/mod/github.com/xyproto/[email protected]/subfolders.go:21 +0xaa
    github.com/xyproto/recwatch.NewRecursiveWatcher({0xc000044700?, 0x2981540?})
    	gopath/pkg/mod/github.com/xyproto/[email protected]/recwatch.go:20 +0x25
    github.com/xyproto/recwatch.EventServer({0xc000044700, 0x34}, {0x2144bdc, 0x1}, {0x1e5be71, 0x5}, {0x1e5929c, 0x4}, 0x14dc9380)
    	opath/pkg/mod/github.com/xyproto/[email protected]/eventserver.go:185 +0xf4
    github.com/xyproto/algernon/engine.(*Config).MustServe(0xc000192580, 0xf?)
    	gopath/pkg/mod/github.com/xyproto/[email protected]/engine/config.go:737 +0x1353
    main.main()
    	gopath/pkg/mod/github.com/xyproto/[email protected]/main.go:32 +0xe5
    
    planning-to-reproduce-the-issue 
    opened by esumerfd 2
Releases(v1.14.0)
Owner
Alexander F. Rødseth
Software Engineer, Arch Linux TU, Go/C/Python/C++ developer and open source enthusiast.
Alexander F. Rødseth
Golang-redis-webserver - Web server using redis

Web Server using Redis Api REST Database SQLITE3 Cache Redis # Creating record s

Paulo Lopes Estevão 1 Jun 19, 2022
Go web server - A web server that can accept a GET request and serve a response.

go_web_server A web server that can accept a GET request and serve a response. Go is a great language for creating simple yet efficient web servers an

Gilbert Ngeno 0 Jan 3, 2022
A simple http-web server logging incoming requests to stdout with simple http-interface.

http-cli-echo-logger A simple http-web server logging incoming requests to stdout with simple http-interface. Run locally go run ./cmd/main.go Default

Andrii Bosonchenko 5 Jul 18, 2022
a simple http server as replacement of python -m http.server

ser a simple http server as replacement of python -m http.server

Changkun Ou 4 Dec 5, 2022
RBTI Golang Server uses PostgreSQL and for its main database and uses Elasticsearch

RBTI Golang Server This server is used for my thesis project, it uses PostgreSQL and for its main database and uses Elasticsearch for faster query spe

Haikal Ikhwan 0 Jan 17, 2022
Fishserver is designed to quickly add HTTP handlers to HTTP servers. It supports registration of various HTTP

Fishserver is designed to quickly add HTTP handlers to HTTP servers. It supports registration of various HTTP. Handler interface types such as Gin Engine, Go's built-in HTTP. HandlerFunc, or http.ServeMux. The HTTP server can be configured quickly with options and can be used for test cases.

coolstina 0 Nov 1, 2021
HTTP Echo is a go web server that echos back the arguments given to it.

HTTP Echo is a go web server that echos back the arguments given to it. This is especially useful for demos or a more extensive "hello world" application in Docker or Kubernetes.

jxlwqq 7 Jul 27, 2022
OpenAPI specs for your Go server, generated at server runtime. No CLI, no code generation, and no HTTP

Overview "oas" is short for "OpenAPI Spec". Go package for generating OpenAPI docs at runtime. Non-features: No code generation. No CLI. No magic comm

Nelo Mitranim 0 Dec 3, 2021
Fully featured and highly configurable SFTP server with optional FTP/S and WebDAV support - S3, Google Cloud Storage, Azure Blob

SFTPGo Fully featured and highly configurable SFTP server with optional FTP/S and WebDAV support, written in Go. Several storage backends are supporte

Nicola Murino 5.2k Dec 3, 2022
Simple webhook delivery system powered by Golang and PostgreSQL

postmand Simple webhook delivery system powered by Golang and PostgreSQL. Features Simple rest api with only three endpoints (webhooks/deliveries/deli

Allisson Azevedo 19 Oct 13, 2022
Stream database events from PostgreSQL to Kafka

PSQL-Streamer This service receives the database events from PostgreSQL using logical replication protocol and feeds them to sinks based on the config

Igor Novgorodov 46 Nov 3, 2022
✨ A lightweight HTTP server based on GO, will try to detect your OS and architecture and return as SHELL script. ✨

✨ A lightweight HTTP server based on GO, will try to detect your OS and architecture and return as SHELL script. ✨

Salvydas Lukosius 8 Nov 29, 2022
Oogway is a simple web server with dynamic content generation and extendability in mind supporting a Git based workflow.

Oogway Oogway is a simple web server with dynamic content generation and extendability in mind supporting a Git based workflow. It's somewhere in betw

Emvi 6 Nov 9, 2022
A feature flag solution, with only a YAML file in the backend (S3, GitHub, HTTP, local file ...), no server to install, just add a file in a central system and refer to it. 🎛️

??️ go-feature-flag A feature flag solution, with YAML file in the backend (S3, GitHub, HTTP, local file ...). No server to install, just add a file i

Thomas Poignant 557 Dec 7, 2022
Opinionated boilerplate Golang HTTP server with CORS, OPA, Prometheus, rate-limiter for API and static website.

Teal.Finance/Server Opinionated boilerplate HTTP server with CORS, OPA, Prometheus, rate-limiter… for API and static website. Origin This library was

teal.finance 8 Nov 3, 2022
HTTP server receives events and publishes them to STAN

Publishes events to Nats Streaming(STAN) synchornously and asynchronously. Cache events's publish-state using Redis and Store events using MongoDB.

Mehdi 15 Nov 9, 2022
Fast, multi-platform web server with automatic HTTPS

a project Every site on HTTPS Caddy is an extensible server platform that uses TLS by default. Releases · Documentation · Get Help Menu Features Insta

Caddy 44.6k Dec 1, 2022
Lightweight go web server that provides a searchable directory index.

autoindex Lightweight go web server that provides a searchable directory index. Optimized for handling large numbers of files (100k+) and remote file

Niels AD 22 Aug 28, 2022