A simple and flexible health check library for Go.

<div align="center">
    <h1>Health</h1>
</div>

<p align="center">
A simple and flexible health check library for Go.
</p>
<div align="center">

[![Build](https://github.com/alexliesenfeld/health/actions/workflows/build.yml/badge.svg)](https://github.com/alexliesenfeld/health/actions/workflows/build.yml)
[![codecov](https://codecov.io/gh/alexliesenfeld/health/branch/main/graph/badge.svg?token=V2mVh8RvYE)](https://codecov.io/gh/alexliesenfeld/health)
[![Go Report Card](https://goreportcard.com/badge/github.com/alexliesenfeld/health)](https://goreportcard.com/report/github.com/alexliesenfeld/health)
[![GolangCI](https://golangci.com/badges/github.com/alexliesenfeld/health.svg)](https://golangci.com/r/github.com/alexliesenfeld/health)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)
[![FOSSA Status](https://app.fossa.com/api/projects/custom%2B26405%2Fgithub.com%2Falexliesenfeld%2Fhealth.svg?type=shield)](https://app.fossa.com/projects/custom%2B26405%2Fgithub.com%2Falexliesenfeld%2Fhealth?ref=badge_shield)

</div>

<p align="center">
    <a href="https://pkg.go.dev/github.com/alexliesenfeld/health">Documentation</a>
    ·
    <a href="https://github.com/alexliesenfeld/health/issues">Report Bug</a>
    ·
    <a href="https://github.com/alexliesenfeld/health/issues">Request Feature</a>
</p>

## Table of Contents
1. [Getting started](#getting-started)
1. [Synchronous vs. Asynchronous Checks](#synchronous-vs-asynchronous-checks)
1. [Caching](#caching)
1. [Listening to Status Changes](#listening-to-status-changes)
1. [Middleware and Interceptors](#middleware-and-interceptors)
1. [Compatibility With Other Libraries](#compatibility-with-other-libraries)
1. [License](#license)

## Getting Started

This library provides a [http.Handler](https://pkg.go.dev/net/http#Handler) that acts as a health endpoint. It can be 
used by [cloud infrastructure](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/) 
or other services to determine the availability of an application.

Rather than simply returning a response with HTTP status code 200, this library allows building health checks 
that test the availability of all required dependencies. The HTTP response contains the aggregated health result and 
details about the health status of each component.

### Example
```go
package main

import (
	"context"
	"database/sql"
	"fmt"
	"github.com/alexliesenfeld/health"
	_ "github.com/mattn/go-sqlite3"
	"log"
	"net/http"
	"time"
)

// This is a very simple example that shows the basic features of this library.
func main() {
	db, _ := sql.Open("sqlite3", "simple.sqlite")
	defer db.Close()

	// Create a new Checker.
	checker := health.NewChecker(
		
		// Set the time-to-live for our cache to 1 second (default).
		health.WithCacheDuration(1*time.Second),

		// Configure a global timeout that will be applied to all checks.
		health.WithTimeout(10*time.Second),

		// A check configuration to see if our database connection is up.
		// The check function will be executed for each HTTP request.
		health.WithCheck(health.Check{
			Name:    "database",      // A unique check name.
			Timeout: 2 * time.Second, // A check specific timeout.
			Check:   db.PingContext,
		}),

		// The following check will be executed periodically every 15 seconds
		// started with an initial delay of 3 seconds. The check function will NOT
		// be executed for each HTTP request.
		health.WithPeriodicCheck(15*time.Second, 3*time.Second, health.Check{
			Name: "search",
			// The check function checks the health of a component. If an error is
			// returned, the component is considered unavailable (or "down").
			// The context contains a deadline according to the configured timeouts.
			Check: func(ctx context.Context) error {
				return fmt.Errorf("this makes the check fail")
			},
		}),

		// Set a status listener that will be invoked when the health status changes.
		// More powerful hooks are also available (see docs).
		health.WithStatusListener(func(ctx context.Context, state health.CheckerState) {
			log.Println(fmt.Sprintf("health status changed to %s", state.Status))
		}),
	)

	// Create a new health check http.Handler that returns the health status
	// serialized as a JSON string. You can pass pass further configuration
	// options to NewHandler to modify default configuration.
	http.Handle("/health", health.NewHandler(checker))
	log.Fatalln(http.ListenAndServe(":3000", nil))
}

```

Because our search component is down, the request `curl http://localhost:3000/health`
would yield a response with HTTP status code `503 (Service Unavailable)`, and the following JSON response body:

```json
{
  "status": "down",
  "details": {
    "database": {
      "status": "up",
      "timestamp": "2021-07-01T08:05:14.603364Z"
    },
    "search": {
      "status": "down",
      "timestamp": "2021-07-01T08:05:08.522685Z",
      "error": "this makes the check fail"
    }
  }
}
```

[This example](https://github.com/alexliesenfeld/health/blob/main/examples/showcase/main.go)
shows **all features** of this library.

## Synchronous vs. Asynchronous Checks

With "synchronous" health checks we mean that every HTTP request initiates a health check and waits until all check
functions complete before returning an aggregated health result. You can configure synchronous checks
using the `WithCheck` configuration option (see [example above](#getting-started)).

Synchronous checks can be sufficient for smaller applications but might not scale well for more involved applications. 
Sometimes an application needs to read a large amount of data, can experience latency issues or make an expensive 
calculation to tell something about its health. With synchronous health checks the application will not be able 
to respond quickly to health check requests
(see [here](https://loft.sh/blog/kubernetes-readiness-probes-examples-common-pitfalls/) 
why this is necessary to avoid service disruptions in modern cloud infrastructure).

Rather than executing health check functions on every HTTP request, periodic (or "asynchronous")
health checks execute the check function on a fixed schedule. With this approach, the health status is always read from
a local cache that is regularly updated in the background. This allows responding to HTTP requests instantly without
waiting for check functions to complete.

Periodic checks can be configured using the `WithPeriodicCheck` configuration option
(see [example above](#getting-started)).

**This library allows you to mix synchronous and asynchronous check functions**, so you can start out simple and easily
transition into a more scalable and robust health check implementation later.

## Caching

Health check results are cached to avoid sending too many request to the services that your program checks and to
mitigate "denial of service" attacks. The [TTL](https://en.wikipedia.org/wiki/Time_to_live) is set to 1 second by
default. If you do not want to use caching altogether, you can disable it using the `health.WithDisabledCache()`
configuration option.

## Listening to Status Changes

It can be useful to react to health status changes. For example, you might want to log status changes or adjust some
metrics, so you can easier correlate logs during root cause analysis or perform actions to mitigate the impact 
of an unhealthy component.

This library allows you to configure listener functions that will be called when either the overall/aggregated health
status changes, or that of a specific component.

### Example

```go
health.WithPeriodicCheck(5*time.Second, 0, health.Check{
    Name:   "search",
    Check:  myCheckFunc,
    StatusListener: func (ctx context.Context, name string, state CheckState) ) {
	    log.Printf("status of component '%s' changed to %s", name, state.Status)
    },
}),

health.WithStatusListener(func (ctx context.Context, state CheckerState)) {
    log.Printf("overall system health status changed to %s", state.Status)
}),
```

## Middleware and Interceptors

It can be useful to hook into the checking lifecycle to do some processing before and after a health check. For example,
you might want to add some tracing information to the [Context](https://pkg.go.dev/context#Context) before the check
function executes, do some logging or modify the check result before sending the HTTP response
(e.g., removing details on failed authentication).

This library provides two mechanisms that allow you to hook into processing:

* [Middleware](https://pkg.go.dev/github.com/alexliesenfeld/health#MiddlewareFunc) gives you the possibility to
  intercept all calls of [Checker.Check](https://pkg.go.dev/github.com/alexliesenfeld/health#Checker), which corresponds
  to every incoming HTTP request. In contrary to the usually used
  [middleware pattern](https://drstearns.github.io/tutorials/gomiddleware/), this middleware allows you to access check
  related information and post-process a check result before sending it in an HTTP response.

  | Middleware              | Description                                                                                                 |
    | ----------------------- |:------------------------------------------------------------------------------------------------------------|
  | [BasicAuth](https://pkg.go.dev/github.com/alexliesenfeld/health/middleware#BasicAuth)               | Reduces exposed health details based on authentication success. Uses [basic auth](https://en.wikipedia.org/wiki/Basic_access_authentication) for authentication.         |
  | [CustomAuth](https://pkg.go.dev/github.com/alexliesenfeld/health/middleware#BasicAuth)              | Same as BasicAuth middleware, but allows using an arbitrary function for authentication.                    |
  | [FullDetailsOnQueryParam](https://pkg.go.dev/github.com/alexliesenfeld/health/middleware#FullDetailsOnQueryParam) | Disables health details unless the request contains a previously configured query parameter name.          |
  | [BasicLogger](https://pkg.go.dev/github.com/alexliesenfeld/health/middleware#BasicLogger)             | Basic request-oriented logging functionality.                                                               |

* [Interceptors](https://pkg.go.dev/github.com/alexliesenfeld/health#InterceptorFunc) make it possible to intercept all
  calls to a check function. This is useful if you have cross-functional code that needs to be reusable and should have
  access to check state information.

  | Interceptor   | Description                                            |
    | ------------- |:-------------------------------------------------------|
  | [BasicLogger](https://pkg.go.dev/github.com/alexliesenfeld/health/interceptors#BasicLogger)   | Basic component check function logging functionality   |

## Compatibility With Other Libraries

Most existing Go health check libraries come with their own implementations of tool specific check functions
(such as for Redis, memcached, Postgres, etc.). Rather than reinventing the wheel and come up with yet another library
specific implementation of check functions, the goal was to design this library in a way that makes it easy to reuse
existing solutions. The following (non-exhaustive) list of health check implementations should work with this library
without or minimal adjustments:

* [github.com/hellofresh/health-go](https://github.com/hellofresh/health-go/tree/master/checks)
  (
  see [full example here](https://github.com/alexliesenfeld/health/blob/main/examples/compatibiltiy/hellofresh/main.go))
  ```go
  import httpCheck "github.com/hellofresh/health-go/v4/checks/http"
  ...
  health.WithCheck(health.Check{
     Name:    "google",
     Check:   httpCheck.New(httpCheck.Config{
        URL: "https://www.google.com",
     }),
  }),
  ```
* [github.com/etherlabsio/healthcheck](https://github.com/etherlabsio/healthcheck/tree/master/checkers)
  (
  see [full example here](https://github.com/alexliesenfeld/health/blob/main/examples/compatibiltiy/etherlabsio/main.go))
    ```go
  import "github.com/etherlabsio/healthcheck/v2/checkers"
  ...
  health.WithCheck(health.Check{
      Name:    "database",
      Check:   checkers.DiskSpace("/var/log", 90).Check,
  })
  ```
* [github.com/heptiolabs/healthcheck](https://github.com/heptiolabs/healthcheck/blob/master/checks.go)
  (
  see [full example here](https://github.com/alexliesenfeld/health/blob/main/examples/compatibiltiy/heptiolabs/main.go))
  ```go
  import "github.com/heptiolabs/healthcheck"
  ...
  health.WithCheck(health.Check{
      Name: "google",
      Check: func(ctx context.Context) error {
         deadline, _ := ctx.Deadline()
         timeout := time.Since(deadline)
         return healthcheck.HTTPGetCheck("https://www.google.com", timeout)()
      },
  }),
  ```
* [github.com/InVisionApp/go-health](https://github.com/InVisionApp/go-health/tree/master/checkers)
  (
  see [full example here](https://github.com/alexliesenfeld/health/blob/main/examples/compatibiltiy/invisionapp/main.go))
  ```go
    import "github.com/InVisionApp/go-health/checkers"
    ...
    // Create check as usual (no error checking for brevity)
    googleURL, err := url.Parse("https://www.google.com")
    check, err := checkers.NewHTTP(&checkers.HTTPConfig{
        URL: googleURL,
    })
    ...
    // Add the check in the Checker configuration.
    health.WithCheck(health.Check{
        Name: "google",
        Check: func(_ context.Context) error {
            _, err := check.Status() 
            return err
        },
    })
  ```

## License

`health` is free software: you can redistribute it and/or modify it under the terms of the MIT Public License.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MIT Public License for more details.

[![FOSSA Status](https://app.fossa.com/api/projects/custom%2B26405%2Fgithub.com%2Falexliesenfeld%2Fhealth.svg?type=large)](https://app.fossa.com/projects/custom%2B26405%2Fgithub.com%2Falexliesenfeld%2Fhealth?ref=badge_large)



health

Provide CLI, Package and Web for tree output and directories creation from Markdown or programmatically.

gtree

Minimalistic, pluggable Golang evloop/timer handler with dependency-injection.

# Anagent [![Build Status](https://travis-ci.org/mudler/anagent.svg?branch=master)](https://travis-ci.org/mudler/anagent) [![codecov](https://codecov.io/gh/mudler/anagent/branch/master/graph/badge.svg)](https://codecov.io/gh/mudler/anagent) [![Go Report Card](https://goreportcard.com/badge/github.com/mudler/anagent)](https://goreportcard.com/report/github.com/mudler/anagent) [![godoc](https://godoc.org/github.com/mudler/anagent?status.svg)](http://godoc.org/github.com/mudler/anagent)

Minimalistic, pluggable Golang evloop/timer handler with dependency-injection - based on [codegangsta/inject](github.com/codegangsta/inject) - [go-macaron/inject](github.com/go-macaron/inject) and [chuckpreslar/emission](https://github.com/chuckpreslar/emission).

*Anagent* is a lightweight library that allows you to plug inside to other event loops, or allows you to handle and create your own within your application - leaving the control to you.

It comes with dependency-injection from codegangsta/inject, and it's also a soft-wrapper to chuckpreslar/emission, adding to it dependency injection capabilities and timer handlers.

## Usage

### Event Emitter with Dependency injection

```go
    package main

    import (
    	"log"
    	"github.com/mudler/anagent"
    )

    type TestTest struct {
    	Test string
    }

    func main() {
    	agent := anagent.New()
    	mytest := &TestTest{Test: "PONG!"}
    	agent.Map(mytest)

    	agent.Once("test", func(te *TestTest, l *log.Logger) {
    		if te.Test == "PONG!" {
    			l.Println("It just works!")
    		}
    	})

    	agent.Emit("test")
    }
```

What happened here? we mapped our structure instance (```TestTest```) inside the agent with (```agent.Map()```), and all fired events can access to them.

### Timer / Reactor

```go
    package main

    import "github.com/mudler/anagent"
    import "fmt"

    type TestTest struct {
            Test string
    }

    func main() {
            agent := anagent.New()
            mytest := &TestTest{Test: "PONG!"}
            agent.Map(mytest)

            agent.Emitter().On("test", func(s string) { fmt.Println("Received: " + s) })

            // Not recurring timer
            agent.TimerSeconds(int64(3), false, func(a *anagent.Anagent, te *TestTest) {
                    a.Emitter().Emit("test", te.Test)
                    go a.Stop()
            })

            agent.Start() // Loops here and never returns
    }
 ```

The code portion will start and wait for 3 seconds, then it will execute the callback (not recurring, that's why the ```false```) that will fire a custom event defined before (note, it's not using the dependency-injection capabilities, thus it's accessing the emitter handler directly with ```agent.Emitter()```).

The difference is that when we access to ```On()``` provided by ```agent.On()```, we access to the agent dependencies, that have been mapped with ```agent.Map()``` - otherwise, with ```agent.Emitter().On()``` we are free to bind any arguments to the event callback.


After the event is fired, the timer stops the eventloop (```a.Stop()```), so the program returns.

### Hook into other loops

It is often in other framework to use loop patterns, as example in framework for game development, network agents, and such.
We can hook into other loops, and run the agent Step function, so we can still leverage the evloop functionalities.

```go
    package main

    import "github.com/mudler/anagent"
    import "fmt"

    type TestTest struct {
    	Test string
    }

    func main() {
    	agent := anagent.New()
    	mytest := &TestTest{Test: "PONG!"}
    	agent.Map(mytest)

        // Reply with a delay of 2s
    	agent.Emitter().On("test", func(s string) {
    		agent.TimerSeconds(int64(2), false, func() {
    			fmt.Println("Received: " + s)
    		})
    	})

    	// Recurring timer
    	agent.TimerSeconds(int64(3), true, func(a *anagent.Anagent, te *TestTest) {
    		fmt.Println("PING!")
    		a.Emitter().Emit("test", te.Test)
    	})

    	for { // Infinite loop
    		agent.Step()
    	}
    }
 ```


anagent

A fast, powerful and extensible web crawling & scraping framework.

Antch
====

[![Build Status](https://travis-ci.org/antchfx/antch.svg?branch=master)](https://travis-ci.org/antchfx/antch)
[![Coverage Status](https://coveralls.io/repos/github/antchfx/antch/badge.svg?branch=master)](https://coveralls.io/github/antchfx/antch?branch=master)
[![Go Report Card](https://goreportcard.com/badge/github.com/antchfx/antch)](https://goreportcard.com/report/github.com/antchfx/antch)
[![GoDoc](https://godoc.org/github.com/antchfx/antch?status.svg)](https://godoc.org/github.com/antchfx/antch)

**Antch**, inspired by [Scrapy](https://scrapy.org/). If you're familiar with scrapy, 
you can quickly get started.

Antch is a fast, powerful and extensible web crawling & scraping framework for Go, used 
to crawl websites and extract structured data from their pages.

Get Started
====

[Getting Started](https://github.com/antchfx/antch-getstarted)

Follow the Getting Started instructions to start your first spider.

- [English](https://github.com/antchfx/antch/wiki/Getting-Started)
- [简体中文](https://github.com/antchfx/antch/wiki/%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8)

Features
====

- Polite, highly concurrent web crawler.
- Powerful and customizable HTTP middleware.
- Item data pipeline for the web spider.
- Built-in proxy support (HTTP, HTTPS, SOCKS5).
- Built-in XPath query support for HTML/XML documents.
- Easy to use and integrate with your project.

Examples
===

[BingWallpaper](https://github.com/zhengchun/bingwallpaper) - Bing daily wallpaper.

Documentation
====

See [https://github.com/antchfx/antch/wiki](https://github.com/antchfx/antch/wiki)


antch

Library and command for making and extracting .zip and .tar.gz archives.

# archiver [![Go Reference](https://pkg.go.dev/badge/github.com/mholt/archiver/v4.svg)](https://pkg.go.dev/github.com/mholt/archiver/v4) [![Ubuntu-latest](https://github.com/mholt/archiver/actions/workflows/ubuntu-latest.yml/badge.svg)](https://github.com/mholt/archiver/actions/workflows/ubuntu-latest.yml) [![Macos-latest](https://github.com/mholt/archiver/actions/workflows/macos-latest.yml/badge.svg)](https://github.com/mholt/archiver/actions/workflows/macos-latest.yml) [![Windows-latest](https://github.com/mholt/archiver/actions/workflows/windows-latest.yml/badge.svg)](https://github.com/mholt/archiver/actions/workflows/windows-latest.yml)

Introducing **Archiver 4.0** - a cross-platform, multi-format archive utility and Go library. A powerful and flexible library meets an elegant CLI in this generic replacement for several platform-specific or format-specific archive utilities.

**:warning: v4 is in ALPHA. The core library APIs work pretty well but the command has not been implemented yet, nor have most automated tests. If you need the `arc` command, stick with v3 for now.**

## Features

- Stream-oriented APIs
- Automatically identify archive and compression formats:
	- By file name
	- By header
- Traverse directories, archive files, and any other file uniformly as [`io/fs`](https://pkg.go.dev/io/fs) file systems:
	- [`DirFS`](https://pkg.go.dev/github.com/mholt/archiver/v4#DirFS)
	- [`FileFS`](https://pkg.go.dev/github.com/mholt/archiver/v4#FileFS)
	- [`ArchiveFS`](https://pkg.go.dev/github.com/mholt/archiver/v4#ArchiveFS)
- Compress and decompress files
- Create and extract archive files
- Walk or traverse into archive files
- Extract only specific files from archives
- Insert (append) into .tar and .zip archives
- Read from password-protected 7-Zip files
- Numerous archive and compression formats supported
- Extensible (add more formats just by registering them)
- Cross-platform, static binary
- Pure Go (no cgo)
- Multithreaded Gzip
- Adjust compression levels
- Automatically add compressed files to zip archives without re-compressing
- Open password-protected RAR archives

### Supported compression formats

- brotli (.br)
- bzip2 (.bz2)
- flate (.zip)
- gzip (.gz)
- lz4 (.lz4)
- lzip (.lz)
- snappy (.sz)
- xz (.xz)
- zlib (.zz)
- zstandard (.zst)

### Supported archive formats

- .zip
- .tar (including any compressed variants like .tar.gz)
- .rar (read-only)
- .7z (read-only)

Tar files can optionally be compressed using any compression format.

## Command use

Coming soon for v4. See [the last v3 docs](https://github.com/mholt/archiver/tree/v3.5.1).


## Library use

```bash
$ go get github.com/mholt/archiver/v4
```


### Create archive

Creating archives can be done entirely without needing a real disk or storage device since all you need is a list of [`File` structs](https://pkg.go.dev/github.com/mholt/archiver/v4#File) to pass in.

However, creating archives from files on disk is very common, so you can use the [`FilesFromDisk()` function](https://pkg.go.dev/github.com/mholt/archiver/v4#FilesFromDisk) to help you map filenames on disk to their paths in the archive. Then create and customize the format type.

In this example, we add 4 files and a directory (which includes its contents recursively) to a .tar.gz file:

```go
// map files on disk to their paths in the archive
files, err := archiver.FilesFromDisk(nil, map[string]string{
	"/path/on/disk/file1.txt": "file1.txt",
	"/path/on/disk/file2.txt": "subfolder/file2.txt",
	"/path/on/disk/file3.txt": "",              // put in root of archive as file3.txt
	"/path/on/disk/file4.txt": "subfolder/",    // put in subfolder as file4.txt
	"/path/on/disk/folder":    "Custom Folder", // contents added recursively
})
if err != nil {
	return err
}

// create the output file we'll write to
out, err := os.Create("example.tar.gz")
if err != nil {
	return err
}
defer out.Close()

// we can use the CompressedArchive type to gzip a tarball
// (compression is not required; you could use Tar directly)
format := archiver.CompressedArchive{
	Compression: archiver.Gz{},
	Archival:    archiver.Tar{},
}

// create the archive
err = format.Archive(context.Background(), out, files)
if err != nil {
	return err
}
```

The first parameter to `FilesFromDisk()` is an optional options struct, allowing you to customize how files are added.

### Extract archive

Extracting an archive, extracting _from_ an archive, and walking an archive are all the same function.

Simply use your format type (e.g. `Zip`) to call `Extract()`. You'll pass in a context (for cancellation), the input stream, the list of files you want out of the archive, and a callback function to handle each file. 

If you want all the files, pass in a nil list of file paths.

```go
// the type that will be used to read the input stream
format := archiver.Zip{}

// the list of files we want out of the archive; any
// directories will include all their contents unless
// we return fs.SkipDir from our handler
// (leave this nil to walk ALL files from the archive)
fileList := []string{"file1.txt", "subfolder"}

handler := func(ctx context.Context, f archiver.File) error {
	// do something with the file
	return nil
}

err := format.Extract(ctx, input, fileList, handler)
if err != nil {
	return err
}
```

### Identifying formats

Have an input stream with unknown contents? No problem, archiver can identify it for you. It will try matching based on filename and/or the header (which peeks at the stream):

```go
format, input, err := archiver.Identify("filename.tar.zst", input)
if err != nil {
	return err
}
// you can now type-assert format to whatever you need;
// be sure to use returned stream to re-read consumed bytes during Identify()

// want to extract something?
if ex, ok := format.(archiver.Extractor); ok {
	// ... proceed to extract
}

// or maybe it's compressed and you want to decompress it?
if decom, ok := format.(archiver.Decompressor); ok {
	rc, err := decom.OpenReader(unknownFile)
	if err != nil {
		return err
	}
	defer rc.Close()

	// read from rc to get decompressed data
}
```

`Identify()` works by reading an arbitrary number of bytes from the beginning of the stream (just enough to check for file headers). It buffers them and returns a new reader that lets you re-read them anew.

### Virtual file systems

This is my favorite feature.

Let's say you have a file. It could be a real directory on disk, an archive, a compressed archive, or any other regular file. You don't really care; you just want to use it uniformly no matter what it is.

Use archiver to simply create a file system:

```go
// filename could be:
// - a folder ("/home/you/Desktop")
// - an archive ("example.zip")
// - a compressed archive ("example.tar.gz")
// - a regular file ("example.txt")
// - a compressed regular file ("example.txt.gz")
fsys, err := archiver.FileSystem(filename)
if err != nil {
	return err
}
```

This is a fully-featured `fs.FS`, so you can open files and read directories, no matter what kind of file the input was.

For example, to open a specific file:

```go
f, err := fsys.Open("file")
if err != nil {
	return err
}
defer f.Close()
```

If you opened a regular file, you can read from it. If it's a compressed file, reads are automatically decompressed.

If you opened a directory, you can list its contents:

```go
if dir, ok := f.(fs.ReadDirFile); ok {
	// 0 gets all entries, but you can pass > 0 to paginate
	entries, err := dir.ReadDir(0)
	if err != nil {
		return err
	}
	for _, e := range entries {
		fmt.Println(e.Name())
	}
}
```

Or get a directory listing this way:

```go
entries, err := fsys.ReadDir("Playlists")
if err != nil {
	return err
}
for _, e := range entries {
	fmt.Println(e.Name())
}
```

Or maybe you want to walk all or part of the file system, but skip a folder named `.git`:

```go
err := fs.WalkDir(fsys, ".", func(path string, d fs.DirEntry, err error) error {
	if err != nil {
		return err
	}
	if path == ".git" {
		return fs.SkipDir
	}
	fmt.Println("Walking:", path, "Dir?", d.IsDir())
	return nil
})
if err != nil {
	return err
}
```

#### Use with `http.FileServer`

It can be used with http.FileServer to browse archives and directories in a browser. However, due to how http.FileServer works, don't directly use http.FileServer with compressed files; instead wrap it like following:

```go
fileServer := http.FileServer(http.FS(archiveFS))
http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
	// disable range request
	writer.Header().Set("Accept-Ranges", "none")
	request.Header.Del("Range")
	
	// disable content-type sniffing
	ctype := mime.TypeByExtension(filepath.Ext(request.URL.Path))
	writer.Header()["Content-Type"] = nil
	if ctype != "" {
		writer.Header().Set("Content-Type", ctype)
	}
	fileServer.ServeHTTP(writer, request)
})
```

http.FileServer will try to sniff the Content-Type by default if it can't be inferred from file name. To do this, the http package will try to read from the file and then Seek back to file start, which the libray can't achieve currently. The same goes with Range requests. Seeking in archives is not currently supported by archiver due to limitations in dependencies.

If content-type is desirable, you can [register it](https://pkg.go.dev/mime#AddExtensionType) yourself.

### Compress data

Compression formats let you open writers to compress data:

```go
// wrap underlying writer w
compressor, err := archiver.Zstd{}.OpenWriter(w)
if err != nil {
	return err
}
defer compressor.Close()

// writes to compressor will be compressed
```

### Decompress data

Similarly, compression formats let you open readers to decompress data:

```go
// wrap underlying reader r
decompressor, err := archiver.Brotli{}.OpenReader(r)
if err != nil {
	return err
}
defer decompressor.Close()

// reads from decompressor will be decompressed
```

### Append to tarball and zip archives

Tar and Zip archives can be appended to without creating a whole new archive by calling `Insert()` on a tar or zip stream. However, for tarballs, this requires that the tarball is not compressed (due to complexities with modifying compression dictionaries).

Here is an example that appends a file to a tarball on disk:

```go
tarball, err := os.OpenFile("example.tar", os.O_RDWR, 0644)
if err != nil {
	return err
}
defer tarball.Close()

// prepare a text file for the root of the archive
files, err := archiver.FilesFromDisk(nil, map[string]string{
	"/home/you/lastminute.txt": "",
})

err := archiver.Tar{}.Insert(context.Background(), tarball, files)
if err != nil {
	return err
}
```

The code is similar for inserting into a Zip archive, except you'll call `Insert()` on the `Zip` type instead.



archiver

Go package to automatically define command line flags from struct fields.

autoflags
=========

Package autoflags provides a convenient way of exposing struct fields as
command line flags. Exposed fields should have `flag` tag attached:
`flag:"flagName,usage string"`.

For examples see [documentation][1].

[1]: http://godoc.org/github.com/artyom/autoflags


autoflags

Calculate average score and rating based on Wilson Score Equation.

# avgRating [![GoDoc](https://godoc.org/github.com/kirillDanshin/avgRating?status.svg)](https://godoc.org/github.com/kirillDanshin/avgRating) [![Go Report Card](https://goreportcard.com/badge/github.com/kirillDanshin/avgRating)](https://goreportcard.com/report/github.com/kirillDanshin/avgRating) ![cover.run go](https://cover.run/go/github.com/kirillDanshin/avgRating.svg)
Calculate average and scoring based on Wilson Score Equation

Port of https://github.com/ndaidong/average-rating

# License

The MIT License (MIT)


avgRating

Go counters for readers/writer/http.ResponseWriter.

# Datacounter

Golang counters for readers/writers.

[![Build Status](https://travis-ci.org/miolini/datacounter.svg)](https://travis-ci.org/miolini/datacounter) [![GoDoc](https://godoc.org/github.com/miolini/datacounter?status.svg)](http://godoc.org/github.com/miolini/datacounter)

## Examples

### ReaderCounter

```go
buf := bytes.Buffer{}
buf.Write(data)
counter := datacounter.NewReaderCounter(&buf)

io.Copy(ioutil.Discard, counter)
if counter.Count() != dataLen {
	t.Fatalf("count mismatch len of test data: %d != %d", counter.Count(), len(data))
}
```

### WriterCounter

```go
buf := bytes.Buffer{}
counter := datacounter.NewWriterCounter(&buf)

counter.Write(data)
if counter.Count() != dataLen {
	t.Fatalf("count mismatch len of test data: %d != %d", counter.Count(), len(data))
}
```

### http.ResponseWriter Counter

```go
handler := func(w http.ResponseWriter, r *http.Request) {
	w.Write(data)
}

req, err := http.NewRequest("GET", "http://example.com/foo", nil)
if err != nil {
	t.Fatal(err)
}

w := httptest.NewRecorder()
counter := datacounter.NewResponseWriterCounter(w)

handler(counter, req)
if counter.Count() != dataLen {
	t.Fatalf("count mismatch len of test data: %d != %d", counter.Count(), len(data))
}
```


datacounter

gatus

A slight and pluggable command-bus for Go.

# GO CommandBus

[![Build Status](https://img.shields.io/travis/lana/go-commandbus/master.svg?style=flat-square)](https://travis-ci.org/lana/go-commandbus)
[![Codecov branch](https://img.shields.io/codecov/c/github/lana/go-commandbus/master.svg?style=flat-square)](https://codecov.io/gh/lana/go-commandbus)
[![GoDoc](https://img.shields.io/badge/godoc-reference-5272B4.svg?style=flat-square)](https://godoc.org/github.com/lana/go-commandbus)
[![Go Report Card](https://goreportcard.com/badge/github.com/lana/go-commandbus?style=flat-square)](https://goreportcard.com/report/github.com/lana/go-commandbus)
[![License](https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square)](https://github.com/lana/go-commandbus/blob/master/LICENSE)

A slight and pluggable command-bus for Go.

## Install

Use go get.
```sh
$ go get github.com/lana/go-commandbus
```

Then import the package into your own code:
```
import "github.com/lana/go-commandbus"
```

## Usage
```go
package main

import (
	"context"
	"log"

	"github.com/lana/go-commandbus"
)

type CreateUser struct {
	Name string
}

func CreateHandler(ctx context.Context, cmd *CreateUser) error {
	log.Printf("user %s created", cmd.Name)

	return nil
}

func main() {
	bus := commandbus.New()

	err := bus.Register(&CreateUser{}, CreateHandler)

	if err != nil {
		log.Error(err)
		os.Exit(1)
	}

	err = bus.Execute(context.Background(), &CreateUser{"go-commandbus"})

	if err != nil {
		log.Error(err)
		os.Exit(1)
	}
}
```

## License

This project is released under the MIT licence. See [LICENSE](https://github.com/lana/go-commandbus/blob/master/LICENSE) for more details.


go-commandbus

Analyze git commit messages to ensure they follow defined patterns.

# Gommit [![codecov](https://codecov.io/gh/antham/gommit/branch/master/graph/badge.svg)](https://codecov.io/gh/antham/gommit) [![Go Report Card](https://goreportcard.com/badge/github.com/antham/gommit)](https://goreportcard.com/report/github.com/antham/gommit) [![GitHub tag](https://img.shields.io/github/tag/antham/gommit.svg)]()

Gommit analyze commits messages to ensure they follow defined pattern.

[![asciicast](https://asciinema.org/a/0j12qm7yay1kku7o3vrs67pv2.png)](https://asciinema.org/a/0j12qm7yay1kku7o3vrs67pv2)

## Summary

- [Setup](#setup)
- [Usage](#usage)
- [Practical Usage](#practical-usage)
- [Third Part Libraries](#third-part-libraries)

## Setup

Download from release page according to your architecture gommit binary : https://github.com/antham/gommit/releases

### Define a file .gommit.toml

Create a file `.gommit.toml` at the root of your project, for instance :

```toml
[config]
exclude-merge-commits=true
check-summary-length=true
summary-length=50

[matchers]
all="(?:ref|feat|test|fix|style)\$.*?\$ : .*?\n(?:\n?(?:\\* |  ).*?\n)*"

[examples]
a_simple_commit="""
[feat|test|ref|fix|style](module) : A commit message
"""
an_extended_commit="""
[feat|test|ref|fix|style](module) : A commit message

* first line
* second line
* and so on...
"""
```

#### Config

- `exclude-merge-commits` : if set to true, will not check commit message for merge commit
- `check-summary-length` : if set to true, check commit summary length, default is 50 characters
- `summary-length` : you can override the default value summary length, which is 50 characters, this config is used only if check-summary-length is true

#### Matchers

You can define as many matchers you want using regexp, naming is up to you, they will all be compared against a commit message till one match. Regexps used support comments, possessive match, positive lookahead, negative lookahead, positive lookbehind, negative lookbehind, back reference, named back referenc and conditionals.

#### Examples

Provided to help user to understand where is the problem, like matchers you can define as many examples as you want, they all will be displayed to the user if an error occured.

If you defined for instance :

```
a_simple_commit="""
[feat|test|ref|fix|style](module) : A commit message
"""
```

this example will be displayed to the user like that :

```
A simple commit :

[feat|test|ref|fix|style](module) : A commit message
```

key is used as a title, underscore are replaced with withespaces.

## Usage

```bash
Ensure your commit messages are consistent

Usage:
  gommit [command]

Available Commands:
  check       Check ensure a message follows defined patterns
  version     App version

Flags:
      --config string    (default ".gommit.toml")
  -h, --help            help for gommit

Use "gommit [command] --help" for more information about a command.
```

### check

```bash
Check ensure a message follows defined patterns

Usage:
  gommit check [flags]
  gommit check [command]

Available Commands:
  commit      Check commit message
  message     Check message
  range       Check messages in commit range

Flags:
  -h, --help   help for check

Global Flags:
      --config string    (default ".gommit.toml")

Use "gommit check [command] --help" for more information about a command.


You need to provide two commit references to run matching for instance :
```

#### check commit

```bash
Check commit message

Usage:
  gommit check commit [id] [&path] [flags]

Flags:
  -h, --help   help for commit

Global Flags:
      --config string    (default ".gommit.toml")
```

Check one comit from its commit ID, doesn't support short ID currently :

`gommit check commit aeb603ba83614fae682337bdce9ee1bad1da6d6e`

#### check message

```bash
Check message

Usage:
  gommit check message [message] [flags]

Flags:
  -h, --help   help for message

Global Flags:
      --config string    (default ".gommit.toml")
```

Check a message, useful for script for instance when you want to use it with git hooks :

`gommit check message "Hello"`

#### check range

```bash
Check messages in range

Usage:
  gommit check range [revisionfrom] [revisionTo] [&path] [flags]

Flags:
  -h, --help   help for range

Global Flags:
      --config string    (default ".gommit.toml")
```

Check a commit range, useful if you want to use it with a CI to ensure all commits in branch are following your conventions :

- with relative references : `gommit check range master~2^ master`
- with absolute references : `gommit check range dev test`
- with commit ids (doesn't support short ID currently) : `gommit check range 7bbb37ade3ff36e362d7e20bf34a1325a15b 09f25db7971c100a8c0cfc2b22ab7f872ff0c18d`

## Practical usage

If your system isn't described here and you find a way to have gommit working on it, please improve this documentation by doing a PR for the next who would like to do the same.

### Git hook

It's possible to use gommit to validate each commit when you are creating them. To do so, you need to use the `commit-msg` hook, you can replace default script with this one :

```
#!/bin/sh

gommit check message "$(cat "$1")";
```

### Travis

In travis, all history isn't cloned, default depth is 50 commits, you can change it : https://docs.travis-ci.com/user/customizing-the-build#Git-Clone-Depth.

First, we download the binary from the release page according to the version we want and we add in `.travis.yml` :

```yaml
before_install:
  - wget -O /tmp/gommit https://github.com/antham/gommit/releases/download/v2.0.0/gommit_linux_386 && chmod 777 /tmp/gommit
```

We can add a perl script in our repository to analyze the commit range against master for instance (master reference needs to be part of cloned history):

```perl
#!/bin/perl

`git ls-remote origin master` =~ /([a-f0-9]{40})/;

my $refHead = `git rev-parse HEAD`;
my $refTail = $1;

chomp($refHead);
chomp($refTail);

if ($refHead eq $refTail) {
    exit 0;
}

system "gommit check range $refTail $refHead";

if ($? > 0) {
    exit 1;
}
```

And finally in `.travis.yml`, make it crashs when an error occured :

```yaml
script: perl test-branch-commit-messages-in-travis.pl
```

### CircleCI

In CircleCI (2.0), there is an environment variable that describe current branch : `CIRCLE_BRANCH` (https://circleci.com/docs/2.0/env-vars/#circleci-environment-variable-descriptions).

First, we download the binary from the release page according to the version we want and we add in `.circleci/config.yml` :

```yaml
- run:
    name: Get gommit binary
    command: |
      mkdir /home/circleci/bin
      wget -O ~/bin/gommit https://github.com/antham/gommit/releases/download/v2.0.0/gommit_linux_386 && chmod 777 ~/bin/gommit
```

And we can run gommit against master for instance :

```yaml
- run:
    name: Run gommit
    command: |
      if [ $CIRCLE_BRANCH != 'master' ]; then ~/bin/gommit check range $(git rev-parse origin/master) $CIRCLE_BRANCH ; fi
```

## Third Part Libraries

### Nodejs

- [gommitjs](https://github.com/dschnare/gommitjs) : A Nodejs wrapper for gommit


gommit

Cross-platform library for retrieving process and system utilization(CPU, Memory, Disks, etc).

# gopsutil: psutil for golang

[![Test](https://github.com/shirou/gopsutil/actions/workflows/test.yml/badge.svg)](https://github.com/shirou/gopsutil/actions/workflows/test.yml) [![Go Reference](https://pkg.go.dev/badge/github.com/shirou/gopsutil/v4.svg)](https://pkg.go.dev/github.com/shirou/gopsutil/v4) [![Calendar Versioning](https://img.shields.io/badge/calver-vMAJOR.YY.MM-22bfda.svg)](https://calver.org/)

This is a port of psutil (https://github.com/giampaolo/psutil). The
challenge is porting all psutil functions on some architectures.

## migration

### v4 migration

There are some breaking changes. Please see [v4 release note](https://github.com/shirou/gopsutil/releases/tag/v4.24.5).

## Tag semantics

gopsutil tag policy is almost same as Semantic Versioning, but
automatically increases like [Ubuntu versioning](https://calver.org/).

For example, v4.24.04 means

- v4: major version
- 24: release year, 2024
- 04: release month

gopsutil aims to keep backwards compatibility until major version change.

Tagged at every end of month, but if there are only a few commits, it
can be skipped.

## Available Architectures

- FreeBSD i386/amd64/arm
- Linux i386/amd64/arm(raspberry pi)
- Windows i386/amd64/arm/arm64
- Darwin amd64/arm64
- OpenBSD i386/amd64/armv7/arm64/riscv64 (Thank you @mpfz0r!)
- Solaris amd64 (developed and tested on SmartOS/Illumos, Thank you @jen20!)

These have partial support:

- CPU on DragonFly BSD (#893, Thank you @gballet!)
- host on Linux RISC-V (#896, Thank you @tklauser!)

All works are implemented without cgo by porting C structs to golang structs.

## Usage

```go
package main

import (
    "fmt"

    "github.com/shirou/gopsutil/v4/mem"
)

func main() {
    v, _ := mem.VirtualMemory()

    // almost every return value is a struct
    fmt.Printf("Total: %v, Free:%v, UsedPercent:%f%%\n", v.Total, v.Free, v.UsedPercent)

    // convert to JSON. String() is also implemented
    fmt.Println(v)
}
```

The output is below.

    Total: 3179569152, Free:284233728, UsedPercent:84.508194%
    {"total":3179569152,"available":492572672,"used":2895335424,"usedPercent":84.50819439828305, (snip...)}

You can set an alternative location to `/proc` by setting the `HOST_PROC`
environment variable.

You can set an alternative location to `/sys` by setting the `HOST_SYS`
environment variable.

You can set an alternative location to `/etc` by setting the `HOST_ETC`
environment variable.

You can set an alternative location to `/var` by setting the `HOST_VAR`
environment variable.

You can set an alternative location to `/run` by setting the `HOST_RUN`
environment variable.

You can set an alternative location to `/dev` by setting the `HOST_DEV`
environment variable.

You can set an alternative location to `/` by setting the `HOST_ROOT`
environment variable.

You can set an alternative location to `/proc/N/mountinfo` by setting the
`HOST_PROC_MOUNTINFO` environment variable.

### Adding settings using `context` (from v3.23.6)

As of v3.23.6, it is now possible to pass a path location using `context`: import `"github.com/shirou/gopsutil/v3/common"` and pass a context with `common.EnvMap` set to `common.EnvKey`, and the location will be used within each function.

```
	ctx := context.WithValue(context.Background(), 
		common.EnvKey, common.EnvMap{common.HostProcEnvKey: "/myproc"},
	)
	v, err := mem.VirtualMemoryWithContext(ctx)
```

First priority is given to the value set in `context`, then the value from the environment variable, and finally the default location.

### Caching

As of v3.24.1, it is now possible to cached some values. These values default to false, not cached. 

Be very careful that enabling the cache may cause inconsistencies. For example, if you enable caching of boottime on Linux, be aware that unintended values may be returned if [the boottime is changed by NTP after booted](https://github.com/shirou/gopsutil/issues/1070#issuecomment-842512782).

- `host`
  - EnableBootTimeCache
- `process`
  - EnableBootTimeCache

### `Ex` struct (from v4.24.5)

gopsutil is designed to work across multiple platforms. However, there are differences in the information available on different platforms, such as memory information that exists on Linux but not on Windows.

As of v4.24.5, to access this platform-specific information, gopsutil provides functions named `Ex` within the package. Currently, these functions are available in the mem and sensor packages.

The Ex structs are specific to each platform. For example, on Linux, there is an `ExLinux` struct, which can be obtained using the `mem.NewExLinux()` function. On Windows, it's `mem.ExWindows()`. These Ex structs provide platform-specific information.

```
ex := NewExWindows()
v, err := ex.VirtualMemory()
if err != nil {
    panic(err)
}

fmt.Println(v.VirtualAvail)
fmt.Println(v.VirtualTotal)

// Output:
// 140731958648832
// 140737488224256
```

gopsutil aims to minimize platform differences by offering common functions. However, there are many requests to obtain unique information for each platform. The Ex structs are designed to meet those requests. Additional functionalities might be added in the future. The use of these structures makes it clear that the information they provide is specific to each platform, which is why they have been designed in this way.

## Documentation

See https://pkg.go.dev/github.com/shirou/gopsutil/v4 or https://godocs.io/github.com/shirou/gopsutil/v4

## Requirements

- go1.18 or above is required.

## More Info

Several methods have been added which are not present in psutil, but
will provide useful information.

- host/HostInfo() (linux)
  - Hostname
  - Uptime
  - Procs
  - OS (ex: "linux")
  - Platform (ex: "ubuntu", "arch")
  - PlatformFamily (ex: "debian")
  - PlatformVersion (ex: "Ubuntu 13.10")
  - VirtualizationSystem (ex: "LXC")
  - VirtualizationRole (ex: "guest"/"host")
- IOCounters
  - Label (linux only) The registered [device mapper
    name](https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-block-dm)
- cpu/CPUInfo() (linux, freebsd)
  - CPU (ex: 0, 1, ...)
  - VendorID (ex: "GenuineIntel")
  - Family
  - Model
  - Stepping
  - PhysicalID
  - CoreID
  - Cores (ex: 2)
  - ModelName (ex: "Intel(R) Core(TM) i7-2640M CPU @ 2.80GHz")
  - Mhz
  - CacheSize
  - Flags (ex: "fpu vme de pse tsc msr pae mce cx8 ...")
  - Microcode
- load/Avg() (linux, freebsd, solaris)
  - Load1
  - Load5
  - Load15
- docker/GetDockerIDList() (linux only)
  - container id list ([]string)
- docker/CgroupCPU() (linux only)
  - user
  - system
- docker/CgroupMem() (linux only)
  - various status
- net_protocols (linux only)
  - system wide stats on network protocols (i.e IP, TCP, UDP, etc.)
  - sourced from /proc/net/snmp
- iptables nf_conntrack (linux only)
  - system wide stats on netfilter conntrack module
  - sourced from /proc/sys/net/netfilter/nf_conntrack_count

Some code is ported from Ohai. Many thanks.

## Current Status

- x: works
- b: almost works, but something is broken
- c: works in CGO only

|name                  |Linux  |FreeBSD  |OpenBSD  |macOS   |Windows  |Solaris  |Plan 9   |AIX      |
|----------------------|-------|---------|---------|--------|---------|---------|---------|---------|
|cpu\_times            |x      |x        |x        |x       |x        |         |b        |x        |
|cpu\_count            |x      |x        |x        |x       |x        |         |x        |x        |
|cpu\_percent          |x      |x        |x        |x       |x        |         |         |x        |
|cpu\_times\_percent   |x      |x        |x        |x       |x        |         |         |x        |
|virtual\_memory       |x      |x        |x        |x       |x        | b       |x        |x        |
|swap\_memory          |x      |x        |x        |x       |         |         |x        |X        |
|disk\_partitions      |x      |x        |x        |x       |x        |         |         |x        |
|disk\_io\_counters    |x      |x        |x        |        |         |         |         |         |
|disk\_usage           |x      |x        |x        |x       |x        |         |         |x        |
|net\_io\_counters     |x      |x        |x        |b       |x        |         |         |         |
|boot\_time            |x      |x        |x        |x       |x        |         |         |X        |
|users                 |x      |x        |x        |x       |x        |         |         |x        |
|pids                  |x      |x        |x        |x       |x        |         |         |         |
|pid\_exists           |x      |x        |x        |x       |x        |         |         |         |
|net\_connections      |x      |x        |x        |x       |         |         |         |x        |
|net\_protocols        |x      |         |         |        |         |         |         |x        |
|net\_if\_addrs        |       |         |         |        |         |         |         |x        |
|net\_if\_stats        |       |         |         |        |         |         |         |x        |
|netfilter\_conntrack  |x      |         |         |        |         |         |         |         |


### Process class

|name                |Linux  |FreeBSD  |OpenBSD  |macOS  |Windows  |
|--------------------|-------|---------|---------|-------|---------|
|pid                 |x      |x        |x        |x      |x        |
|ppid                |x      |x        |x        |x      |x        |
|name                |x      |x        |x        |x      |x        |
|cmdline             |x      |x        |         |x      |x        |
|create\_time        |x      |         |         |x      |x        |
|status              |x      |x        |x        |x      |         |
|cwd                 |x      |         |         |x      |x        |
|exe                 |x      |x        |x        |       |x        |
|uids                |x      |x        |x        |x      |         |
|gids                |x      |x        |x        |x      |         |
|terminal            |x      |x        |x        |       |         |
|io\_counters        |x      |x        |x        |       |x        |
|nice                |x      |x        |x        |x      |x        |
|num\_fds            |x      |         |         |       |         |
|num\_ctx\_switches  |x      |         |         |       |         |
|num\_threads        |x      |x        |x        |x      |x        |
|cpu\_times          |x      |         |         |       |x        |
|memory\_info        |x      |x        |x        |x      |x        |
|memory\_info\_ex    |x      |         |         |       |         |
|memory\_maps        |x      |         |         |       |         |
|open\_files         |x      |         |         |       |         |
|send\_signal        |x      |x        |x        |x      |         |
|suspend             |x      |x        |x        |x      |         |
|resume              |x      |x        |x        |x      |         |
|terminate           |x      |x        |x        |x      |x        |
|kill                |x      |x        |x        |x      |         |
|username            |x      |x        |x        |x      |x        |
|ionice              |       |         |         |       |         |
|rlimit              |x      |         |         |       |         |
|num\_handlers       |       |         |         |       |         |
|threads             |x      |         |         |       |         |
|cpu\_percent        |x      |         |x        |x      |x        |
|cpu\_affinity       |       |         |         |       |         |
|memory\_percent     |x      |         |         |       |x        |
|parent              |x      |         |x        |x      |x        |
|children            |x      |x        |x        |x      |x        |
|connections         |x      |         |x        |x      |         |
|is\_running         |       |         |         |       |         |
|page\_faults        |x      |         |         |       |         |

### Original Metrics

|item             |Linux  |FreeBSD  |OpenBSD  |macOS   |Windows |Solaris  |AIX      |
|-----------------|-------|---------|---------|--------|--------|---------|---------|
|**HostInfo**     |       |         |         |        |        |         |         |
|hostname         |x      |x        |x        |x       |x       |x        |X        |
|uptime           |x      |x        |x        |x       |        |x        |x        |
|process          |x      |x        |x        |        |        |x        |         |
|os               |x      |x        |x        |x       |x       |x        |x        |
|platform         |x      |x        |x        |x       |        |x        |x        |
|platformfamily   |x      |x        |x        |x       |        |x        |x        |
|virtualization   |x      |         |         |        |        |         |         |
|**CPU**          |       |         |         |        |        |         |         |
|VendorID         |x      |x        |x        |x       |x       |x        |x        |
|Family           |x      |x        |x        |x       |x       |x        |x        |
|Model            |x      |x        |x        |x       |x       |x        |x        |
|Stepping         |x      |x        |x        |x       |x       |x        |         |
|PhysicalID       |x      |         |         |        |        |x        |         |
|CoreID           |x      |         |         |        |        |x        |         |
|Cores            |x      |         |         |        |x       |x        |x        |
|ModelName        |x      |x        |x        |x       |x       |x        |x        |
|Microcode        |x      |         |         |        |        |x        |         |
|**LoadAvg**      |       |         |         |        |        |         |         |
|Load1            |x      |x        |x        |x       |        |         |x        |
|Load5            |x      |x        |x        |x       |        |         |x        |
|Load15           |x      |x        |x        |x       |        |         |x        |
|**GetDockerID**  |       |         |         |        |        |         |         |
|container id     |x      |no       |no       |no      |no      |         |         |
|**CgroupsCPU**   |       |         |         |        |        |         |         |
|user             |x      |no       |no       |no      |no      |         |         |
|system           |x      |no       |no       |no      |no      |         |         |
|**CgroupsMem**   |       |         |         |        |        |         |         |
|various          |x      |no       |no       |no      |no      |         |         |

- future work
  - process_iter
  - wait_procs
  - Process class
    - as_dict
    - wait
  - AIX processes

## License

New BSD License (same as psutil)

## Related Works

I have been influenced by the following great works:

- psutil: https://github.com/giampaolo/psutil
- dstat: https://github.com/dagwieers/dstat
- gosigar: https://github.com/cloudfoundry/gosigar/
- goprocinfo: https://github.com/c9s/goprocinfo
- go-ps: https://github.com/mitchellh/go-ps
- ohai: https://github.com/opscode/ohai/
- bosun:
  https://github.com/bosun-monitor/bosun/tree/master/cmd/scollector/collectors
- mackerel:
  https://github.com/mackerelio/mackerel-agent/tree/master/metrics

## How to Contribute

1.  Fork it
2.  Create your feature branch (git checkout -b my-new-feature)
3.  Commit your changes (git commit -am 'Add some feature')
4.  Push to the branch (git push origin my-new-feature)
5.  Create new Pull Request

English is not my native language, so PRs correcting grammar or spelling are welcome and appreciated.


gopsutil

Provide Go Statistics Handler, Struct, Measure Method.

# Go Statistics Handler

[![GitHub Actions](https://github.com/osamingo/gosh/workflows/CI/badge.svg?branch=master)](https://github.com/osamingo/gosh/actions?query=workflow%3ACI+branch%3Amaster)
[![codecov](https://codecov.io/gh/osamingo/gosh/branch/master/graph/badge.svg)](https://codecov.io/gh/osamingo/gosh)
[![Go Report Card](https://goreportcard.com/badge/github.com/osamingo/gosh)](https://goreportcard.com/report/github.com/osamingo/gosh)
[![GoDoc](https://godoc.org/github.com/osamingo/gosh?status.svg)](https://godoc.org/github.com/osamingo/gosh)
[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/osamingo/gosh/master/LICENSE)

## About

- The `gosh` is an abbreviation for Go Statistics Handler.
- This Repository is provided following functions.
  - Go runtime statistics struct.
  - Go runtime statistics API handler.
  - Go runtime measure method.
- You can specify the favorite JSON encoder.
  - [`encoding/json`](https://pkg.go.dev/encoding/json/) package.
  - [`goccy/go-json`](https://pkg.go.dev/github.com/goccy/go-json) package.
  - The original package you created, and so on.

## Install

```bash
$ go get github.com/osamingo/gosh@latest
```

## Usage

### Example

```go
package main

import (
	"encoding/json"
	"io"
	"log"
	"net/http"

	"github.com/osamingo/gosh"
)

func main() {

	h, err := gosh.NewStatisticsHandler(func(w io.Writer) gosh.JSONEncoder {
		return json.NewEncoder(w)
	})
	if err != nil {
		log.Fatalln(err)
	}

	mux := http.NewServeMux()
	mux.Handle("/healthz", h)

	if err := http.ListenAndServe(":8080", mux); err != nil {
		log.Fatalln(err)
	}
}
```

### Output

```bash
$ curl "localhost:8080/healthz" | jq .
{
  "timestamp": 1527317620,
  "go_version": "go1.10.2",
  "go_os": "darwin",
  "go_arch": "amd64",
  "cpu_num": 8,
  "goroutine_num": 6,
  "gomaxprocs": 8,
  "cgo_call_num": 1,
  "memory_alloc": 422272,
  "memory_total_alloc": 422272,
  "memory_sys": 3084288,
  "memory_lookups": 6,
  "memory_mallocs": 4720,
  "memory_frees": 71,
  "stack_inuse": 491520,
  "heap_alloc": 422272,
  "heap_sys": 1605632,
  "heap_idle": 401408,
  "heap_inuse": 1204224,
  "heap_released": 0,
  "heap_objects": 4649,
  "gc_next": 4473924,
  "gc_last": 0,
  "gc_num": 0,
  "gc_per_second": 0,
  "gc_pause_per_second": 0,
  "gc_pause": []
}
```


## License

Released under the [MIT License](https://github.com/osamingo/gosh/blob/master/LICENSE).


gosh

Your own local SMS gateway in Go that can be used to send SMS.

gosms
-----

Your own local SMS gateway
==========================

What's the use ?
----------------
Can be used to send SMS,
where you don't have access to internet or cannot use Web SMS gateways
or want to save some money per SMS,
or have minimal requirements for personal / internal use and such

- deploy in less than 1 minute
- supports Windows, GNU\Linux, Mac OS
- works with GSM modems
- provides API over HTTP to push messages to gateway, just like the internet based gateways do
- takes care of queuing, throttling and retrying
- supports multiple devices at once

![gosms dashboard](https://raw.githubusercontent.com/haxpax/gosms/screenshot/screenshots/gosms.png)

deployment
----------
- Update conf.ini `[DEVICES]` section with your modem's COM port.
  for ex. `COM10` or `/dev/USBtty2`
- Run

API specification
------------------
- /api/sms/ [*POST*]
    - param **mobile**
        - mobile number to send message to
        - number should have contry code prefix
        - for ex. +919890098900
    - param **message**
        - message text
        - max length is limited to 160 characters
    - response
```json
{
  "status": 200,
  "message": "ok"
}
```
- /api/logs/ [*GET*]
    - response
```json
{
  "status": 200,
  "message": "ok",
  "summary": [ 10, 50, 2 ],
  "daycount": { "2015-01-22": 10, "2015-01-23": 25 },
  "messages": [
    {
      "uuid": "d04f17c4-a32c-11e4-827f-00ffcf62442b",
      "mobile": "+1858111222",
      "body": "Hey! Just playing around with gosms.",
      "status": 1
    },
  ]
}
```
    - message status codes
      - 0 : Pending
      - 1 : Processed
      - 2 : Error

planned features
-------
- Allowing multiple mobile numbers with a single message in `/api/sms/`
- CRUD support for messages, possibly support cancellation of message
- Authentication support for API
- Adding authentication for Dashboard
- Send an email to admin on high failure rate

building from source
---------------------


On Ubuntu
- go get github.com/haxpax/gosms
- cd $GOPATH/src/github.com/haxpax/gosms/dashboard
- go get
- go build

On Windows
- Setup GCC for go-sqlite3 package
    - For 32 bit
        - Download MinGW from http://sourceforge.net/projects/mingw/
        - Add `C:\MinGW\bin` to PATH
        - run `mingw-get install gcc` from command line
    - For 64 bit
        - Download minigw from here : [sourcceforge](http://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/installer/mingw-w64-install.exe/download)
	- Install
	- Add its bin dir to path, typically `C:\Program Files\mingw-w64\x86_64-4.9.2-posix-seh-rt_v3-rev1\mingw64\bin`

- go get `github.com/haxpax/gosms`
- cd $GOPATH/src/github.com/haxpax/gosms/dashboard
- go get
- go build

run dashboard executable. Copy assets, templates, conf.ini, dashboard[.exe] if you want to move to another directory db.sqlite is created at first run if not present, copy that too if its there




gosms

Type-safe metrics builder wrapper library for the official Prometheus client.

# gotoprom
## A Prometheus metrics builder

[![Build Status](https://travis-ci.org/cabify/gotoprom.svg?branch=master)](https://travis-ci.org/cabify/gotoprom)
[![Coverage Status](https://coveralls.io/repos/github/cabify/gotoprom/badge.svg)](https://coveralls.io/github/cabify/gotoprom)
[![GoDoc](https://godoc.org/github.com/cabify/gotoprom?status.svg)](https://godoc.org/github.com/cabify/gotoprom)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)  

`gotoprom` offers an easy to use declarative API with type-safe labels for building and using Prometheus metrics.
It doesn't replace the [official Prometheus client](https://github.com/prometheus/client_golang)
but adds a wrapper on top of it.

`gotoprom` is built for developers who like type safety, navigating the code using IDEs and using a “find usages”
functionality, making refactoring and debugging easier at the cost of performance and writing slightly more verbose code.


## Motivation

Main motivation for this library was to have type-safety on the Prometheus labels, which are
just a `map[string]string` in the original library, and their values can be reported even
without mentioning the label name, just relying on the order they were declared in.

For example, it replaces:
```go
httpReqs := prometheus.NewCounterVec(
    prometheus.CounterOpts{
        Name: "http_requests_total",
        Help: "How many HTTP requests processed, partitioned by status code and HTTP method.",
    },
    []string{"code", "method"},
)
prometheus.MustRegister(httpReqs)

// ...

httpReqs.WithLabelValues("404", "POST").Add(42)
```

With:
```go
var metrics = struct{
	Reqs func(labels) prometheus.Counter `name:"requests_total" help:"How many HTTP requests processed, partitioned by status code and HTTP method."`
}

type labels struct {
	Code   int    `label:"code"`
	Method string `label:"method"`
}

gotoprom.MustInit(&metrics, "http")

// ...

metrics.Reqs(labels{Code: 404, Method: "POST"}).Inc()
```

This way it's impossible to mess the call by exchanging the order of `"POST"` & `"404"` params.


## Usage

Define your metrics:

```go
var metrics struct {
	SomeCounter                      func() prometheus.Counter   `name:"some_counter" help:"some counter"`
	SomeHistogram                    func() prometheus.Histogram `name:"some_histogram" help:"Some histogram with default prometheus buckets" buckets:""`
	SomeHistogramWithSpecificBuckets func() prometheus.Histogram `name:"some_histogram_with_buckets" help:"Some histogram with custom buckets" buckets:".01,.05,.1"`
	SomeGauge                        func() prometheus.Gauge     `name:"some_gauge" help:"Some gauge"`
	SomeSummaryWithSpecificMaxAge    func() prometheus.Summary   `name:"some_summary_with_specific_max_age" help:"Some summary with custom max age" max_age:"20m" objectives:"0.50,0.95,0.99"`

	Requests struct {
		Total func(requestLabels) prometheus.Count `name:"total" help:"Total amount of requests served"`
	} `namespace:"requests"`
}

type requestLabels struct {
	Service    string `label:"service"`
	StatusCode int    `label:"status"`
	Success    bool   `label:"success"`
}
```

Initialize them:

```go
func init() {
	gotoprom.MustInit(&metrics, "namespace")
}
```

Measure stuff:

```go
metrics.SomeGauge().Set(100)
metrics.Requests.Total(requestLabels{Service: "google", StatusCode: 404, Success: false}).Inc()
```


## Custom metric types

By default, only some basic metric types are registered when `gotoprom` is intialized:
* `prometheus.Counter`
* `prometheus.Histogram`
* `prometheus.Gauge`
* `prometheus.Summary`

You can extend this by adding more types, for instance, if you want to observe time and want
to avoid repetitive code you can create a `prometheusx.TimeHistogram`:
```go
package prometheusx

import (
	"reflect"
	"time"

	"github.com/cabify/gotoprom"
	"github.com/cabify/gotoprom/prometheusvanilla"
	"github.com/prometheus/client_golang/prometheus"
)

var (
	// TimeHistogramType is the reflect.Type of the TimeHistogram interface
	TimeHistogramType = reflect.TypeOf((*TimeHistogram)(nil)).Elem()
)

func init() {
	gotoprom.MustAddBuilder(TimeHistogramType, RegisterTimeHistogram)
}

// RegisterTimeHistogram registers a TimeHistogram after registering the underlying prometheus.Histogram in the prometheus.Registerer provided
// The function it returns returns a TimeHistogram type as an interface{}
func RegisterTimeHistogram(name, help, namespace string, labelNames []string, tag reflect.StructTag) (func(prometheus.Labels) interface{}, prometheus.Collector, error) {
	f, collector, err := prometheusvanilla.BuildHistogram(name, help, namespace, labelNames, tag)
	if err != nil {
		return nil, nil, err
	}

	return func(labels prometheus.Labels) interface{} {
		return timeHistogramAdapter{Histogram: f(labels).(prometheus.Histogram)}
	}, collector, nil
}

// TimeHistogram offers the basic prometheus.Histogram functionality
// with additional time-observing functions
type TimeHistogram interface {
	prometheus.Histogram
	// Duration observes the duration in seconds
	Duration(duration time.Duration)
	// Since observes the duration in seconds since the time point provided
	Since(time.Time)
}

type timeHistogramAdapter struct {
	prometheus.Histogram
}

// Duration observes the duration in seconds
func (to timeHistogramAdapter) Duration(duration time.Duration) {
	to.Observe(duration.Seconds())
}

// Since observes the duration in seconds since the time point provided
func (to timeHistogramAdapter) Since(duration time.Time) {
	to.Duration(time.Since(duration))
}
```

So you can later define it as:

```go
var metrics struct {
	DurationSeconds func() prometheusx.TimeHistogram `name:"duration_seconds" help:"Duration in seconds" buckets:".001,.005,.01,.025,.05,.1"`
}

func init() {
	gotoprom.MustInit(&metrics, "requests")
}
```

And use it as:

```go
// ...
defer metrics.DurationSeconds().Since(t0)
// ...
```


### Replacing metric builders
If you don't like the default metric builders, you can replace the `DefaultInitializer` with your own one.


## Performance

Obviously, there's a performance cost to perform the type-safety mapping magic to the original
Prometheus client's API.

In general terms, it takes 3x to increment a counter than with vanilla Prometheus, which is
around 600ns (we're talking about a portion of a microsecond, less than a thousandth of a millisecond)

```
$ go test -bench . -benchtime 3s
goos: darwin
goarch: amd64
pkg: github.com/cabify/gotoprom
BenchmarkVanilla-4    	10000000	       387 ns/op
BenchmarkGotoprom-4   	 5000000	      1049 ns/op
PASS
ok  	github.com/cabify/gotoprom	10.611s
```

In terms of memory, there's a also a 33% increase in terms of space, and 3x increase in allocations:

```
$ go test -bench . -benchmem
goos: darwin
goarch: amd64
pkg: github.com/cabify/gotoprom
BenchmarkVanilla-4    	 5000000	       381 ns/op	     336 B/op	       2 allocs/op
BenchmarkGotoprom-4   	 1000000	      1030 ns/op	     432 B/op	       6 allocs/op
PASS
ok  	github.com/cabify/gotoprom	3.369s
```

This costs are probably assumable in most of the applications, especially when measuring
network accesses, etc. which are magnitudes higher.


gotoprom

Package that exposes country and subdivision data.

# gountries

[![wercker status](https://app.wercker.com/status/909d6a059d7d0b49b74ec8b658f97df4/s/master "wercker status")](https://app.wercker.com/project/bykey/909d6a059d7d0b49b74ec8b658f97df4) [![codecov.io](https://codecov.io/github/pariz/gountries/coverage.svg?branch=master)](https://codecov.io/github/pariz/gountries?branch=master) [![Go Report Card](https://goreportcard.com/badge/pariz/gountries)](https://goreportcard.com/report/pariz/gountries)

Inspired by the [countries](https://github.com/hexorx/countries) gem for ruby.

Countries (ISO-3166-1), Country Subdivisions(ISO-3166-2), Currencies (ISO 4217), Geo Coordinates(ISO-6709) as well as translations, country borders and other stuff exposed as struct data.

All data is derived from the [pariz/countries](https://github.com/pariz/countries) repo.

*This is currently a work in progress, so things may change. More stuff will be added*

# Installation

```
go get github.com/pariz/gountries
```

# Examples


## Basic
```go
package main

import (
	"fmt"
	"github.com/pariz/gountries"
)

func main() {
	query := gountries.New()

	/////////////////
	// Find sweden //
	/////////////////

	sweden, _ := query.FindCountryByName("sweden")
	// sweden, _ := query.FindCountryByAlpha("SE")
	// sweden, _ := query.FindCountryByAlpha("SWE")

	fmt.Println(sweden.Name.Common)   // Output: Sweden
	fmt.Println(sweden.Name.Official) // Output: Konungariket Sverige

	fmt.Println(sweden.Translations["DEU"].Common)   // Output: Schweden
	fmt.Println(sweden.Translations["DEU"].Official) // Output: Königreich Schweden
}

```
## A bit more advanced
```go
package main

import (
	"fmt"
	"github.com/pariz/gountries"
)

func main() {

	query := gountries.New()

	////////////////////////////////////////////
	// Find the bordering countries of Sweden //
	////////////////////////////////////////////

	sweden, _ := query.FindCountryByAlpha("SWE") // "SE" also works..

	// Get the bordering countries of sweden
	for _, country := range sweden.BorderingCountries() {
		fmt.Println(country.Name.Common)
	}

	// Output:
	// Finland
	// Norway

	////////////////////////////////////
	// Find all subdivisons for Sweden //
	////////////////////////////////////

	subdivisions := sweden.SubDivisions()

	for _, subdivision := range subdivisions {
		fmt.Println(subdivision.Name)
	}

	// Output:
	// Västerbottens län
	// Uppsala län
	// Södermanlands län
	// Gotlands län
	// Dalarnas län
	// ...

	//////////////////////////////////////////////////////////
	// Find all countries bordering Germany and Switzerland //
	//////////////////////////////////////////////////////////

	countryQuery := gountries.Country{
		Borders: []string{
			"DEU",
			"CHE",
		},
	}

	countries := query.FindCountries(countryQuery)

	for _, c := range countries {
		fmt.Println(c.Name.Common)
	}

	// Output:
	// Austria
	// France

	///////////////////////////////////////////////////////////////////
	// Calculate distance between Sweden and Germany (in Kilometers) //
	///////////////////////////////////////////////////////////////////

	se, _ := query.FindCountryByAlpha("SWE")
	de, _ := query.FindCountryByAlpha("DEU")

	distance := gountries.MeasureDistanceHaversine(se, de)
	//distance := MeasureDistancePythagoras(se, de)

	fmt.Println(distance)

	// Output:
	// 1430.1937864547901

	distance = gountries.CalculateHaversine(
		se.Coordinates.MaxLatitude, se.Coordinates.MaxLongitude,
		de.Coordinates.MinLatitude, de.Coordinates.MinLongitude)

	fmt.Println(distance)

	// Output:
	// 2641.26145088825
}

```

# Using packed data

The data in the `data/yaml` subdirectory is embedded using go-bindata.  Once you include this library in your project, you won't need to access the data directory.  To add or update the data, make changes to the YAML files then run:

```
go-bindata -pkg gountries data/yaml/*
```

# Testing

Has a pretty solid test coverage but is constantly improving.

# Todo
- [ ] Province/County querying (partially complete)
- [x] Measurement between coordinates
- [ ] GeoJSON information
- [ ] Suggestions?


gountries

Easy to use, extensible health check library.

[![Build Status](https://travis-ci.org/dimiro1/health.svg?branch=master)](https://travis-ci.org/dimiro1/health)
[![Go Report Card](https://goreportcard.com/badge/github.com/dimiro1/health)](https://goreportcard.com/report/github.com/dimiro1/health)
[![GoDoc](https://godoc.org/github.com/dimiro1/health?status.svg)](https://godoc.org/github.com/dimiro1/health)

Try browsing [the code on Sourcegraph](https://sourcegraph.com/github.com/dimiro1/health)!

# Go Health Check

An easy to use, extensible health check library for Go applications.

# New package

Use `https://github.com/dimiro1/healthz` for a basic health check implementation.

**Table of Contents**

- [Example](#example)
- [Motivation](#motivation)
- [Inspiration](#inspiration)
- [Installation](#Installation)
- [API](#api)
- [Testing](#testing)
- [Implementing custom checkers](#implementing-custom-checkers)
- [Implemented health check indicators](#implemented-health-check-indicators)
- [LICENSE](#license)

# Example

```go
package main

import (
    "net/http"
    "database/sql"
    "time"

    "github.com/dimiro1/health"
    "github.com/dimiro1/health/url"
    "github.com/dimiro1/health/db"
    "github.com/dimiro1/health/redis"
    _ "github.com/go-sql-driver/mysql"
)

func main() {
    database, _ := sql.Open("mysql", "/")
	mysql := db.NewMySQLChecker(database)
    timeout := 5 * time.Second
    
    companies := health.NewCompositeChecker()
    companies.AddChecker("Microsoft", url.NewChecker("https://www.microsoft.com/"))
    companies.AddChecker("Oracle", url.NewChecker("https://www.oracle.com/"))
    companies.AddChecker("Google", url.NewChecker("https://www.google.com/"))

    handler := health.NewHandler()
    handler.AddChecker("Go", url.NewCheckerWithTimeout("https://golang.org/", timeout))
    handler.AddChecker("Big Companies", companies)
    handler.AddChecker("MySQL", mysql)
    handler.AddChecker("Redis", redis.NewChecker("tcp", ":6379"))

    http.Handle("/health/", handler)
    http.ListenAndServe(":8080", nil)
}
```

```sh
$ curl localhost:8080/health/
```

If everything is ok the server must respond with HTTP Status 200 OK and have following json in the body.

```json
{
    "Big Companies": {
        "Google": {
            "code": 200,
            "status": "UP"
        },
        "Microsoft": {
            "code": 200,
            "status": "UP"
        },
        "Oracle": {
            "code": 200,
            "status": "UP"
        },
        "status": "UP"
    },
    "Go": {
        "code": 200,
        "status": "UP"
    },
    "MySQL": {
        "status": "UP",
        "version": "10.1.9-MariaDB"
    },
    "Redis": {
        "status": "UP",
        "version": "3.0.5"
    },
    "status": "UP"
}
```

The server responds with HTTP Status 503 Service Unavailable if the ckeck is Down and the json response could be something like this.

```json
{
    "Big Companies": {
        "Google": {
            "code": 200,
            "status": "UP"
        },
        "Microsoft": {
            "code": 200,
            "status": "UP"
        },
        "Oracle": {
            "code": 200,
            "status": "UP"
        },
        "status": "UP"
    },
    "Go": {
        "code": 200,
        "status": "UP"
    },
    "MySQL": {
        "status": "DOWN",
        "error": "Error 1044: Access denied for user ''@'localhost' to database 'invalid-database'",
    },
    "Redis": {
        "status": "UP",
        "version": "3.0.5"
    },
    "status": "DOWN"
}
```

# Motivation

It is very important to verify the status of your system, not only the system itself, but all its dependencies, 
If your system is not Up you can easily know what is the cause of the problem only looking the health check.

Also it serves as a kind of basic integration test between the systems.

# Inspiration

I took a lot of ideas from the [spring framework](http://spring.io/).

# Installation

This package is a go getable package.

```sh
$ go get github.com/dimiro1/health
```

# API

The API is stable and I do not have any plans to break compatibility, but I recommend you to vendor this dependency in your project, as it is a good practice.

# Testing

You have to install the test dependencies.

```sh
$ go get gopkg.in/DATA-DOG/go-sqlmock.v1
$ go get github.com/rafaeljusto/redigomock
```

or you can go get this package with the -t flag

```sh
go get -t github.com/dimiro1/health
```

# Implementing custom checkers

The key interface is `health.Checker`, you only have to implement a type that satisfies that interface.

```go
type Checker interface {
	Check() Health
}
```

Here is an example of Disk Space usage (unix only).

```go
package main

import (
    "syscall"
    "os"
)

type DiskSpaceChecker struct {
	Dir       string
	Threshold uint64
}

func NewDiskSpaceChecker(dir string, threshold uint64) DiskSpaceChecker {
	return DiskSpaceChecker{Dir: dir, Threshold: threshold}
}

func (d DiskSpaceChecker) Check() health.Health {
	health := health.NewHealth()

	var stat syscall.Statfs_t

	wd, err := os.Getwd()

	if err != nil {
        health.Down().AddInfo("error", err.Error()) // Why the check is Down
        return health
	}

	syscall.Statfs(wd, &stat)

	diskFreeInBytes := stat.Bavail * uint64(stat.Bsize)

	if diskFreeInBytes < d.Threshold {
		health.Down()
	} else {
        health.Up()
    }

    health.
        AddInfo("free", diskFreeInBytes).
        AddInfo("threshold", d.Threshold)

	return health
}
```

## Important

The **status** key in the json has priority over a **status** key added by a Checker, so if some checker adds a **status** key to the json, it will not be rendered  

# Implemented health check indicators

| Health         | Description                            | Package                                              |
|----------------|----------------------------------------|------------------------------------------------------|
| url.Checker    | Check the connection with some URL     | https://github.com/dimiro1/health/tree/master/url    |
| db.Checker     | Check the connection with the database | https://github.com/dimiro1/health/tree/master/db     |
| redis.Checker  | Check the connection with the redis    | https://github.com/dimiro1/health/tree/master/redis  |

# LICENSE

The MIT License (MIT)

Copyright (c) 2016 Claudemiro

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.


An opinionated and concurrent health-check HTTP handler for RESTful services.

<img src="logo.png" width="500" align="top"/>

# Healthcheck

[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)  

[![Build Status](https://travis-ci.com/etherlabsio/healthcheck.svg)](https://travis-ci.com/etherlabsio/healthcheck) [![Go Report Card](https://goreportcard.com/badge/github.com/etherlabsio/healthcheck)](https://goreportcard.com/report/github.com/etherlabsio/healthcheck) [![GoDoc](https://godoc.org/github.com/etherlabsio/healthcheck?status.svg)](https://godoc.org/github.com/etherlabsio/healthcheck) [![codecov](https://codecov.io/gh/etherlabsio/healthcheck/branch/master/graph/badge.svg)](https://codecov.io/gh/etherlabsio/healthcheck) [![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fetherlabsio%2Fhealthcheck.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fetherlabsio%2Fhealthcheck?ref=badge_shield)

A simple and extensible RESTful Healthcheck API implementation for Go services.

Health provides an `http.Handlefunc` for use as a healthcheck endpoint used by external services or load balancers. The function is used to determine the health of the application and to remove unhealthy application hosts or containers from rotation.

Instead of blindly returning a `200` HTTP status code, a healthcheck endpoint should test all the mandatory dependencies that are essential for proper functioning of a web service.

Implementing the `Checker` interface and passing it on to healthcheck allows you to test the the dependencies such as a database connection, caches, files and even external services you rely on. You may choose to not fail the healthcheck on failure of certain dependencies such as external services that you are not always dependent on.

## Example

```GO
package main

import (
    "context"
    "database/sql"
    "net/http"
    "time"

    "github.com/etherlabsio/healthcheck/v2"
    "github.com/etherlabsio/healthcheck/v2/checkers"
    _ "github.com/go-sql-driver/mysql"
    "github.com/gorilla/mux"
)

func main() {
    // For brevity, error check is being omitted here.
    db, _ := sql.Open("mysql", "user:password@/dbname")
    defer db.Close()

    r := mux.NewRouter()
    r.Handle("/healthcheck", healthcheck.Handler(

        // WithTimeout allows you to set a max overall timeout.
        healthcheck.WithTimeout(5*time.Second),

        // Checkers fail the status in case of any error.
        healthcheck.WithChecker(
            "heartbeat", checkers.Heartbeat("$PROJECT_PATH/heartbeat"),
        ),

        healthcheck.WithChecker(
            "database", healthcheck.CheckerFunc(
                func(ctx context.Context) error {
                    return db.PingContext(ctx)
                },
            ),
        ),

        // Observers do not fail the status in case of error.
        healthcheck.WithObserver(
            "diskspace", checkers.DiskSpace("/var/log", 90),
        ),
    ))

    http.ListenAndServe(":8080", r)
}
```

Based on the example provided above, `curl localhost:8080/healthcheck | jq` should yield on error a response with an HTTP statusCode of `503`.

```JSON
{
  "status": "Service Unavailable",
  "errors": {
    "database": "dial tcp 127.0.0.1:3306: getsockopt: connection refused",
    "heartbeat": "heartbeat not found. application should be out of rotation"
  }
}
```

## License

This project is licensed under the terms of the MIT license. See the [LICENSE](LICENSE) file.


[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fetherlabsio%2Fhealthcheck.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fetherlabsio%2Fhealthcheck?ref=badge_large)


healthcheck

A golang library for packing and unpacking FQDNs list.

hostutils

Library for interacting with LLVM IR in pure Go.

# llvm

[![Build Status](https://github.com/llir/llvm/workflows/Go/badge.svg?branch=master)](https://github.com/llir/llvm/actions/workflows/go.yml)
[![Coverage Status](https://coveralls.io/repos/github/llir/llvm/badge.svg?branch=master)](https://coveralls.io/github/llir/llvm?branch=master)
[![Go Report Card](https://goreportcard.com/badge/github.com/llir/llvm)](https://goreportcard.com/report/github.com/llir/llvm)
[![go.dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/github.com/llir/llvm)

Library for interacting with [LLVM IR](http://llvm.org/docs/LangRef.html) in pure Go.

## Introduction

* [Introductory blog post "LLVM IR and Go"](https://blog.gopheracademy.com/advent-2018/llvm-ir-and-go/)
* [Our Document](https://llir.github.io/document/)

## Installation

```bash
go get github.com/llir/llvm/...
```

## Versions

Map between `llir/llvm` tagged releases and LLVM release versions.

* [llir/llvm v0.3.7](https://github.com/llir/llvm/tree/v0.3.7): LLVM 15.0 (yet to be released)
* [llir/llvm v0.3.6](https://github.com/llir/llvm/tree/v0.3.6): LLVM 14.0
* [llir/llvm v0.3.5](https://github.com/llir/llvm/tree/v0.3.5): LLVM 13.0
* [llir/llvm v0.3.4](https://github.com/llir/llvm/tree/v0.3.4): LLVM 12.0
* [llir/llvm v0.3.3](https://github.com/llir/llvm/tree/v0.3.3): LLVM 11.0
* [llir/llvm v0.3.2](https://github.com/llir/llvm/tree/v0.3.2): LLVM 10.0
* [llir/llvm v0.3.0](https://github.com/llir/llvm/tree/v0.3.0): LLVM 9.0

## Users

* [decomp](https://github.com/decomp/decomp): LLVM IR to Go decompiler by [@decomp](https://github.com/decomp).
* [geode](https://github.com/geode-lang/geode): Geode to LLVM IR compiler by [@nickwanninger](https://github.com/nickwanninger).
* [leaven](https://github.com/andybalholm/leaven): LLVM IR to Go decompiler by [@andybalholm](https://github.com/andybalholm).
* [slate](https://github.com/nektro/slate): Slate to LLVM IR compiler by [@nektro](https://github.com/nektro).
* [tre](https://github.com/zegl/tre): Go to LLVM IR compiler by [@zegl](https://github.com/zegl).
* [uc](https://github.com/mewmew/uc): µC to LLVM IR compiler by [@sangisos](https://github.com/sangisos) and [@mewmew](https://github.com/mewmew).
* [B++](https://github.com/Nv7-Github/Bpp): B++ to LLVM IR compiler by [@Nv7-Github](https://github.com/Nv7-Github).

## Usage

### Input example, parsing LLVM IR assembly

[Example usage in GoDoc](https://pkg.go.dev/github.com/llir/llvm/asm#example-package).

```go
// This example parses an LLVM IR assembly file and pretty-prints the data types
// of the parsed module to standard output.
package main

import (
	"log"

	"github.com/kr/pretty"
	"github.com/llir/llvm/asm"
)

func main() {
	// Parse the LLVM IR assembly file `foo.ll`.
	m, err := asm.ParseFile("foo.ll")
	if err != nil {
		log.Fatalf("%+v", err)
	}
	// Pretty-print the data types of the parsed LLVM IR module.
	pretty.Println(m)
}
```

### Output examples, producing LLVM IR assembly

#### Hello, World

[Example usage in GoDoc](https://pkg.go.dev/github.com/llir/llvm/ir#example-package-Hello).

```go
// This example produces LLVM IR generating "Hello, World" output.

package main

import (
	"fmt"

	"github.com/llir/llvm/ir"
	"github.com/llir/llvm/ir/constant"
	"github.com/llir/llvm/ir/types"
)

func main() {
	// Create a new LLVM IR module.
	m := ir.NewModule()
	hello := constant.NewCharArrayFromString("Hello, world!\n\x00")
	str := m.NewGlobalDef("str", hello)
	// Add external function declaration of puts.
	puts := m.NewFunc("puts", types.I32, ir.NewParam("", types.NewPointer(types.I8)))
	main := m.NewFunc("main", types.I32)
	entry := main.NewBlock("")
	// Cast *[15]i8 to *i8.
	zero := constant.NewInt(types.I64, 0)
	gep := constant.NewGetElementPtr(hello.Typ, str, zero, zero)
	entry.NewCall(puts, gep)
	entry.NewRet(constant.NewInt(types.I32, 0))
	fmt.Println(m)
}
```

#### Pseudo Random-Number Generator

[Example usage in GoDoc](https://pkg.go.dev/github.com/llir/llvm/ir#example-package).

```go
// This example produces LLVM IR code equivalent to the following C code, which
// implements a pseudo-random number generator.
//
//    int abs(int x);
//
//    int seed = 0;
//
//    // ref: https://en.wikipedia.org/wiki/Linear_congruential_generator
//    //    a = 0x15A4E35
//    //    c = 1
//    int rand(void) {
//       seed = seed*0x15A4E35 + 1;
//       return abs(seed);
//    }
package main

import (
	"fmt"

	"github.com/llir/llvm/ir"
	"github.com/llir/llvm/ir/constant"
	"github.com/llir/llvm/ir/types"
)

func main() {
	// Create convenience types and constants.
	i32 := types.I32
	zero := constant.NewInt(i32, 0)
	a := constant.NewInt(i32, 0x15A4E35) // multiplier of the PRNG.
	c := constant.NewInt(i32, 1)         // increment of the PRNG.

	// Create a new LLVM IR module.
	m := ir.NewModule()

	// Create an external function declaration and append it to the module.
	//
	//    int abs(int x);
	abs := m.NewFunc("abs", i32, ir.NewParam("x", i32))

	// Create a global variable definition and append it to the module.
	//
	//    int seed = 0;
	seed := m.NewGlobalDef("seed", zero)

	// Create a function definition and append it to the module.
	//
	//    int rand(void) { ... }
	rand := m.NewFunc("rand", i32)

	// Create an unnamed entry basic block and append it to the `rand` function.
	entry := rand.NewBlock("")

	// Create instructions and append them to the entry basic block.
	tmp1 := entry.NewLoad(i32, seed)
	tmp2 := entry.NewMul(tmp1, a)
	tmp3 := entry.NewAdd(tmp2, c)
	entry.NewStore(tmp3, seed)
	tmp4 := entry.NewCall(abs, tmp3)
	entry.NewRet(tmp4)

	// Print the LLVM IR assembly of the module.
	fmt.Println(m)
}
```

### Analysis example, processing LLVM IR

[Example usage in GoDoc](https://pkg.go.dev/github.com/llir/llvm/ir#example-package-Callgraph).

```go
// This example program analyses an LLVM IR module to produce a callgraph in
// Graphviz DOT format.
package main

import (
	"fmt"
	"strings"

	"github.com/llir/llvm/asm"
	"github.com/llir/llvm/ir"
)

func main() {
	// Parse LLVM IR assembly file.
	m, err := asm.ParseFile("foo.ll")
	if err != nil {
		panic(err)
	}
	// Produce callgraph of module.
	callgraph := genCallgraph(m)
	// Output callgraph in Graphviz DOT format.
	fmt.Println(callgraph)
}

// genCallgraph returns the callgraph in Graphviz DOT format of the given LLVM
// IR module.
func genCallgraph(m *ir.Module) string {
	buf := &strings.Builder{}
	buf.WriteString("digraph {\n")
	// For each function of the module.
	for _, f := range m.Funcs {
		// Add caller node.
		caller := f.Ident()
		fmt.Fprintf(buf, "\t%q\n", caller)
		// For each basic block of the function.
		for _, block := range f.Blocks {
			// For each non-branching instruction of the basic block.
			for _, inst := range block.Insts {
				// Type switch on instruction to find call instructions.
				switch inst := inst.(type) {
				case *ir.InstCall:
					callee := inst.Callee.Ident()
					// Add edges from caller to callee.
					fmt.Fprintf(buf, "\t%q -> %q\n", caller, callee)
				}
			}
			// Terminator of basic block.
			switch term := block.Term.(type) {
			case *ir.TermRet:
				// do something.
				_ = term
			}
		}
	}
	buf.WriteString("}")
	return buf.String()
}
```

## License

The `llir/llvm` project is dual-licensed to the [public domain](UNLICENSE) and under a [zero-clause BSD license](LICENSE). You may choose either license to govern your use of `llir/llvm`.


llvm

# OpenAPI

[![build-img]][build-url]
[![pkg-img]][pkg-url]
[![reportcard-img]][reportcard-url]
[![coverage-img]][coverage-url]
[![version-img]][version-url]

OpenAPI specification object model

## Features
- Easy to integrate.

## Installation
```shell
go get github.com/neotoolkit/openapi
```

## Usage
```go
package main

import (
	"fmt"
	"io/ioutil"
	"log"

	"github.com/neotoolkit/openapi"
)

func main() {
	file, err := ioutil.ReadFile("openapi.yml")
	if err != nil {
		log.Fatalln(err)
	}

	oapi, err := openapi.Parse(file)
	if err != nil {
		log.Fatalln(err)
	}
	
	fmt.Println(oapi.OpenAPI)
}

```

## Documentation

See [these docs][pkg-url].

## License

[MIT License](LICENSE).

[build-img]: https://github.com/neotoolkit/openapi/workflows/build/badge.svg
[build-url]: https://github.com/neotoolkit/openapi/actions
[pkg-img]: https://pkg.go.dev/badge/neotoolkit/openapi
[pkg-url]: https://pkg.go.dev/github.com/neotoolkit/openapi
[reportcard-img]: https://goreportcard.com/badge/neotoolkit/openapi
[reportcard-url]: https://goreportcard.com/report/neotoolkit/openapi
[coverage-img]: https://codecov.io/gh/neotoolkit/openapi/branch/main/graph/badge.svg
[coverage-url]: https://codecov.io/gh/neotoolkit/openapi
[version-img]: https://img.shields.io/github/v/release/neotoolkit/openapi
[version-url]: https://github.com/neotoolkit/openapi/releases

## Sponsors
<p>
  <a href="https://evrone.com/?utm_source=github&utm_campaign=dotenv-linter">
    <img src="https://raw.githubusercontent.com/neotoolkit/.github/main/assets/sponsored_by_evrone.svg"
      alt="Sponsored by Evrone">
  </a>
</p>


openapi

HTTP service to generate PDF from Json requests.

# pdfgen
[![Build Status](https://travis-ci.org/hyperboloide/pdfgen.svg?branch=master)](https://travis-ci.org/hyperboloide/pdfgen)
[![Go Report Card](https://goreportcard.com/badge/github.com/hyperboloide/pdfgen)](https://goreportcard.com/report/github.com/hyperboloide/pdfgen)


HTTP service to generate PDF from Json requests

## Install and run

The recommended method is to use the docker container by mounting your template
directory (here with the provided example `template` directory):

```
docker run --rm -it -p 8888:8888 \
  --mount src=my_templates/,target=/etc/pdfgen/templates,type=bind \
  hyperboloide/pdfgen
```

If you rather not using Docker, you need to install [wkhtmltopdf](https://wkhtmltopdf.org/downloads.html)
first, then run:
```
go install github.com/hyperboloide/pdfgen
PDFGEN_TEMPLATES=./templates pdfgen
```

Once installed you can test with something like this:
```
curl -H "Content-Type: application/json" -X POST -d @my_json_file.json \
  http://localhost:8888/invoice > result.pdf
```

Note that the rendering may differ depending on your os (especially OSX) and installed fonts,
that's why it is recommended to test and develop on the Docker environment to
get the same result in production.

## Templates

The PDF are generated from HTML templates. These templates closely ressemble [Django Templates](https://docs.djangoproject.com/en/1.9/ref/templates/language/).

the following template:
```html
<h1>Hello, {{ user }}</h1>
```

can be generated with a `application/json` POST request:

```json
{"user": "fred"}
```

The response is of type `application/pdf` and contains the resulting PDF.

Each PDF template should be in it's own directory under the root directory
defined in the `PDFGEN_TEMPLATES` environment variable.

The urls endpoints will be generated from these directories names. For example a template
in the directory `invoice` will be a reachable at a url that look like that: `http://host:port/invoice`

The template directory must contain an `index.html` file and optionnaly
a `footer.html` file. Other assets like images and CSS should be in
that directory too.
Note that each PDF is generated in isolation and so
your templates should use absolutes paths.
For example if you use bower and have a path like that:
`invoices/bower_components/`
you should have:

```html
<link rel="stylesheet" href="/bower_components/bootstrap/dist/css/bootstrap.min.css" media='screen,print'>
```

Finally don't forget to set the `PDFGEN_TEMPLATES` env variable to the path of
your templates parent directory
Alternatively you copy your templates to either :
`/etc/pdfgen/templates` or `~/.templates`.

## Adding fonts

You could just create a new container with your fonts and rebuild the
cache. Bellow an example Dockerfile.

```
FROM hyperboloide/pdfgen
COPY my_fonts /usr/local/share/fonts/
RUN  fc-cache -f -v
```


pdfgen

A fluent library for creating state machines.

<p align="center"><img width="650" src="./assets/stateless.svg" alt="Stateless logo. Fire gopher designed by https://www.deviantart.com/quasilyte"></p>

<p align="center">
    <a href="https://pkg.go.dev/github.com/qmuntal/stateless?tab=doc"><img src="https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white" alt="go.dev"></a>
    <a href="https://github.com/qmuntal/stateless/actions/workflows/test.yml"><img src="https://github.com/qmuntal/stateless/actions/workflows/test.yml/badge.svg" alt="Build Status"></a>
    <a href="https://coveralls.io/github/qmuntal/stateless"><img src="https://coveralls.io/repos/github/qmuntal/stateless/badge.svg" alt="Code Coverage"></a>
    <a href="https://goreportcard.com/report/github.com/qmuntal/stateless"><img src="https://goreportcard.com/badge/github.com/qmuntal/stateless" alt="Go Report Card"></a>
    <a href="https://opensource.org/licenses/BSD-2-Clause"><img src="https://img.shields.io/badge/License-BSD%202--Clause-orange.svg" alt="Licenses"></a>
    <a href="https://github.com/avelino/awesome-go"><img src="https://awesome.re/mentioned-badge.svg" alt="Mentioned in Awesome Go"></a>
</p>

# Stateless

**Create *state machines* and lightweight *state machine-based workflows* directly in Go code:**

```go
phoneCall := stateless.NewStateMachine(stateOffHook)

phoneCall.Configure(stateOffHook).Permit(triggerCallDialed, stateRinging)

phoneCall.Configure(stateRinging).
  OnEntryFrom(triggerCallDialed, func(_ context.Context, args ...any) error {
    onDialed(args[0].(string))
    return nil
  }).
  Permit(triggerCallConnected, stateConnected)

phoneCall.Configure(stateConnected).
  OnEntry(func(_ context.Context, _ ...any) error {
    startCallTimer()
    return nil
  }).
  OnExit(func(_ context.Context, _ ...any) error {
    stopCallTimer()
    return nil
  }).
  Permit(triggerLeftMessage, stateOffHook).
  Permit(triggerPlacedOnHold, stateOnHold)

// ...

phoneCall.Fire(triggerCallDialed, "qmuntal")
```

This project, as well as the example above, is almost a direct, yet idiomatic, port of [dotnet-state-machine/stateless](https://github.com/dotnet-state-machine/stateless), which is written in C#.

The state machine implemented in this library is based on the theory of [UML statechart](https://en.wikipedia.org/wiki/UML_state_machine). The concepts behind it are about organizing the way a device, computer program, or other (often technical) process works such that an entity or each of its sub-entities is always in exactly one of a number of possible states and where there are well-defined conditional transitions between these states.

## Features

Most standard state machine constructs are supported:

* Support for states and triggers of any comparable type (int, strings, boolean, structs, etc.)
* Hierarchical states
* Entry/exit events for states
* Guard clauses to support conditional transitions
* Introspection

Some useful extensions are also provided:

* Ability to store state externally (for example, in a property tracked by an ORM)
* Parameterised triggers
* Reentrant states
* Thread-safe
* Export to DOT graph

### Hierarchical States

In the example below, the `OnHold` state is a substate of the `Connected` state. This means that an `OnHold` call is still connected.

```go
phoneCall.Configure(stateOnHold).
  SubstateOf(stateConnected).
  Permit(triggerTakenOffHold, stateConnected).
  Permit(triggerPhoneHurledAgainstWall, statePhoneDestroyed)
```

In addition to the `StateMachine.State` property, which will report the precise current state, an `IsInState(State)` method is provided. `IsInState(State)` will take substates into account, so that if the example above was in the `OnHold` state, `IsInState(State.Connected)` would also evaluate to `true`.

### Entry/Exit Events

In the example, the `StartCallTimer()` method will be executed when a call is connected. The `StopCallTimer()` will be executed when call completes (by either hanging up or hurling the phone against the wall.)

The call can move between the `Connected` and `OnHold` states without the `StartCallTimer()` and `StopCallTimer()` methods being called repeatedly because the `OnHold` state is a substate of the `Connected` state.

Entry/Exit event handlers can be supplied with a parameter of type `Transition` that describes the trigger, source and destination states.

### Initial state transitions

A substate can be marked as initial state. When the state machine enters the super state it will also automatically enter the substate. This can be configured like this:

```go
sm.Configure(State.B)
  .InitialTransition(State.C);

sm.Configure(State.C)
  .SubstateOf(State.B);
```

### External State Storage

Stateless is designed to be embedded in various application models. For example, some ORMs place requirements upon where mapped data may be stored, and UI frameworks often require state to be stored in special "bindable" properties. To this end, the `StateMachine` constructor can accept function arguments that will be used to read and write the state values:

```go
machine := stateless.NewStateMachineWithExternalStorage(func(_ context.Context) (stateless.State, error) {
  return myState.Value, nil
}, func(_ context.Context, state stateless.State) error {
  myState.Value  = state
  return nil
}, stateless.FiringQueued)
```

In this example the state machine will use the `myState` object for state storage.

### Activation / Deactivation

It might be necessary to perform some code before storing the object state, and likewise when restoring the object state. Use `Deactivate` and `Activate` for this. Activation should only be called once before normal operation starts, and once before state storage.

### Introspection

The state machine can provide a list of the triggers that can be successfully fired within the current state via the `StateMachine.PermittedTriggers` property.

### Guard Clauses

The state machine will choose between multiple transitions based on guard clauses, e.g.:

```go
phoneCall.Configure(stateOffHook).
  Permit(triggerCallDialled, stateRinging, func(_ context.Context, _ ...any) bool {
    return IsValidNumber()
  }).
  Permit(triggerCallDialled, stateBeeping, func(_ context.Context, _ ...any) bool {
    return !IsValidNumber()
  })
```

Guard clauses within a state must be mutually exclusive (multiple guard clauses cannot be valid at the same time). Substates can override transitions by respecifying them, however substates cannot disallow transitions that are allowed by the superstate.

The guard clauses will be evaluated whenever a trigger is fired. Guards should therefor be made side effect free.

### Parameterised Triggers

Strongly-typed parameters can be assigned to triggers:

```go
stateMachine.SetTriggerParameters(triggerCallDialed, reflect.TypeOf(""))

stateMachine.Configure(stateRinging).
  OnEntryFrom(triggerCallDialed, func(_ context.Context, args ...any) error {
    fmt.Println(args[0].(string))
    return nil
  })

stateMachine.Fire(triggerCallDialed, "qmuntal")
```

It is runtime safe to cast parameters to the ones specified in `SetTriggerParameters`. If the parameters passed in `Fire` do not match the ones specified it will panic.

Trigger parameters can be used to dynamically select the destination state using the `PermitDynamic()` configuration method.

### Ignored Transitions and Reentrant States

Firing a trigger that does not have an allowed transition associated with it will cause a panic to be thrown.

To ignore triggers within certain states, use the `Ignore(Trigger)` directive:

```go
phoneCall.Configure(stateConnected).
  Ignore(triggerCallDialled)
```

Alternatively, a state can be marked reentrant so its entry and exit events will fire even when transitioning from/to itself:

```go
stateMachine.Configure(stateAssigned).
  PermitReentry(triggerAssigned).
  OnEntry(func(_ context.Context, _ ...any) error {
    startCallTimer()
    return nil
  })
```

By default, triggers must be ignored explicitly. To override Stateless's default behaviour of throwing a panic when an unhandled trigger is fired, configure the state machine using the `OnUnhandledTrigger` method:

```go
stateMachine.OnUnhandledTrigger( func (_ context.Context, state State, _ Trigger, _ []string) {})
```

### Export to DOT graph

It can be useful to visualize state machines on runtime. With this approach the code is the authoritative source and state diagrams are by-products which are always up to date.

```go
sm := stateMachine.Configure(stateOffHook).
  Permit(triggerCallDialed, stateRinging, isValidNumber)
graph := sm.ToGraph()
```

The StateMachine.ToGraph() method returns a string representation of the state machine in the DOT graph language, e.g.:

```dot
digraph {
  OffHook -> Ringing [label="CallDialled [isValidNumber]"];
}
```

This can then be rendered by tools that support the DOT graph language, such as the dot command line tool from graphviz.org or viz.js. See [webgraphviz.com](http://www.webgraphviz.com) for instant gratification. Command line example: dot -T pdf -o phoneCall.pdf phoneCall.dot to generate a PDF file.

This is the complete Phone Call graph as builded in `example_test.go`.

![Phone Call graph](assets/phone-graph.png?raw=true "Phone Call complete DOT")

## Project Goals

This page is an almost-complete description of Stateless, and its explicit aim is to remain minimal.

Please use the issue tracker or the if you'd like to report problems or discuss features.

(_Why the name? Stateless implements the set of rules regarding state transitions, but, at least when the delegate version of the constructor is used, doesn't maintain any internal state itself._)


stateless

Monitors Go MemStats + System stats such as Memory, Swap and CPU and sends via UDP anywhere you want for logging etc...

stats

A modern, powerful, and robust URL shortener microservice with mysql support.

[![Build Status](https://travis-ci.com/pantrif/url-shortener.svg?branch=master)](https://travis-ci.com/pantrif/url-shortener)
[![Go Report Card](https://goreportcard.com/badge/github.com/pantrif/url-shortener)](https://goreportcard.com/report/github.com/pantrif/url-shortener)
[![GoDoc](https://godoc.org/github.com/pantrif/url-shortener?status.png)](http://godoc.org/github.com/pantrif/url-shortener)

# url-shortener
A golang URL Shortener with mysql support.  
Using Bijective conversion between natural numbers (IDs) and short strings

# Installation
## Using docker compose
```
docker-compose up --build
```
## Using an existing mysql

Edit .env file to add connection strings for mysql  
Run mysql_init/create_table.sql  
```
go run main.go
```

# Usage

## Create short url
```
curl -X POST -H "Content-Type:application/json" -d "{\"url\": \"http://www.google.com\"}" http://localhost:8081/shorten
```
Expected output  
```
{"url":"localhost:8081/3"}
```

## Redirect
```
curl -v localhost:8081/3
```
Output  
```
*   Trying ::1...
* TCP_NODELAY set
* Connected to localhost (::1) port 8081 (#0)
> GET /3 HTTP/1.1
> Host: localhost:8081
> User-Agent: curl/7.54.0
> Accept: */*
>
< HTTP/1.1 303 See Other
< Location: http://www.google.com
< Date: Mon, 04 Jun 2018 08:03:13 GMT
< Content-Length: 48
< Content-Type: text/html; charset=utf-8
<
<a href="http://www.google.com">See Other</a>.
```

# Licence 
This module is open-sourced software licensed under the [MIT license](http://opensource.org/licenses/MIT)


url-shortener

A faster varying length integer encoder/decoder than the one provided in the standard library.

# Variable length unsigned integer encoding

Small unsigned integer values are more frequent than big values. A substantial
compression may then be achieved by dropping the insignificant 0 bits when
serializing integers in a byte sequence. The byte length of the encoded 
integer will then vary according to the number of significant bits. 

The length of the encoded integer must be encoded with the integer bits so
that the original integer can be restored. There exist different ways to 
encode a varying length integer. Here we consider only the encoding of `uint64`
values. 

The most popular of such encoding is 
[LEB128](https://en.wikipedia.org/wiki/LEB128). It allows to encode integers of
any byte size. It is the encoding used in UTF8 characters and in the 
`encoding/binary` package for `Uvarint`. The maximum byte length of an `uint64`
encoded in LEB128 is 10 bytes. 

This package implements the 
[prefix code](https://en.wikipedia.org/wiki/Prefix_code). The significant bytes
are serialized in big endian order, and the most significant bits of the first 
byte set to 1 encode the number of bytes that follow the first byte. This 
encoding requires less bit fiddling than the postfiy code to encode or decode. 
The maximum byte length of an `uint64` prefix encoded is 9 bytes.

An alternate encoding is the [postfix code](). In this encoding the significant 
bytes are serialized in little endian order. The byte length is encoded as a 
number of 0 bits in the last byte which appears first in the encoded byte 
sequence. It may seam more performant than the prefix code since words may be 
written in memory in one instruction on little endian computers, but the bit 
fiddling adds a non nigligible overhead. Benchmarks comparing prefix en postfix
code show indeed that prefix code is more performant when coded in Go.

There exist other encoding as the one use by SQLight, but we don't discuss them
here. 

## Usage

To use this package you must first make sure that you have a `go.mod` file in 
your project. To create a `go.mod` file, you must issue the following command in
your terminal where you replace `myProgram` with the name of your program. 

```bash
$ go mod init myProgram
```

The second step is to import this package in the go source files that will use 
its functions. 

```go
import "github.com/chmike/varint"
```

### Encoding

To encode a `uint64` value, use the following function. It will serialize the 
value in the byte slice and return the number of bytes written. If the slice 
is too small to hold the encoded integer, the function returns 0. The 
function never panics.

```go
func varint.Encode([]byte, uint64) int
```

In your program, you would encode the value `1234` in the byte slice `b` 
like this:

```go
l := varint.Encode(b, 1234)
if l == 0 {
  // b is too small to hold the encoded value
}
b = b[l:]
```

### Decoding

To decode an encoded `uint64` value, use the following function. It will deserialize
the value and return the number of bytes read. If the slice is too small to contain
a value (slice empty or value truncated), the function returns the value 0 and 0 bytes
read. The function never panics.

```go
func varint.Decode([]byte) (uint64,int)
```

In your program, you would decode an encoded value in the byte slice `b` like this:

```go
l, v := varint.Decod(b)
if l == 0 {
  // b is empty or the value is truncated
}
b = b[l:]
```
### difference with the Uvarint functions

These functions have the same API as the `binary.PutUvarint()` and the `binary.Uvarint`
functions and can conveniently replace them. There are a number of differences though. 

- the `Uvarint()` and `PatUvarint` functions may panic
- the function `PutUvarint()` will never return 0
- `Uvarint()` may return a negative number of bytes read in some conditions.

## Preformance 

The extensive study of performance comparing different implementation of 
postfix and prefix encoding led to this code. Its performance is compared
with the `binary.PutUvarint()` and `binary.Uvarint()` and presented in
the following graphic. The data is made available in `docs/data.txt`.

![benchmarks](img/benchmarks.png)

The LEB128 encoding with `binary.PutUvarint()` for values up to 35 bits 
is as fast as `varint.Encode()` function. Encoding values smaller than
128 is inlined. `varint.Decode()` of such values is slower than `Uvarint`
because it is not inlined by the compiler. 

For unknown reason the LEB128 encoding and decoding functions become
significantly slower for values bigger than 35bits on my computer. I 
don't know if it's due to the compiler or the CPU. 

The following graphic shows the time required to encode and decode a
`uint64` value. This clearly shows that `varint` is faster. Since a value
is usually written once and read many times, it shows that prefix encoding
is a more efficient encoding than LEB128. 

![benchmark encode and decode](img/benchmarkEncodeAndDecode.png)

### Note of caution on the benchmark results

The benchmark is advantaging the `chmike/varint` code due to branch prediction
optimisation. Encoding a slice of uint64 values of different magnitude would
mitigate this effect. A zipf distributed magnitude might be more realist. 

Any other suggestion for a better benchmarking method is welcome in the issue
section.


varint

FreeDesktop.org (xdg) Specs implemented in Go.

xdg
===

Package xdg provides access to the FreeDesktop.org (XDG) specs.

[![GoDoc](https://godoc.org/github.com/rkoesters/xdg?status.svg)](https://godoc.org/github.com/rkoesters/xdg)
[![Build Status](https://travis-ci.org/rkoesters/xdg.svg?branch=master)](https://travis-ci.org/rkoesters/xdg)
[![Go Report Card](https://goreportcard.com/badge/github.com/rkoesters/xdg)](https://goreportcard.com/report/github.com/rkoesters/xdg)

Documentation
-------------

Documentation is available via godoc. Here are direct links to the
documentation pages for each package:

* [xdg](https://godoc.org/github.com/rkoesters/xdg) - Provides xdg.Open
  function to call `xdg-open` command.
* [xdg/basedir](https://godoc.org/github.com/rkoesters/xdg/basedir) -
  Provides access to the xdg basedir spec.
* [xdg/desktop](https://godoc.org/github.com/rkoesters/xdg/desktop) -
  Read desktop files (w/ localization support).
* [xdg/keyfile](https://godoc.org/github.com/rkoesters/xdg/keyfile) -
  Provides access to xdg key file format (w/ localization support).
* [xdg/trash](https://godoc.org/github.com/rkoesters/xdg/trash) -
  Provides access to xdg trash spec.
* [xdg/userdirs](https://godoc.org/github.com/rkoesters/xdg/userdirs) -
  Provides access to common user directories.

Testing
-------

Tests can be run with `go test`.

The tests for the [xdg/trash](trash) package expect the trash to exist
(`$XDG_DATA_HOME/Trash/files` (or `$HOME/.local/share/Trash/files` if
`$XDG_DATA_HOME` is undefined)).

The tests for the [xdg/userdirs](userdirs) package require the
`xdg-user-dir` command.

TODO
----

- autostart
- desktop.Launch (in progress on desktop-launch branch)
- trash.New (requires checking for a "sticky bit" on the filesystem of
  the drive on which the trash exists; in addition to other (easier)
  checks)

License
-------

See [LICENSE](LICENSE).


The Best Go Libraries For Miscellaneous - These libraries were placed here because none of the other categories seemed to fit. (27)

health

gtree

anagent

antch

archiver

autoflags

avgRating

datacounter

gatus

go-commandbus

gommit

gopsutil

gosh

gosms

gotoprom

gountries

health

healthcheck

hostutils

llvm

openapi

pdfgen

stateless

stats

url-shortener

varint

xdg