data validation for #golang with configurable & extensible rules in usual code constructs

ozzo-validation is a Go package that provides configurable and extensible data validation capabilities. It uses programming constructs to specify how data should be validated rather than relying on error-prone struct tags, which makes your code more flexible and less error prone. ozzo-validation has the following features:

  • rule-based data validation that allows validating a data value with multiple rules.
  • validation rules are declared via normal programming constructs instead of error-prone struct tags.
  • can validate data of different types, e.g., structs, strings, byte slices, slices, maps, arrays.
  • can validate custom data types as long as they implement the Validatable interface.
  • support validating data types that implement the sql.Valuer interface (e.g. sql.NullString).
  • support validating selective struct fields.
  • customizable and well-formatted validation errors.
  • provide a rich set of validation rules right out of box.
  • extremely easy to create and use custom validation rules.

https://github.com/go-ozzo/ozzo-validation

Share This:

Need a good #golang Book? Here are 2 lists for you

Learning by doing is mostly done via reading a good book (and of course a good blog ;-)).
Here is a well maintained list of English #golang books:
https://github.com/vladimirvivien/GoBooks

And here a blog post with another list:
https://hackerlists.com/free-go-programming-books/

Share This:

#golang based Interactive cli tool for HTTP inspection

Wuzz is an golang based interactive cli tool for HTTP inspection

Wuzz command line arguments are similar to cURL’s arguments, so it can be used to inspect/modify requests copied from the browser’s network inspector with the “copy as cURL” feature.

 

Share This:

Building High Performance APIs In #golang Using gRPC And Protocol Buffers

Very interesting Blog Post from Shiju Varghese about gRPC and Protocol Buffer based High Performance APIs.

Read Medium Blog Post

Share This:

go-otp implements one-time-password generators used in 2-factor auth systems #golang

The Package go-otp implements one-time-password generators used in 2-factor authentication systems like RSA-tokens. Currently this supports both HOTP (RFC-4226), TOTP (RFC-6238) and Base32 encoding (RFC-3548) for Google Authenticator compatibility

https://github.com/hgfischer/go-otp

Why One Time Passwords?

One Time Passwords (OTPs) are an mechanism to improve security over passwords alone. When a Time-based OTP (TOTP) is stored on a user’s phone, and combined with something the user knows (Password), you have an easy on-ramp to Multi-factor authentication without adding a dependency on a SMS provider. This Password and TOTP combination is used by many popular websites including Google, Github, Facebook, Salesforce and many others.

The otp library enables you to easily add TOTPs to your own application, increasing your user’s security against mass-password breaches and malware.

Because TOTP is standardized and widely deployed, there are many mobile clients and software implementations.

otp Supports:

Generating QR Code images for easy user enrollment.
Time-based One-time Password Algorithm (TOTP) (RFC 6238): Time based OTP, the most commonly used method.
HMAC-based One-time Password Algorithm (HOTP) (RFC 4226): Counter based OTP, which TOTP is based upon.
Generation and Validation of codes for either algorithm.

Share This:

#golang based HTTP reverse proxy and load balancer made to deploy #microservices with ease.

Træfɪk is a modern HTTP reverse proxy and load balancer made to deploy microservices with ease. It supports several backends (Docker, Swarm, Kubernetes, Marathon, Mesos, Consul, Etcd, Zookeeper, BoltDB, Eureka, Rest API, file…) to manage its configuration automatically and dynamically.

https://www.traefik.io/
https://github.com/containous/traefik

Share This:

#golang based open-source tool for capturing and replaying live HTTP traffic into a test environment

GoReplay is an #golang based open-source tool for capturing and replaying live HTTP traffic into a test environment in order to continuously test your system with real data. It can be used to increase confidence in code deployments, configuration changes and infrastructure changes.

https://github.com/buger/goreplay

Share This:

Blog post about “How to use slice capacity and length in #golang “

An interesting blog post about “How to use slice capacity and length in Go”:

https://www.calhoun.io/how-to-use-slice-capacity-and-length-in-go/

Share This:

csvtk- cross-platform ( #golang ), efficient, practical and pretty CSV/TSV toolkit

csvtk is a cross-platform, efficient, practical and pretty CSV/TSV toolkit with the following features:

Features

  • Cross-platform (Linux/Windows/Mac OS X/OpenBSD/FreeBSD)
  • Light weight and out-of-the-box, no dependencies, no compilation, no configuration
  • Fast, multiple-CPUs supported
  • Practical functions supported by N subcommands
  • Support STDIN and gziped input/output file, easy being used in pipe
  • Most of the subcommands support unselecting fields and fuzzy fields, e.g. -f "-id,-name" for all fields except “id” and “name”, -F -f "a.*" for all fields with prefix “a.”.
  • Support common plots

https://github.com/shenwei356/csvtk

Share This:

Ponzu: #golang 1.8 based CMS / http server framework

Ponzu is a powerful and efficient open-source HTTP server framework and CMS. It provides automatic, free, and secure HTTP/2 over TLS (certificates obtained via Let’s Encrypt), a useful CMS and scaffolding to generate content editors, and a fast HTTP API on which to build modern applications.

Requirement: Golang 1.8 (actually available as RC versions only)

https://github.com/ponzu-cms/ponzu

Share This: