aptly is a Debian repository management tool.

=====
aptly
=====

.. image:: https://api.travis-ci.org/aptly-dev/aptly.svg?branch=master
    :target: https://travis-ci.org/aptly-dev/aptly

.. image:: https://codecov.io/gh/aptly-dev/aptly/branch/master/graph/badge.svg
  :target: https://codecov.io/gh/aptly-dev/aptly

.. image:: https://badges.gitter.im/Join Chat.svg
    :target: https://gitter.im/aptly-dev/aptly?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge

.. image:: http://goreportcard.com/badge/aptly-dev/aptly
    :target: http://goreportcard.com/report/aptly-dev/aptly

Aptly is a swiss army knife for Debian repository management.

.. image:: http://www.aptly.info/img/aptly_logo.png
    :target: http://www.aptly.info/

Documentation is available at `http://www.aptly.info/ <http://www.aptly.info/>`_. For support please use
mailing list `aptly-discuss <https://groups.google.com/forum/#!forum/aptly-discuss>`_.

Aptly features: ("+" means planned features)

* make mirrors of remote Debian/Ubuntu repositories, limiting by components/architectures
* take snapshots of mirrors at any point in time, fixing state of repository at some moment of time
* publish snapshot as Debian repository, ready to be consumed by apt
* controlled update of one or more packages in snapshot from upstream mirror, tracking dependencies
* merge two or more snapshots into one
* filter repository by search query, pulling dependencies when required
* publish self-made packages as Debian repositories
* REST API for remote access
* mirror repositories "as-is" (without resigning with user's key) (+)
* support for yum repositories (+)

Current limitations:

* translations are not supported yet

Download
--------

To install aptly on Debian/Ubuntu, add new repository to ``/etc/apt/sources.list``::

    deb http://repo.aptly.info/ squeeze main

And import key that is used to sign the release::

    $ apt-key adv --keyserver pool.sks-keyservers.net --recv-keys ED75B5A4483DA07C

After that you can install aptly as any other software package::

    $ apt-get update
    $ apt-get install aptly

Don't worry about squeeze part in repo name: aptly package should work on Debian squeeze+,
Ubuntu 10.0+. Package contains aptly binary, man page and bash completion.

If you would like to use nightly builds (unstable), please use following repository::

    deb http://repo.aptly.info/ nightly main

Binary executables (depends almost only on libc) are available for download from `Bintray <http://dl.bintray.com/smira/aptly/>`_.

If you have Go environment set up, you can build aptly from source by running (go 1.10+ required)::

    mkdir -p $GOPATH/src/github.com/aptly-dev/aptly
    git clone https://github.com/aptly-dev/aptly $GOPATH/src/github.com/aptly-dev/aptly
    cd $GOPATH/src/github.com/aptly-dev/aptly
    make install

Binary would be installed to ``$GOPATH/bin/aptly``.

Contributing
------------

Please follow detailed documentation in `CONTRIBUTING.md <CONTRIBUTING.md>`_.

Integrations
------------

Vagrant:

-   `Vagrant configuration <https://github.com/sepulworld/aptly-vagrant>`_ by
    Zane Williamson, allowing to bring two virtual servers, one with aptly installed
    and another one set up to install packages from repository published by aptly

Docker:

-    `Docker container <https://github.com/mikepurvis/aptly-docker>`_ with aptly inside by Mike Purvis
-    `Docker container <https://github.com/urpylka/docker-aptly>`_ with aptly and nginx by Artem Smirnov

With configuration management systems:

-   `Chef cookbook <https://github.com/hw-cookbooks/aptly>`_ by Aaron Baer
    (Heavy Water Operations, LLC)
-   `Puppet module <https://github.com/alphagov/puppet-aptly>`_ by
    Government Digital Services
-   `Puppet module <https://github.com/tubemogul/puppet-aptly>`_ by
    TubeMogul
-   `SaltStack Formula <https://github.com/saltstack-formulas/aptly-formula>`_ by
    Forrest Alvarez and Brian Jackson
-   `Ansible role <https://github.com/aioue/ansible-role-aptly>`_ by Tom Paine

CLI for aptly API:

-   `Ruby aptly CLI/library <https://github.com/sepulworld/aptly_cli>`_ by Zane Williamson
-   `Python aptly CLI (good for CI) <https://github.com/TimSusa/aptly_api_cli>`_ by Tim Susa

GUI for aptly API:

-   `Python aptly GUI (via pyqt5) <https://github.com/chnyda/python-aptly-gui>`_ by Cedric Hnyda

Scala sbt:

-   `sbt aptly plugin <https://github.com/amalakar/sbt-aptly>`_ by Arup Malakar


aptly

Dead simple, no frills Go cross compile tool.

# Gox - Simple Go Cross Compilation

Gox is a simple, no-frills tool for Go cross compilation that behaves a
lot like standard `go build`. Gox will parallelize builds for multiple
platforms. Gox will also build the cross-compilation toolchain for you.

## Installation

To install Gox, please use `go get`. We tag versions so feel free to
checkout that tag and compile.

```
$ go install github.com/mitchellh/gox@latest
...
$ gox -h
...
```

## Usage

If you know how to use `go build`, then you know how to use Gox. For
example, to build the current package, specify no parameters and just
call `gox`. Gox will parallelize based on the number of CPUs you have
by default and build for every platform by default:

```
$ gox
Number of parallel builds: 4

-->      darwin/386: github.com/mitchellh/gox
-->    darwin/amd64: github.com/mitchellh/gox
-->       linux/386: github.com/mitchellh/gox
-->     linux/amd64: github.com/mitchellh/gox
-->       linux/arm: github.com/mitchellh/gox
-->     freebsd/386: github.com/mitchellh/gox
-->   freebsd/amd64: github.com/mitchellh/gox
-->     openbsd/386: github.com/mitchellh/gox
-->   openbsd/amd64: github.com/mitchellh/gox
-->     windows/386: github.com/mitchellh/gox
-->   windows/amd64: github.com/mitchellh/gox
-->     freebsd/arm: github.com/mitchellh/gox
-->      netbsd/386: github.com/mitchellh/gox
-->    netbsd/amd64: github.com/mitchellh/gox
-->      netbsd/arm: github.com/mitchellh/gox
-->       plan9/386: github.com/mitchellh/gox
```

Or, if you want to build a package and sub-packages:

```
$ gox ./...
...
```

Or, if you want to build multiple distinct packages:

```
$ gox github.com/mitchellh/gox github.com/hashicorp/serf
...
```

Or if you want to just build for linux:

```
$ gox -os="linux"
...
```

Or maybe you just want to build for 64-bit linux:

```
$ gox -osarch="linux/amd64"
...
```

And more! Just run `gox -h` for help and additional information.

## Versus Other Cross-Compile Tools

A big thanks to these other options for existing. They each paved the
way in many aspects to make Go cross-compilation approachable.

* [Dave Cheney's golang-crosscompile](https://github.com/davecheney/golang-crosscompile) -
  Gox compiles for multiple platforms and can therefore easily run on
  any platform Go supports, whereas Dave's scripts require a shell. Gox
  will also parallelize builds. Dave's scripts build sequentially. Gox has
  much easier to use OS/Arch filtering built in.

* [goxc](https://github.com/laher/goxc) -
  A very richly featured tool that can even do things such as build system
  packages, upload binaries, generate download webpages, etc. Gox is a
  super slim alternative that only cross-compiles binaries. Gox builds packages in parallel, whereas
  goxc doesn't. Gox doesn't enforce a specific output structure for built
  binaries.



build tool for Go, with a focus on cross-compiling and packaging.

goxc  [![build status](http://img.shields.io/travis/laher/goxc.svg)](https://travis-ci.org/laher/goxc)
====

_NOTE: goxc has long been in maintenance mode. Ever since Go1.5 supported simple cross-compilation, this tool lost much of its value. There are still many aspects of goxc which I'm very proud of, and some packaging features in particular, which are still useful. I'm very much a go user, but I myself haven't had any need for goxc for a long while._

_If you see something you'd like to add to goxc, please go ahead, fork and PR. Good PRs will earn you commit access to the repo. Thanks for everyone's help over the years._

[goxc](https://github.com/laher/goxc) is a build tool for Go, with a focus on cross-compiling and packaging.


By default, goxc [g]zips (& .debs for Linux) the programs, and generates a 'downloads page' in markdown (with a Jekyll header).

goxc is written in Go but uses *os.exec* to call 'go build' with the appropriate flags & env variables for each supported platform.

goxc was inspired by Dave Cheney's Bash script [golang-crosscompile](https://github.com/davecheney/golang-crosscompile).

 * goxc crosscompiles to all platforms at once. 
 * The artifacts are saved into a directory structure along with a markdown file of relative links.
 * Artifacts are packaged as zips, tgzs, or debs. Defaults for each OS/architecture.
 * AND, goxc can now upload your files to github releases OR bintray.com. 
 * **See ‘Github Releases’ section below.**


Notable Features
----------------
 * Cross-compilation, to all supported platforms, or a specified subset.
 	* Validation of toolchain & verification of cross-compiled artifacts
 	* Specify target platform, via 'Build Constraint'-like syntax (via commandline flag e.g. `-bc="windows linux,!arm"`, or via config)
 * *Automatic* (re-)building toolchain to all or specified platforms.
 * 'task' based invocation, similar to 'make' or 'ant'. e.g. `goxc xc` or `goxc clean go-test` 
	* The 'default' task alias will, test, cross-compile, verify, package up your artifacts for each platform, and generate a 'downloads page' with links to each platform. 
 	* Various go tools available via tasks: `go-test`, `go-vet`, `go-fmt`, `go-install`, `go-clean`.
	* You can modify task behaviour via configuration or commandline flags.
 * JSON-based configuration files for repeatable builds. 
 	* Most config data can be written via flags (using -wc option) - less JSON fiddliness.
	* Includes support for multiple configurations per-project.
 	* Per-task configuration options.
	* 'Override' config files for 'local environment' - working-copy-specific, or branch-specific, configurations.
 * Packaging & distribution
 	* Zip (or tar.gz) archiving of cross-compiled artifacts & accompanying resources (READMEs etc)
 	* Packaging into .debs (for Debian/Ubuntu Linux)
    * Upload to github.com releases.
 	* bintray.com integration (deploys binaries to bintray.com). *bintray.com registration required*
 	* 'downloads page' generation (markdown/html format; templatable).
 * Versioning:
	* track your version number via configuration data.
	* version number interpolation at compile-time (uses go's `-ldflags` compiler option to populate given constants or global variables with build version or build date)
	* version number interpolation of source code. `goxc interpolate-source` (new task available in 0.10.x).
	* the `bump` task facilitates increasing the app version number.
	* the `tag` task creates a tag in your vcs (currently only 'git' supported).
 * support for multiple binaries per project (goxc now searches subdirectories for 'main' packages)
 * support for multiple Go installations - choose at runtime with `-goroot=` flag.

Installation
--------------
goxc requires the go source and the go toolchain.

 1. [Install go from source](http://golang.org/doc/install/source). (Requires gcc (or MinGW) and 'hg')

	* OSX Users Note: If you are using XCode 5 (OSX 10.9), it is best to go straight to Go 1.2rc5 (or greater). This is necessary because Apple have replaced the standard gcc with llvm-gcc, and Go 1.1 compilation tools depend on the usual gcc.

		* There is another workaround incase Go 1.2rc5 is not an option:

				brew tap homebrew/versions
				brew install apple-gcc42
				go get github.com/laher/goxc
				CC=`brew list apple-gcc42 | grep bin/gcc-4.2` goxc -t

 2. Install goxc:

		go get github.com/laher/goxc
			
 3. a. (just once per Go version): to pre-build the toolchains for all platforms:

		goxc -t


	* Note that rebuilding the toolchain is only required for Go up until v1.4. This step will become unnecessary in Go 1.5.
	* Note that, until goxc v0.16.0, rebuilding the toolchain was triggered automatically. This has now been switched off (by default). Automatic rebuilding was causing a number of subtle bugs for different users, and has been switched off since v0.16.0.
	* Also note that building the toolchain takes a while. Cross-compilation itself is quite fast.

Basic Usage
-----------

	cd path/to/app/dir
	goxc


More options
------------

Use `goxc -h` to list all options.

 * e.g. To restrict by OS and Architecture (using the same syntax as Go Build Constraints):

		goxc -bc="linux,!arm windows,386 darwin"
	
	* Note that build constraints are described in Go's ['build' package documentation](http://golang.org/pkg/go/build/) (in the overview section).

 * e.g. To set a destination root directory and artifact version number:

		goxc -d=my/jekyll/site/downloads -pv=0.1.1

 * 'Package version' can be compiled into your app if you define a VERSION variable in your main package.

"Tasks"
-------

goxc performs a number of operations, defined as 'tasks'. You can specify tasks as commandline arguments

 * `goxc -t` performs one task called 'toolchain'. It's the equivalent of `goxc -d=~ toolchain`
 * The *default* task is actually several tasks, which can be summarised as follows:
    * validate (tests the code) -> compile (cross-compiles code) -> package ([g]zips up the executables and builds a 'downloads' page)
 * You can specify one or more tasks, such as `goxc go-fmt xc`
 * You can skip tasks with '-tasks-='. Skip the 'package' stage with `goxc -tasks-=package`
 * For a list of tasks and 'aliases', run `goxc -h tasks`
 * Several tasks have options available for overriding. You can specify them in config or via flags. Just use `goxc <taskname> -task-setting=value <othertask>`
 * For more info on a particular task, run `goxc -h <taskname>`. This will also show you the options available for that task.
 * The easiest way to see how to configure tasks in config is to write some task config via `-wc`, e.g. `goxc -wc xc -GOARM=5`

Outcome
-------

By default, artifacts are generated and then immediately archived into (outputdir).

Examples:

 * /my/outputdir/0.1.1/myapp\_0.1.1\_linux\_arm.tar.gz
 * /my/outputdir/0.1.1/myapp\_0.1.1\_windows\_386.zip
 * /my/outputdir/0.1.1/myapp\_0.1.1\_linux\_386.deb

The version number is specified with -pv=0.1.1 .

By default, the output directory is ($GOBIN)/(appname)-xc, and the version is 'unknown', but you can specify these.

e.g.

      goxc -pv=0.1.1 -d=/home/me/myuser-github-pages/myapp/downloads/

*NOTE: it's **bad idea** to use project-level github-pages - your repo will become huge. User-level gh-pages are an option, but it's better to use the 'bintray' tasks.*:

If non-archived, artifacts generated into a directory structure as follows:

 (outputdir)/(version)/(OS)\_(ARCH)/(appname)(.exe?)

Be careful if you want to build a project with multiple executables. You need to add `{{.ExeName}}` to your `OutPath`-setting in your '.goxc.json'. So it may look like the following code snippet.

```
"OutPath": "{{.Dest}}{{.PS}}{{.AppName}}{{.PS}}{{.Version}}{{.PS}}{{.ExeName}}_{{.Version}}_{{.Os}}_{{.Arch}}{{.Ext}}"
```

Configuration file
-----------------

For repeatable builds (and some extra options), it is recomended to use goxc with one or more configuration file(s) to save and re-run compilations.

To create a config file (`.goxc.json`), just use the -wc (write config) option.

	goxc -wc -d=../site/downloads -bc="linux windows" xc -GOARM=7

You can also use multiple config files to support different paremeters for each platform.

The following would add a 'local' config file, `.goxc.local.json`. This file's contents will override `.goxc.json`. The idea of the .local.json files is to git-ignore them - for any local parameters which you only want on this particular computer, but not for other users or even for yourself on other computers/OS's.

	goxc -wlc -d=../site/downloads

The configuration file(s) feature is documented in much more detail in [the wiki](https://github.com/laher/goxc/wiki/config)


Github Releases
---------------

This is the good stuff, so let’s go from the top.

 * *First, install Go from source, and goxc. See ‘Installation’, above*

 * If you haven’t already, build toolchain (all platforms!). This takes a while.

```
	goxc -t
```

 * Write a config file `.goxc.json` with info about your repo

```
	goxc -wc default publish-github -owner=<username> 
	goxc -wc default publish-github -repository=<reponame>
	cat .goxc.json
```

 * Bump a version, to get a meaningful version number.

```
	goxc bump
```

 * *Go to your github account and create a personal access token*

[https://github.com/settings/tokens](https://github.com/settings/tokens)

 * Write a local config file `.goxc.local.json` with your key info, ensuring that the key doesn’t end up in your git repo. See more about config files in [the wiki](https://github.com/laher/goxc/wiki/config)

```
	goxc -wlc default publish-github -apikey=123456789012
	echo ".goxc.local.json" >> .gitignore
```

*Note that you can put a dummy key into the commandline and edit the file later with the real key.*

 * Now, cross-compile, package and upload. All in one go.

```
	goxc
```

There’s heaps of ways to reconfigure each task to get the outcome you really want, but this produces some pretty sensible defaults. Have fun.

Limitations
-----------

 * Tested on Linux and Mac recently. Windows - some time ago now.
 * Currently goxc is only designed to build standalone Go apps without linked libraries. You can try but YMMV
 * The *API* is not considered stable yet, so please don't start embedding goxc method calls in your code yet - unless you 'Contact us' first! Then I can freeze some API details as required.
 * Bug: issue with config overriding. Empty strings do not currently override non-empty strings. e.g. `-pi=""` doesnt override the associated config setting PackageInfo

License
-------

   Copyright 2013 Am Laher

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

See also
--------
 * [Package Versioning](https://github.com/laher/goxc/wiki/versioning)
 * [Wiki home](https://github.com/laher/goxc/wiki)
 * [Contributions](https://github.com/laher/goxc/wiki/contributions)


goxc

Open source Pusher server implementation compatible with Pusher client libraries written in GO.

[![Go Report Card](https://goreportcard.com/badge/github.com/dimiro1/ipe)](https://goreportcard.com/report/github.com/dimiro1/ipe)

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

# IPÊ

An open source Pusher server implementation compatible with Pusher client libraries written in Go.

# Why I wrote this software?

1. I wanted to learn Go and I needed a non trivial application;
2. I use Pusher in some projects;
3. I really like Pusher;
4. I was using Pusher on some projects behind a firewall;

# Features

* Public Channels;
* Private Channels;
* Presence Channels;
* Web Hooks;
* Client events;
* Complete REST API;
* Easy installation;
* A single binary without dependencies;
* Easy configuration;
* Protocol version 7;
* Multiple apps in the same instance;
* Drop in replacement for pusher server;

# Download pre built binaries

You can download pre built binaries from the [releases tab](https://github.com/dimiro1/ipe/releases).

# Building

```console
$ go get github.com/dimiro1/ipe
```

or simply

```console
$ go install github.com/dimiro1/ipe
```

Building from a local checkout

```console
$ git clone https://github.com/dimiro1/ipe.git
$ cd ipe/cmd
$ go build -o ipe
```

# How to configure?

## The server

```yaml

---
host: ":8080"
profiling: false
ssl:
  enabled: false
  host: ":4343"
  key_file: "key.pem"
  cert_file: "cert.pem"
apps:
  - name: "Sample Application"
    enabled: true
    only_ssl: false
    key: "278d525bdf162c739803"
    secret: "${APP_SECRET}" # Expand env vars
    app_id: "1"
    user_events: true
    webhooks:
      enabled: true
      url: "http://127.0.0.1:5000/hook"

```

## Libraries

### Client javascript library

```javascript
let pusher = new Pusher(APP_KEY, {
  wsHost: 'localhost',
  wsPort: 8080,
  wssPort: 4433,    // Required if encrypted is true
  encrypted: false, // Optional. the application must use only SSL connections
  enabledTransports: ["ws", "flash"],
  disabledTransports: ["flash"]
});
```

### Client server libraries

Ruby

```ruby
Pusher.host = 'localhost'
Pusher.port = 8080
```

PHP

```php
$pusher = new Pusher(APP_KEY, APP_SECRET, APP_ID, DEBUG, "http://localhost", "8080");
```

Go

```go
package main

import "github.com/pusher/pusher-http-go"

func main() {
	client := pusher.Client{
        AppId:  "APP_ID",
        Key:    "APP_KEY",
        Secret: "APP_SECRET",
        Host:   ":8080",
    }
	
	// use the client
}
```

NodeJS

```javascript
let pusher = new Pusher({
  appId: APP_ID,
  key: APP_KEY,
  secret: APP_SECRET
  domain: 'localhost',
  port: 80
});

```

# Logging

This software uses the [glog](https://github.com/golang/glog) library

for more information about logging type the following in console.

```console
$ ipe -h
```

# When use this software?

* When you are offline;
* When you want to control your infrastructure;
* When you do not want to have external dependencies;
* When you want extend the protocol;

# Contributing.

Feel free to fork this repo.

# Pusher

Pusher is an excellent service, their service is very reliable. I recommend for everyone.

# Where this name came from?

Here in Brazil we have this beautiful tree called [Ipê](http://en.wikipedia.org/wiki/Tabebuia_aurea), it comes in differente colors: yellow, pink, white, purple.

[I want to see pictures](https://www.flickr.com/search/?q=ipe)

# Author

Claudemiro Alves Feitosa Neto

# LICENSE

Copyright 2014, 2018 Claudemiro Alves Feitosa Neto. All rights reserved.
Use of this source code is governed by a MIT-style
license that can be found in the LICENSE file.



ProtonMail module for waybar/polybar/yabar/i3blocks.

# protoncheck 
[![](https://goreportcard.com/badge/github.com/servusdei2018/protoncheck)](https://goreportcard.com/report/github.com/servusdei2018/protoncheck) [![Go Reference](https://pkg.go.dev/badge/github.com/servusdei2018/protoncheck.svg)](https://pkg.go.dev/github.com/servusdei2018/protoncheck) [![](https://sonarcloud.io/api/project_badges/measure?project=servusdei2018_protoncheck&metric=alert_status)](https://sonarcloud.io/project/overview?id=servusdei2018_protoncheck)  [![Awesome](https://cdn.rawgit.com/sindresorhus/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg)](https://github.com/avelino/awesome-go)

awesome waybar/polybar/yabar/i3blocks module to check the amount of unread emails in a ProtonMail inbox.

## Installation
You may compile protoncheck yourself or download a copy from the [Releases](https://github.com/servusdei2018/protoncheck/releases/latest).

## Usage
Run `protoncheck`, using the `--username` and `--password` flags to supply your ProtonMail username and password, respectively. It will output the amount of unread emails in your inbox.

> ⚠️  _Protoncheck doesn't work with accounts with 2FA enabled._

#### waybar Config
Below is a sample Waybar configuration to check your ProtonMail inbox every 30 seconds.

~/.config/waybar/config:
```json
"modules-right": {
  "custom/protoncheck"
}

"custom/protoncheck": {
		"exec": "~/bin/protoncheck --username USER@protonmail.com --password PASSWORD",
		"format": " {}",
		"interval": 30,
		"on-click": "xdg-open https://mail.protonmail.com/inbox"
}
```

#### polybar Config
Below is a sample Polybar configuration to check your ProtonMail inbox every 30 seconds.

~/.config/polybar/config:
```yaml
modules-right = protoncheck

[module/protoncheck]
type = custom/script
exec = ~/bin/protoncheck --username USER@protonmail.com --password PASSWORD | sed  's/^/ /'
interval = 30
click-left = xdg-open https://mail.protonmail.com/inbox
```

#### yabar Config
Below is a sample yabar configuration to check your ProtonMail inbox every 30 seconds.

~/.config/yabar/yabar.conf:
```
	title: {
		exec: ~/bin/protoncheck --username USER@protonmail.com --password PASSWORD | sed  's/^/ /';
		type: "periodic";
		interval: 30;
	}
```

#### i3blocks Config
Below is a sample i3blocks configuration to check your ProtonMail inbox every 30 seconds.

~/.config/i3blocks/config:
```
[protoncheck]
command=~/bin/protoncheck --username USER@protonmail.com --password PASSWORD | sed  's/^/ /'
interval=30
color=#A4C2F4
```

## Credits
 - Special thank you to [@crabvk](https://github.com/crabvk) for making [bar-protonmail](https://github.com/crabvk/bar-protonmail), without which I wouldn't have had the inspiration to make protoncheck.

## Sponsoring
Work on `protoncheck` is done by volunteers in their free time, and takes time and effort. To show your appreciation and to provide continued motivation for work on this and other open source software, please send a donation.

[![](https://img.shields.io/badge/PayPal-00457C?style=for-the-badge&logo=paypal&logoColor=white)](https://www.paypal.com/donate?business=S9REMLHZB64NQ&no_recurring=0&item_name=Help+fund+my+college+tuition+and+open-source+work&currency_code=USD)


protoncheck

TCP tool for network performance and path monitoring, including socket statistics.

![tcpprobe](/docs/imgs/tp_logo.png) 


[![Github Actions](https://github.com/mehrdadrad/tcpprobe/workflows/build/badge.svg)](https://github.com/mehrdadrad/tcpprobe/actions?query=workflow%3Abuild) [![Go report](https://goreportcard.com/badge/github.com/mehrdadrad/tcpprobe)](https://goreportcard.com/report/github.com/mehrdadrad/tcpprobe)  [![Coverage Status](https://coveralls.io/repos/github/mehrdadrad/tcpprobe/badge.svg?branch=main)](https://coveralls.io/github/mehrdadrad/tcpprobe?branch=main)

**TCPProbe** is a modern TCP tool and service for network performance observability. It exposes information about socket’s underlying TCP session, TLS and HTTP (more than 60 [metrics](https://github.com/mehrdadrad/tcpprobe/wiki/metrics)). you can run it through command line or as a service. the request is highly customizable and you can integrate it with your application through gRPC. it runs in a Kubernetes cluster as cloud native application and by adding annotations on pods allow a fine control of the probing process.

![tcpprobe](/docs/imgs/tcpprobe_banner.png) 

## Features
- TCP socket statistics
- TCP/IP request customization
- Prometheus exporter
- Probing multiple hosts
- Runs as service
- Kubernetes native
- gRPC interface

## Documentation
* [Command's options](https://github.com/mehrdadrad/tcpprobe/wiki/command's-options)
* [Service](https://github.com/mehrdadrad/tcpprobe/wiki/service)
* [Demo](https://github.com/mehrdadrad/tcpprobe/wiki/prometheus-grafana) ([🎥 video](https://youtu.be/0Rr2ndrxftw))
* [Metrics](https://github.com/mehrdadrad/tcpprobe/wiki/metrics)
* [Helm Chart](https://github.com/mehrdadrad/tcpprobe/wiki/helm)
* [CLI tutorial](https://github.com/mehrdadrad/tcpprobe/wiki/command-line-tutorial)
* [gRPC](https://github.com/mehrdadrad/tcpprobe/wiki/grpc)

#### **Command line** ([download Linux binary](https://github.com/mehrdadrad/tcpprobe/releases/latest/download/tcpprobe)) 
```
tcpprobe -json https://www.google.com
```
```json
{"Target":"https://www.google.com","IP":"142.250.72.196","Timestamp":1607567390,"Seq":0,"State":1,"CaState":0,"Retransmits":0,"Probes":0,"Backoff":0,"Options":7,"Rto":204000,"Ato":40000,"SndMss":1418,"RcvMss":1418,"Unacked":0,"Sacked":0,"Lost":0,"Retrans":0,"Fackets":0,"LastDataSent":56,"LastAckSent":0,"LastDataRecv":0,"LastAckRecv":0,"Pmtu":9001,"RcvSsthresh":56587,"Rtt":1365,"Rttvar":446,"SndSsthresh":2147483647,"SndCwnd":10,"Advmss":8949,"Reordering":3,"RcvRtt":0,"RcvSpace":62727,"TotalRetrans":0,"PacingRate":20765147,"BytesAcked":448,"BytesReceived":10332,"SegsOut":10,"SegsIn":11,"NotsentBytes":0,"MinRtt":1305,"DataSegsIn":8,"DataSegsOut":3,"DeliveryRate":1785894,"BusyTime":4000,"RwndLimited":0,"SndbufLimited":0,"Delivered":4,"DeliveredCe":0,"BytesSent":447,"BytesRetrans":0,"DsackDups":0,"ReordSeen":0,"RcvOoopack":0,"SndWnd":66816,"TCPCongesAlg":"cubic","HTTPStatusCode":200,"HTTPRcvdBytes":14683,"HTTPRequest":113038,"HTTPResponse":293,"DNSResolve":2318,"TCPConnect":1421,"TLSHandshake":57036,"TCPConnectError":0,"DNSResolveError":0}
```

#### **Docker**
```
docker run --rm mehrdadrad/tcpprobe smtp.gmail.com:587
```

#### **Docker Compose**
TCPProbe and Prometheus
```
docker-compose up -d
```
Open your browser and try http://localhost:9090
You can edit the docker-compose.yml to customize the options and target(s).

#### **Helm Chart**
Detailed installation instructions for TCPProbe on Kubernetes are found [here](https://github.com/mehrdadrad/tcpprobe/wiki/helm).
```
helm install tcpprobe tcpprobe
```

## License
This project is licensed under MIT license. Please read the LICENSE file.

## Contribute
Welcomes any kind of contribution, please follow the next steps:

- Fork the project on github.com.
- Create a new branch.
- Commit changes to the new branch.
- Send a pull request.


tcpprobe

# Term Quiz

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

### A Quiz application made for your terminal

![Image of a abcd question](https://raw.githubusercontent.com/crazcalm/term-quiz/master/img/question1.png  "question")

![Image of end screen solution](https://raw.githubusercontent.com/crazcalm/term-quiz/master/img/answer1.png  "answer")

### Installation
	go get github.com/crazcalm/term-quiz

### Question Types Include
- A B C D
- True and False
- Fill in the Blank

### Usage

See the [code examples](https://github.com/crazcalm/term-quiz/tree/master/_examples) and [test csv files](https://github.com/crazcalm/term-quiz/tree/master/_examples/test_data).

### Keybindings
#### Quiz Screen
Keybindings| Action
--|--
Ctrl + C| Quit
Tab| Next Answer
Enter| Select Answer

#### Solutions Screen
Keybinding| Action
--|--
Ctrl + C| Quit
Enter| Next Solution

### Issues/Bugs/Suggestions
Feel free to report any bugs or make suggestions [here](https://github.com/crazcalm/term-quiz/issues).

### Repository of Quizzes
Feel free to add or use quizzes in the following repository ([github.com/crazcalm/quizzes](https://github.com/crazcalm/quizzes)).

The Best Go Libraries For Software Packages - Software written in Go. (7)

aptly

gox

goxc

ipe

protoncheck

tcpprobe

term-quiz