a better customizable tool to embed files in go; also update embedded files remotely without restarting the server

Overview

fileb0x Circle CI GoDoc GoReportCard

What is fileb0x?

A better customizable tool to embed files in go.

It is an alternative to go-bindata that have better features and organized configuration.

TL;DR

a better go-bindata


How does it compare to go-bindata?

Feature fileb0x go-bindata
gofmt yes (optional) no
golint safe unsafe
gzip compression yes yes
gzip decompression yes (optional: runtime) yes (on read)
gzip compression levels yes no
separated prefix / base for each file yes no (all files only)
different build tags for each file yes no
exclude / ignore files yes (glob) yes (regex)
spread files yes no (single file only)
unexported vars/funcs yes (optional) no
virtual memory file system yes no
http file system / handler yes no
replace text in files yes no
glob support yes no (walk folders only)
regex support no yes (ignore files only)
config file yes (config file only) no (cmd args only)
update files remotely yes no

What are the benefits of using a Virtual Memory File System?

By using a virtual memory file system you can have access to files like when they're stored in a hard drive instead of a map[string][]byte you would be able to use IO writer and reader. This means you can read, write, remove, stat and rename files also make, remove and stat directories.

TL;DR

Virtual Memory File System has similar functions as a hdd stored files would have.

Features

  • golint safe code output

  • optional: gzip compression (with optional run-time decompression)

  • optional: formatted code (gofmt)

  • optional: spread files

  • optional: unexporTed variables, functions and types

  • optional: include multiple files and folders

  • optional: exclude files or/and folders

  • optional: replace text in files

  • optional: custom base and prefix path

  • Virtual Memory FileSystem - webdav

  • HTTP FileSystem and Handler

  • glob support - doublestar

  • json / yaml / toml support

  • optional: Update files remotely

  • optional: Build tags for each file

License

MIT

Get Started

TL;DR QuickStart™

Here's the get-you-going in 30 seconds or less:

git clone https://github.com/UnnoTed/fileb0x.git
cd fileb0x
cd _example/simple
go generate
go build
./simple
  • mod.go defines the package as example.com/foo/simple
  • b0x.yaml defines the sub-package static from the folder public
  • main.go includes the comment //go:generate go run github.com/UnnoTed/fileb0x b0x.yaml
  • main.go also includes the import example.com/foo/simple/static
  • go generate locally installs fileb0x which generates ./static according to bax.yaml
  • go build creates the binary simple from package main in the current folder
  • ./simple runs the self-contained standalone webserver with built-in files from public
How to use it?
1. Download
go get -u github.com/UnnoTed/fileb0x
2. Create a config file

First you need to create a config file, it can be *.json, *.yaml or *.toml. (* means any file name)

Now write into the file the configuration you wish, you can use the example files as a start.

json config file example b0x.json

yaml config file example b0x.yaml

toml config file example b0x.toml

3. Run

if you prefer to use it from the cmd or terminal edit and run the command below.

fileb0x YOUR_CONFIG_FILE.yaml

or if you wish to generate the embedded files through go generate just add and edit the line below into your main.go.

//go:generate fileb0x YOUR_CONFIG_FILE.yaml
What functions and variables fileb0x let me access and what are they for?

HTTP

var HTTP http.FileSystem
Type

http.FileSystem

What is it?

A In-Memory HTTP File System.

What it does?

Serve files through a HTTP FileServer.

How to use it?
// http.ListenAndServe will create a server at the port 8080
// it will take http.FileServer() as a param
//
// http.FileServer() will use HTTP as a file system so all your files
// can be avialable through the port 8080
http.ListenAndServe(":8080", http.FileServer(myEmbeddedFiles.HTTP))
How to use it with `echo`?
package main

import (
	"github.com/labstack/echo"
	"github.com/labstack/echo/engine/standard"
	// your embedded files import here ...
	"github.com/UnnoTed/fileb0x/_example/echo/myEmbeddedFiles"
)

func main() {
	e := echo.New()

	// enable any filename to be loaded from in-memory file system
	e.GET("/*", echo.WrapHandler(myEmbeddedFiles.Handler))

	// http://localhost:1337/public/README.md
	e.Start(":1337")
}
How to serve a single file through echo?
package main

import (
	"github.com/labstack/echo"

	// your embedded files import here ...
	"github.com/UnnoTed/fileb0x/_example/echo/myEmbeddedFiles"
)

func main() {
	e := echo.New()

	// read ufo.html from in-memory file system
	htmlb, err := myEmbeddedFiles.ReadFile("ufo.html")
	if err != nil {
		log.Fatal(err)
	}

	// convert to string
	html := string(htmlb)

	// serve ufo.html through "/"
	e.GET("/", func(c echo.Context) error {

		// serve as html
		return c.HTML(http.StatusOK, html)
	})

	e.Start(":1337")
}
Examples

simple example - main.go

echo example - main.go

package main

import (
	"log"
	"net/http"

  // your generaTed package
	"github.com/UnnoTed/fileb0x/_example/simple/static"
)

func main() {
	files, err := static.WalkDirs("", false)
	if err != nil {
		log.Fatal(err)
	}

	log.Println("ALL FILES", files)

  // here we'll read the file from the virtual file system
	b, err := static.ReadFile("public/README.md")
	if err != nil {
		log.Fatal(err)
	}

  // byte to str
  s := string(b)
  s += "#hello"

  // write file back into the virtual file system
  err := static.WriteFile("public/README.md", []byte(s), 0644)
  if err != nil {
    log.Fatal(err)
  }


	log.Println(string(b))

	// true = handler
	// false = file system
	as := false

	// try it -> http://localhost:1337/public/secrets.txt
	if as {
		// as Handler
		panic(http.ListenAndServe(":1337", static.Handler))
	} else {
		// as File System
		panic(http.ListenAndServe(":1337", http.FileServer(static.HTTP)))
	}
}
Update files remotely

Having to upload an entire binary just to update some files in a b0x and restart a server isn't something that i like to do...

How it works?

By enabling the updater option, the next time that you generate a b0x, it will include a http server, this http server will use a http basic auth and it contains 1 endpoint / that accepts 2 methods: GET, POST.

The GET method responds with a list of file names and sha256 hash of each file. The POST method is used to upload files, it creates the directory tree of a new file and then creates the file or it updates an existing file from the virtual memory file system... it responds with a ok string when the upload is successful.

How to update files remotely?
  1. First enable the updater option in your config file:
##################
## yaml example ##
##################

# updater allows you to update a b0x in a running server
# without having to restart it
updater:
  # disabled by default
  enabled: false

  # empty mode creates a empty b0x file with just the 
  # server and the filesystem, then you'll have to upload
  # the files later using the cmd:
  # fileb0x -update=http://server.com:port b0x.yaml
  #
  # it avoids long compile time
  empty: false

  # amount of uploads at the same time
  workers: 3

  # to get a username and password from a env variable
  # leave username and password blank (username: "")
  # then set your username and password in the env vars 
  # (no caps) -> fileb0x_username and fileb0x_password
  #
  # when using env vars, set it before generating a b0x 
  # so it can be applied to the updater server.
  username: "user" # username: ""
  password: "pass" # password: ""
  port: 8041
  1. Generate a b0x with the updater option enabled, don't forget to set the username and password for authentication.
  2. When your files update, just run fileb0x -update=http://yourServer.com:8041 b0x.toml to update the files in the running server.
Build Tags

To use build tags for a b0x package just add the tags to the tags property in the main object of your config file

# default: main
pkg: static

# destination
dest: "./static/"

# build tags for the main b0x.go file
tags: "!linux"

You can also have different build tags for a list of files, you must enable the spread property in the main object of your config file, then at the custom list, choose the set of files which you want a different build tag

# default: main
pkg: static

# destination
dest: "./static/"

# build tags for the main b0x.go file
tags: "windows darwin"

# [spread] means it will make a file to hold all fileb0x data
# and each file into a separaTed .go file
#
# example:
# theres 2 files in the folder assets, they're: hello.json and world.txt
# when spread is activaTed, fileb0x will make a file: 
# b0x.go or [output]'s data, assets_hello.json.go and assets_world.txt.go
#
#
# type: bool
# default: false
spread: true

# type: array of objects
custom:
  # type: array of strings
  - files: 
    - "start_space_ship.exe"

    # build tags for this set of files
    # it will only work if spread mode is enabled
    tags: "windows"

  # type: array of strings
  - files: 
    - "ufo.dmg"

    # build tags for this set of files
    # it will only work if spread mode is enabled
    tags: "darwin"

the config above will make:

ab0x.go                         # // +build windows darwin

b0xfile_ufo.exe.go              # // +build windows
b0xfile_start_space_ship.bat.go # // +build darwin

Functions and Variables

FS (File System)
var FS webdav.FileSystem
Type

webdav.FileSystem

What is it?

In-Memory File System.

What it does?

Lets you read, write, remove, stat and rename files and make, remove and stat directories...

How to use it?
func main() {

	// you have the following functions available
	// they all control files/dirs from/to the in-memory file system!
	func Mkdir(name string, perm os.FileMode) error
	func OpenFile(name string, flag int, perm os.FileMode) (File, error)
	func RemoveAll(name string) error
	func Rename(oldName, newName string) error
	func Stat(name string) (os.FileInfo, error)
	// you should remove those lines ^

	// 1. creates a directory
	err := myEmbeddedFiles.FS.Mkdir(myEmbeddedFiles.CTX, "assets", 0777)
	if err != nil {
		log.Fatal(err)
	}

	// 2. creates a file into the directory we created before and opens it
	// with fileb0x you can use ReadFile and WriteFile instead of this complicaTed thing
	f, err := myEmbeddedFiles.FS.OpenFile(myEmbeddedFiles.CTX, "assets/memes.txt", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
	if err != nil {
		log.Fatal(err)
	}

	data := []byte("I are programmer I make computer beep boop beep beep boop")

	// write the data into the file
	n, err := f.Write(data)
	if err == nil && n < len(data) {
		err = io.ErrShortWrite
	}

	// close the file
	if err1 := f.Close(); err == nil {
		log.Fatal(err1)
	}

	// 3. rename a file
	// can also move files
	err = myEmbeddedFiles.FS.Rename(myEmbeddedFiles.CTX, "assets/memes.txt", "assets/programmer_memes.txt")
	if err != nil {
		log.Fatal(err)
	}

	// 4. checks if the file we renamed exists
	if _, err = myEmbeddedFiles.FS.Stat(myEmbeddedFiles.CTX, "assets/programmer_memes.txt"); os.IsExist(err) {
		// exists!

		// tries to remove the /assets/ directory
		// from the in-memory file system
		err = myEmbeddedFiles.FS.RemoveAll(myEmbeddedFiles.CTX, "assets")
		if err != nil {
			log.Fatal(err)
		}
	}

	// 5. checks if the dir we removed exists
	if _, err = myEmbeddedFiles.FS.Stat(myEmbeddedFiles.CTX, "public/"); os.IsNotExist(err) {
		// doesn't exists!
		log.Println("works!")
	}
}
Handler
var Handler *webdav.Handler
Type

webdav.Handler

What is it?

A HTTP Handler implementation.

What it does?

Serve your embedded files.

How to use it?
// ListenAndServer will create a http server at port 8080
// and use Handler as a http handler to serve your embedded files
http.ListenAndServe(":8080", myEmbeddedFiles.Handler)
ReadFile
func ReadFile(filename string) ([]byte, error)
Type

ioutil.ReadFile

What is it?

A Helper function to read your embedded files.

What it does?

Reads the specified file from the in-memory file system and return it as a byte slice.

How to use it?
// it works the same way that ioutil.ReadFile does.
// but it will read the file from the in-memory file system
// instead of the hard disk!
//
// the file name is passwords.txt
// topSecretFile is a byte slice ([]byte)
topSecretFile, err := myEmbeddedFiles.ReadFile("passwords.txt")
if err != nil {
	log.Fatal(err)
}

log.Println(string(topSecretFile))
WriteFile
func WriteFile(filename string, data []byte, perm os.FileMode) error
Type

ioutil.WriteFile

What is it?

A Helper function to write a file into the in-memory file system.

What it does?

Writes the data into the specified filename in the in-memory file system, meaning you embedded a file!

-- IMPORTANT -- IT WON'T WRITE THE FILE INTO THE .GO GENERATED FILE, IT WILL BE TEMPORARY, WHILE YOUR APP IS RUNNING THE FILE WILL BE AVAILABLE, AFTER IT SHUTDOWN, IT IS GONE.

How to use it?
// it works the same way that ioutil.WriteFile does.
// but it will write the file into the in-memory file system
// instead of the hard disk!
//
// the file name is secret.txt
// data should be a byte slice ([]byte)
// 0644 is a unix file permission

data := []byte("jet fuel can't melt steel beams")
err := myEmbeddedFiles.WriteFile("secret.txt", data, 0644)
if err != nil {
	log.Fatal(err)
}
WalkDirs
func WalkDirs(name string, includeDirsInList bool, files ...string) ([]string, error) {
Type

[]string

What is it?

A Helper function to walk dirs from the in-memory file system.

What it does?

Returns a list of files (with option to include dirs) that are currently in the in-memory file system.

How to use it?
includeDirsInTheList := false

// WalkDirs returns a string slice with all file paths
files, err := myEmbeddedFiles.WalkDirs("", includeDirsInTheList)
if err != nil {
	log.Fatal(err)
}

log.Println("List of all my files", files)
Comments
  • Go complains about unused variables

    Go complains about unused variables

    When compiling my main file, which imports a file generated with fileb0x, go finds err f rb and r to be "declared but not used". The only way I found to fix this was to manually delete the variables from inside the generated file.

    opened by ishehadeh 6
  • looks like the last couple of commits broke code generation

    looks like the last couple of commits broke code generation

    here is what we are getting in our CI:

    09:41:52 # github.com/Aptomi/aptomi/pkg/server/ui
    09:41:52 pkg/server/ui/ab0x.go:40:2: undefined: err
    09:41:52 pkg/server/ui/ab0x.go:41:5: undefined: err
    09:41:52 pkg/server/ui/ab0x.go:42:9: undefined: err
    09:41:52 pkg/server/ui/ab0x.go:45:2: undefined: err
    09:41:52 pkg/server/ui/ab0x.go:46:5: undefined: err
    09:41:52 pkg/server/ui/ab0x.go:47:9: undefined: err
    09:41:52 pkg/server/ui/ab0x.go:50:2: undefined: err
    09:41:52 pkg/server/ui/ab0x.go:51:5: undefined: err
    09:41:52 pkg/server/ui/ab0x.go:52:9: undefined: err
    09:41:52 pkg/server/ui/ab0x.go:55:2: undefined: err
    09:41:52 pkg/server/ui/ab0x.go:55:2: too many errors
    09:41:58 Makefile:85: recipe for target 'build' failed
    
    opened by romangithub1024 5
  • "Base" option stopped working

    Hi,

    Seems that https://github.com/UnnoTed/fileb0x/commit/5494112a4d3e8629069278b3b0125960cd699c8d changes the behavior of base.

    I have something like this:

    custom:
      - files:
        - "public/js"
        - "public/css"
        base: "public/"
    

    Before that commit, I could serve files as /js/... and /css/... instead of /public/js/. But now public/ is not being removed from the path anymore.

    Thanks for this awesome lib.

    opened by andreynering 4
  • go get -u github.com/UnnoTed/fileb0x error

    go get -u github.com/UnnoTed/fileb0x error

    github.com/airking05/termui

    C:\Users\administrator\go\pkg\mod\github.com\airking05\[email protected]+incompatible\render.go:107:30: not enough arguments in call to stack.ParseDump have (*bytes.Reader, *os.File) want (io.Reader, io.Writer, bool) C:\Users\administrator\go\pkg\mod\github.com\airking05\[email protected]+incompatible\render.go:112:10: undefined: stack.Palette C:\Users\administrator\go\pkg\mod\github.com\airking05\[email protected]+incompatible\render.go:113:15: undefined: stack.SortBuckets C:\Users\administrator\go\pkg\mod\github.com\airking05\[email protected]+incompatible\render.go:113:33: undefined: stack.Bucketize C:\Users\administrator\go\pkg\mod\github.com\airking05\[email protected]+incompatible\render.go:114:22: undefined: stack.CalcLengths

    opened by temaowangluo 3
  • go get Fail

    go get Fail

    go get -u github.com/UnnoTed/fileb0x
    
    # github.com/ungerik/go-dry
    src/github.com/ungerik/go-dry/debug.go:46:8: undefined: strings.Builder
    src/github.com/ungerik/go-dry/debug.go:58:8: undefined: strings.Builder
    src/github.com/ungerik/go-dry/debug.go:64:55: undefined: strings.Builder
    src/github.com/ungerik/go-dry/errors.go:115:8: undefined: strings.Builder
    src/github.com/ungerik/go-dry/string.go:148:8: undefined: strings.Builder
    src/github.com/ungerik/go-dry/string.go:257:8: undefined: strings.Builder
    src/github.com/ungerik/go-dry/string.go:274:8: undefined: strings.Builder
    
    go version
    go version go1.9.2 linux/amd64
    
    opened by yohanyflores 3
  • An attempt is made to create the root directory

    An attempt is made to create the root directory

    My directory structure looks something like this:

    .
    ├── b0x.yaml
    └── server
        ├── ab0x.go
        └── static
            └── css
                └── styles.min.css
    

    b0x.yaml contains the following:

    pkg: server
    dest: server
    compression:
      compress: true
    custom:
      - files:
        - server/static
        base: server
    

    However, when I generate server/ab0x.go, the following is added to init():

    err = FS.Mkdir(CTX, "/", 0777)
    if err != nil {
      log.Fatal(err)
    }
    

    This is a problem because attempting to create the root directory results in an error.

    opened by nathan-osman 3
  • "prefix" bugs?

    Hey.

    Has faced with several problems.

    First

    In attempt to use such configuration - I receive strange behavior. First dot in filenames will be replaced with a prefix var.

    custom:
      - files:
        - "./main.go"
        - "./fileb0x.yaml"
        base: "./"
        prefix: "_bug?_"
    

    Second

    The prefix option doesn't work for me :(

      - files:
        - "./static"
        prefix: "test_prefix/"
    

    Result:

    fileb0x

    opened by iu0v1 3
  • Please tag as v1.0.0 (or whatever)

    Please tag as v1.0.0 (or whatever)

    For the sake of being able to easily track likely breaking changes it would be great to have some tags.

    git tag v1.0.0
    git push --tags
    

    Since this is already much used and well-tested in the wild, starting at v1.0.0 makes sense to me - but you do what you like :)

    opened by coolaj86 2
  • Undefined: err

    Undefined: err

    I'm getting an error that looks very similar to https://github.com/UnnoTed/fileb0x/issues/21 but I've double-checked and I have the fixed version of the code with the commit mentioned in that PR:

    # github.com/akerl/github-auth-lambda/static
    static/ab0x.go:45:5: undefined: err
    static/ab0x.go:46:5: undefined: err
    static/ab0x.go:47:9: undefined: err
    static/ab0x.go:50:5: undefined: err
    static/ab0x.go:51:5: undefined: err
    static/ab0x.go:52:9: undefined: err
    static/ab0x.go:55:2: undefined: err
    static/ab0x.go:56:5: undefined: err
    static/ab0x.go:57:9: undefined: err
    

    Here's my box.yaml: https://github.com/akerl/github-auth-lambda/blob/9f2de9c3a6fe8bde4484aada59ad872ab57ef638/box.yaml

    opened by akerl 2
  • Update timestamp only if there are other changes

    Update timestamp only if there are other changes

    Hi!

    Is there a way to make the asset generation idempotent so that it won't update the timestamp in the assets file if there are no other changes within the data?

    My configuration looks like this:

    pkg: assets
    dest: "."
    fmt: true
    output: assets.go
    updater:
      enabled: false
    custom:
      - files:
        - "./data/*.jpeg"
        base: "./data/"
    
    opened by sharpner 2
  • too many arguments in call to {FS.Mkdir, FS.OpenFile}

    too many arguments in call to {FS.Mkdir, FS.OpenFile}

    This error is happening while compiling the generated source.

    Rolling back to https://github.com/UnnoTed/fileb0x/commit/89859f8fda74286e7a8698efe57ba7acee55293c fixed for me.

    opened by andreynering 2
  • Bump gopkg.in/yaml.v2 from 2.2.1 to 2.2.8

    Bump gopkg.in/yaml.v2 from 2.2.1 to 2.2.8

    Bumps gopkg.in/yaml.v2 from 2.2.1 to 2.2.8.

    Commits
    • 53403b5 Optimize cases with long potential simple_keys (#555)
    • 1f64d61 Fix issue in simple_keys improvements (#548)
    • a95acef Update travis config to use latest go versions (#540)
    • 36babc3 Port stale simple_keys fix to v2 (#543)
    • 770b8da Fix Decorder doc typo (#494)
    • 1ed5951 Add Go 1.10-13 to travis setup.
    • f90ceb4 Fix check for non-map alias merging in v2 (#529)
    • 970885f Trivial style tuning on last change.
    • f221b84 Improve heuristics preventing CPU/memory abuse (#515)
    • bb4e33b Add logic to catch cases of alias abuse.
    • Additional commits viewable in compare view

    Dependabot compatibility score

    Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.


    Dependabot commands and options

    You can trigger Dependabot actions by commenting on this PR:

    • @dependabot rebase will rebase this PR
    • @dependabot recreate will recreate this PR, overwriting any edits that have been made to it
    • @dependabot merge will merge this PR after your CI passes on it
    • @dependabot squash and merge will squash and merge this PR after your CI passes on it
    • @dependabot cancel merge will cancel a previously requested merge and block automerging
    • @dependabot reopen will reopen this PR if it is closed
    • @dependabot close will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
    • @dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
    • @dependabot use these labels will set the current labels as the default for future PRs for this repo and language
    • @dependabot use these reviewers will set the current reviewers as the default for future PRs for this repo and language
    • @dependabot use these assignees will set the current assignees as the default for future PRs for this repo and language
    • @dependabot use this milestone will set the current milestone as the default for future PRs for this repo and language

    You can disable automated security fix PRs for this repo from the Security Alerts page.

    dependencies 
    opened by dependabot[bot] 0
  • windows compile it got error

    windows compile it got error

    github.com/UnnoTed/fileb0x/custom

    custom\custom.go:58:31: cannot use customFile (type string) as type fs.FS in argument to doublestar.Glob: string does not implement fs.FS (missing Open method)

    opened by runsys 0
  • Possible to pack SQLite file?

    Possible to pack SQLite file?

    I have a program that read data from local sqlite db, and show data to users, I wanna to pack all assets include sqlite file to one binary file, this program only execute read operation from sqlite, is it possible to pack sqlite file?

    opened by TangMonk 0
  • Added Init config variable.

    Added Init config variable.

    When the config file specifies the Init option, the initialization function will be named that (by default it is init() ).

    Users can specify an exported name which needs to be explicitly called. This allows initialization to be explicit to avoid doing it in cases where it is not needed.

    opened by scudette 4
Releases(v1.1.4)
Owner
null
Generates go code to embed resource files into your library or executable

Deprecating Notice go is now going to officially support embedding files. The go command will support //go:embed tags. Go Embed Generates go code to e

Peter 6.3k Jun 2, 2021
The simple and easy way to embed static files into Go binaries.

NOTICE: Please consider migrating your projects to github.com/markbates/pkger. It has an idiomatic API, minimal dependencies, a stronger test suite (t

Buffalo - The Go Web Eco-System 3.4k Sep 27, 2022
Embed files into a Go executable

statik statik allows you to embed a directory of static files into your Go binary to be later served from an http.FileSystem. Is this a crazy idea? No

Jaana Dogan 3.5k Sep 22, 2022
Using brotli compression to embed static files in Go.

?? Broccoli go get -u aletheia.icu/broccoli Broccoli uses brotli compression to embed a virtual file system of static files inside Go executables. A f

Aletheia 526 Sep 20, 2022
:file_folder: Embeds static resources into go files for single binary compilation + works with http.FileSystem + symlinks

Package statics Package statics embeds static files into your go applications. It provides helper methods and objects to retrieve embeded files and se

Go Playgound 65 Sep 27, 2022
Hotswap provides a solution for reloading your go code without restarting your server, interrupting or blocking any ongoing procedure.

Hotswap provides a solution for reloading your go code without restarting your server, interrupting or blocking any ongoing procedure. Hotswap is built upon the plugin mechanism.

Edwin 115 Sep 21, 2022
A C/S Tool to Download Torrent Remotely and Retrieve Files Back Over HTTP at Full Speed without ISP Torrent Limitation.

remote-torrent Download Torrent Remotely and Retrieve Files Over HTTP at Full Speed without ISP Torrent Limitation. This repository is an extension to

Bruce Wang 58 Aug 9, 2022
Get an embed.FS from inside an embed.FS

embed.FS wrapper providing additional functionality Features Get an embed.FS from an embedded subdirectory Handy Copy(sourcePath, targetPath) method t

Lea Anthony 21 Aug 20, 2022
Recreate embedded filesystems from embed.FS type in current working directory.

rebed Recreate embedded filesystems from embed.FS type in current working directory. Expose the files you've embedded in your binary so users can see

Patricio Whittingslow 22 Feb 28, 2022
The runner project is to create an interface for users to run their code remotely without having to have any compiler on their machine

The runner project is to create an interface for users to run their code remotely without having to have any compiler on their machine. This is a work in progress project for TCSS 401X :)

cam 6 May 29, 2022
A simple daemon which will watch files on your filesystem, mirror them to MFS, automatically update related pins, and update related IPNS keys.

ipfs-sync is a simple daemon which will watch files on your filesystem, mirror them to MFS, automatically update related pins, and update related IPNS keys, so you can always access your directories from the same address. You can use it to sync your documents, photos, videos, or even a website!

null 75 Sep 6, 2022
kcp is a prototype of a Kubernetes API server that is not a Kubernetes cluster - a place to create, update, and maintain Kube-like APis with controllers above or without clusters.

kcp is a minimal Kubernetes API server How minimal exactly? kcp doesn't know about Pods or Nodes, let alone Deployments, Services, LoadBalancers, etc.

Prototype of Future Kubernetes Ideas 1.6k Sep 21, 2022
Monitorable, gracefully restarting, self-upgrading binaries in Go (golang)

overseer overseer is a package for creating monitorable, gracefully restarting, self-upgrading binaries in Go (golang). The main goal of this project

Jaime Pillora 1.9k Sep 28, 2022
A restart tracker that gives context to what is restarting in your cluster

A restart tracker that gives context to what is restarting in your cluster

Soraro Labs 48 Aug 22, 2022
This action prints "true" if image is required to update based on the base image update.

container-image-updater This action prints "true" if image is required to update based on the base image update. Inputs Name Type Description base-ima

Manjunath Kumatagi 1 Apr 15, 2022
Automatic-Update-Launcher - A general purpose updater for updating program binaries when update folder exists

Automatic Update Launcher A general purpose updater for updating (web) applicati

Toby Chui 4 Jun 27, 2022
A web server for managing VirtualBox vms remotely(using VirtualBox CLI: vboxmanage)

VirtualBox-Manager A simple http server(using echo) and virtualbox wrapper for controlling virtualbox vms remotly. available commands: status on off s

Mohammad ebrahim Adibzadeh 6 Dec 26, 2021
Command-line tool to remotely execute commands on Windows machines through WinRM

winrm-cli This is a Go command-line executable to execute remote commands on Windows machines through the use of WinRM/WinRS. Note: this tool doesn't

Brice Figureau 143 Sep 27, 2022
A tool to be used with 'go generate' to embed external template files into Go code.

templify A tool to be used with 'go generate' to embed external template files into Go code. Scenario An often used scenario in developing go applicat

Michael Wolber 27 Jan 24, 2022