From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:52032) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1dz7H5-0003CK-MD for guix-patches@gnu.org; Mon, 02 Oct 2017 16:25:21 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1dz7Gw-0000wr-QL for guix-patches@gnu.org; Mon, 02 Oct 2017 16:25:11 -0400 Received: from debbugs.gnu.org ([208.118.235.43]:35903) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1dz7Gw-0000wc-E2 for guix-patches@gnu.org; Mon, 02 Oct 2017 16:25:02 -0400 Received: from Debian-debbugs by debbugs.gnu.org with local (Exim 4.84_2) (envelope-from ) id 1dz7Gw-0005EN-82 for guix-patches@gnu.org; Mon, 02 Oct 2017 16:25:02 -0400 Subject: [bug#28586] go-build-system and Syncthing Resent-Message-ID: Received: from eggs.gnu.org ([2001:4830:134:3::10]:51288) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1dz7Fi-0002wM-1h for guix-patches@gnu.org; Mon, 02 Oct 2017 16:23:55 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1dz7FZ-0007Tx-HI for guix-patches@gnu.org; Mon, 02 Oct 2017 16:23:46 -0400 Received: from out1-smtp.messagingengine.com ([66.111.4.25]:51767) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1dz7FY-0007SI-TT for guix-patches@gnu.org; Mon, 02 Oct 2017 16:23:37 -0400 Received: from localhost (c-73-165-108-70.hsd1.pa.comcast.net [73.165.108.70]) by mail.messagingengine.com (Postfix) with ESMTPA id BCEE624870 for ; Mon, 2 Oct 2017 16:23:35 -0400 (EDT) Date: Mon, 2 Oct 2017 16:23:25 -0400 From: Leo Famulari Message-ID: <20171002202325.GA12172@jasmine.lan> References: <20170924203651.GA29973@jasmine.lan> MIME-Version: 1.0 Content-Type: multipart/signed; micalg=pgp-sha256; protocol="application/pgp-signature"; boundary="1LKvkjL3sHcu1TtY" Content-Disposition: inline In-Reply-To: <20170924203651.GA29973@jasmine.lan> List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: guix-patches-bounces+kyle=kyleam.com@gnu.org Sender: "Guix-patches" To: 28586@debbugs.gnu.org --1LKvkjL3sHcu1TtY Content-Type: multipart/mixed; boundary="gKMricLos+KVdGMg" Content-Disposition: inline --gKMricLos+KVdGMg Content-Type: text/plain; charset=us-ascii Content-Disposition: inline On Sun, Sep 24, 2017 at 04:36:51PM -0400, Leo Famulari wrote: > These patches add a go-build-system, a package for Syncthing, and > Syncthing's dependencies. Here is the latest revision of these patches. I'll push them in a couple days if there are no further comments. --gKMricLos+KVdGMg Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: attachment; filename="0001-build-Add-the-Go-build-system.patch" Content-Transfer-Encoding: quoted-printable =46rom c07a2204ab6c5deb353699a67660841630d40feb Mon Sep 17 00:00:00 2001 =46rom: Leo Famulari Date: Tue, 19 Sep 2017 21:08:42 -0400 Subject: [PATCH 1/2] build: Add the Go build system. * guix/build-system/go.scm, guix/build/go-build-system.scm: New files. * Makefile.am (MODULES): Add new files. * doc/guix.texi (Build Systems): Document the go-build-system. --- Makefile.am | 2 + doc/guix.texi | 18 ++++ guix/build-system/go.scm | 132 +++++++++++++++++++++++++ guix/build/go-build-system.scm | 216 +++++++++++++++++++++++++++++++++++++= ++++ 4 files changed, 368 insertions(+) create mode 100644 guix/build-system/go.scm create mode 100644 guix/build/go-build-system.scm diff --git a/Makefile.am b/Makefile.am index d054f7879..efbd07a35 100644 --- a/Makefile.am +++ b/Makefile.am @@ -80,6 +80,7 @@ MODULES =3D \ guix/build-system/dub.scm \ guix/build-system/emacs.scm \ guix/build-system/font.scm \ + guix/build-system/go.scm \ guix/build-system/meson.scm \ guix/build-system/minify.scm \ guix/build-system/asdf.scm \ @@ -111,6 +112,7 @@ MODULES =3D \ guix/build/meson-build-system.scm \ guix/build/minify-build-system.scm \ guix/build/font-build-system.scm \ + guix/build/go-build-system.scm \ guix/build/asdf-build-system.scm \ guix/build/git.scm \ guix/build/hg.scm \ diff --git a/doc/guix.texi b/doc/guix.texi index c57c0bab6..6bef57748 100644 --- a/doc/guix.texi +++ b/doc/guix.texi @@ -3566,6 +3566,24 @@ debugging information''), which roughly means that c= ode is compiled with @code{-O2 -g}, as is the case for Autoconf-based packages by default. @end defvr =20 +@defvr {Scheme Variable} go-build-system +This variable is exported by @code{(guix build-system go)}. It +implements a build procedure for Go packages using the standard +@url{https://golang.org/cmd/go/#hdr-Compile_packages_and_dependencies, +Go build mechanisms}. + +The user is expected to provide a value for the key @code{#:import-path} +and, in some cases, @code{#:unpack-path}. The +@url{https://golang.org/doc/code.html#ImportPaths, import path} +corresponds to the filesystem path expected by the package's build +scripts and any referring packages, and provides a unique way to +refer to a Go package. It is typically based on a combination of the +package source code's remote URI and filesystem hierarchy structure. In +some cases, you will need to unpack the package's source code to a +different directory structure than the one indicated by the import path, +and @code{#:unpack-path} should be used in such cases. +@end defvr + @defvr {Scheme Variable} glib-or-gtk-build-system This variable is exported by @code{(guix build-system glib-or-gtk)}. It is intended for use with packages making use of GLib or GTK+. diff --git a/guix/build-system/go.scm b/guix/build-system/go.scm new file mode 100644 index 000000000..43599df6f --- /dev/null +++ b/guix/build-system/go.scm @@ -0,0 +1,132 @@ +;;; GNU Guix --- Functional package management for GNU +;;; Copyright =A9 2016 Petter +;;; Copyright =A9 2017 Leo Famulari +;;; +;;; This file is part of GNU Guix. +;;; +;;; GNU Guix is free software; you can redistribute it and/or modify it +;;; under the terms of the GNU General Public License as published by +;;; the Free Software Foundation; either version 3 of the License, or (at +;;; your option) any later version. +;;; +;;; GNU Guix 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 +;;; GNU General Public License for more details. +;;; +;;; You should have received a copy of the GNU General Public License +;;; along with GNU Guix. If not, see . + +(define-module (guix build-system go) + #:use-module (guix utils) + #:use-module (guix derivations) + #:use-module (guix search-paths) + #:use-module (guix build-system) + #:use-module (guix build-system gnu) + #:use-module (guix packages) + #:use-module (ice-9 match) + #:export (%go-build-system-modules + go-build + go-build-system)) + +;; Commentary: +;; +;; Standard build procedure for packages using the Go build system. It is +;; implemented as an extension of 'gnu-build-system'. +;; +;; Code: + +(define %go-build-system-modules + ;; Build-side modules imported and used by default. + `((guix build go-build-system) + ,@%gnu-build-system-modules)) + +(define (default-go) + ;; Lazily resolve the binding to avoid a circular dependency. + (let ((go (resolve-interface '(gnu packages golang)))) + (module-ref go 'go))) + +(define* (lower name + #:key source inputs native-inputs outputs system target + (go (default-go)) + #:allow-other-keys + #:rest arguments) + "Return a bag for NAME." + (define private-keywords + '(#:source #:target #:go #:inputs #:native-inputs)) + + (and (not target) ;XXX: no cross-compilati= on + (bag + (name name) + (system system) + (host-inputs `(,@(if source + `(("source" ,source)) + '()) + ,@inputs + + ;; Keep the standard inputs of 'gnu-build-system'. + ,@(standard-packages))) + (build-inputs `(("go" ,go) + ,@native-inputs)) + (outputs outputs) + (build go-build) + (arguments (strip-keyword-arguments private-keywords arguments)))= )) + +(define* (go-build store name inputs + #:key + (phases '(@ (guix build go-build-system) + %standard-phases)) + (outputs '("out")) + (search-paths '()) + (import-path "") + (unpack-path "") + (tests? #t) + (system (%current-system)) + (guile #f) + (imported-modules %go-build-system-modules) + (modules '((guix build go-build-system) + (guix build utils)))) + (define builder + `(begin + (use-modules ,@modules) + (go-build #:name ,name + #:source ,(match (assoc-ref inputs "source") + (((? derivation? source)) + (derivation->output-path source)) + ((source) + source) + (source + source)) + #:system ,system + #:phases ,phases + #:outputs %outputs + #:search-paths ',(map search-path-specification->sexp + search-paths) + #:import-path ,import-path + #:unpack-path ,unpack-path + #:tests? ,tests? + #:inputs %build-inputs))) + + (define guile-for-build + (match guile + ((? package?) + (package-derivation store guile system #:graft? #f)) + (#f ; the default + (let* ((distro (resolve-interface '(gnu packages commencement))) + (guile (module-ref distro 'guile-final))) + (package-derivation store guile system + #:graft? #f))))) + + (build-expression->derivation store name builder + #:inputs inputs + #:system system + #:modules imported-modules + #:outputs outputs + #:guile-for-build guile-for-build)) + +(define go-build-system + (build-system + (name 'go) + (description + "Build system for Go programs") + (lower lower))) diff --git a/guix/build/go-build-system.scm b/guix/build/go-build-system.scm new file mode 100644 index 000000000..a60e05f29 --- /dev/null +++ b/guix/build/go-build-system.scm @@ -0,0 +1,216 @@ +;;; GNU Guix --- Functional package management for GNU +;;; Copyright =A9 2016 Petter +;;; Copyright =A9 2017 Leo Famulari +;;; +;;; This file is part of GNU Guix. +;;; +;;; GNU Guix is free software; you can redistribute it and/or modify it +;;; under the terms of the GNU General Public License as published by +;;; the Free Software Foundation; either version 3 of the License, or (at +;;; your option) any later version. +;;; +;;; GNU Guix 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 +;;; GNU General Public License for more details. +;;; +;;; You should have received a copy of the GNU General Public License +;;; along with GNU Guix. If not, see . + +(define-module (guix build go-build-system) + #:use-module ((guix build gnu-build-system) #:prefix gnu:) + #:use-module (guix build utils) + #:use-module (ice-9 match) + #:use-module (srfi srfi-1) + #:export (%standard-phases + go-build)) + +;; Commentary: +;; +;; Build procedures for Go packages. This is the builder-side code. +;; +;; Software written in Go is either a 'package' (i.e. library) or 'command' +;; (i.e. executable). Both types can be built with either the `go build` = or `go +;; install` commands. However, `go build` discards the result of the build +;; process for Go libraries, so we use `go install`, which preserves the +;; results. [0] + +;; Go software is developed and built within a particular filesystem hiera= rchy +;; structure called a 'workspace' [1]. This workspace is found by Go +;; via the GOPATH environment variable. Typically, all Go source code +;; and compiled objects are kept in a single workspace, but it is +;; possible for GOPATH to contain a list of directories, and that is +;; what we do in this go-build-system. [2] +;; +;; Go software, whether a package or a command, is uniquely named using +;; an 'import path'. The import path is based on the URL of the +;; software's source. Since most source code is provided over the +;; internet, the import path is typically a combination of the remote +;; URL and the source repository's filesystem structure. For example, +;; the Go port of the common `du` command is hosted on github.com, at +;; . Thus, the import path is +;; . [3] +;; +;; It may be possible to programatically guess a package's import path +;; based on the source URL, but we don't try that in this revision of +;; the go-build-system. +;; +;; Modules of modular Go libraries are named uniquely with their +;; filesystem paths. For example, the supplemental but "standardized" +;; libraries developed by the Go upstream developers are available at +;; . The Go IPv4 +;; library's import path is . The source of +;; such modular libraries must be unpacked at the top-level of the +;; filesystem structure of the library. So the IPv4 library should be +;; unpacked to . This is handled in the +;; go-build-system with the optional #:unpack-path key. +;; +;; In general, Go software is built using a standardized build mechanism +;; that does not require any build scripts like Makefiles. This means +;; that all modules of modular libraries cannot be built with a single +;; command. Each module must be built individually. This complicates +;; certain cases, and these issues are currently resolved by creating a +;; filesystem union of the required modules of such libraries. I think +;; this could be improved in future revisions of the go-build-system. +;; +;; [0] `go build`: +;; https://golang.org/cmd/go/#hdr-Compile_packages_and_dependencies +;; `go install`: +;; https://golang.org/cmd/go/#hdr-Compile_and_install_packages_and_depende= ncies +;; [1] https://golang.org/doc/code.html#Workspaces +;; bin/ +;; hello # command executable +;; outyet # command executable +;; pkg/ +;; linux_amd64/ +;; github.com/golang/example/ +;; stringutil.a # package object +;; src/ +;; github.com/golang/example/ +;; .git/ # Git repository metadata +;; hello/ +;; hello.go # command source +;; outyet/ +;; main.go # command source +;; main_test.go # test source +;; stringutil/ +;; reverse.go # package source +;; reverse_test.go # test source +;; golang.org/x/image/ +;; .git/ # Git repository metadata +;; bmp/ +;; reader.go # package source +;; writer.go # package source +;; ... (many more repositories and packages omitted) ... +;; +;; [2] https://golang.org/doc/code.html#GOPATH +;; [3] https://golang.org/doc/code.html#ImportPaths +;; +;; Code: + +(define* (unpack #:key source import-path unpack-path #:allow-other-keys) + "Unpack SOURCE in the UNPACK-PATH, or the IMPORT-PATH is the UNPACK-PATH= is +unset. When SOURCE is a directory, copy it instead of unpacking." + (if (string-null? import-path) + ((display "WARNING: The Go import path is unset.\n"))) + (if (string-null? unpack-path) + (set! unpack-path import-path)) + (mkdir "src") + (let ((dest (string-append "src/" unpack-path))) + (mkdir-p dest) + (if (file-is-directory? source) + (begin + (copy-recursively source dest #:keep-mtime? #t) + #t) + (if (string-suffix? ".zip" source) + (zero? (system* "unzip" "-d" dest source)) + (zero? (system* "tar" "-C" dest "-xvf" source)))))) + +(define* (install-source #:key outputs #:allow-other-keys) + "Install the source code to the output directory." + (let* ((out (assoc-ref outputs "out")) + (source "src") + (dest (string-append out "/" source))) + (copy-recursively source dest #:keep-mtime? #t) + #t)) + +(define (golang-package? name) + (string-prefix? "golang-" name)) + +(define (golang-inputs inputs) + "Return the alist of INPUTS that are Go software." + ;; XXX This should not check the file name of the store item. Instead we + ;; should pass, from the host side, the list of inputs that are packages= using + ;; the go-build-system. + (alist-delete "source" + (filter (match-lambda + ((label . directory) + (golang-package? ((compose package-name->name+version + strip-store-file-name) + directory))) + (_ #f)) + inputs))) + +(define* (setup-environment #:key inputs outputs #:allow-other-keys) + "Export the variables GOPATH and GOBIN, which are based on INPUTS and OU= TPUTS, +respectively." + (let ((out (assoc-ref outputs "out"))) + ;; GOPATH is where Go looks for the source code of the build's depende= ncies. + (set-path-environment-variable "GOPATH" + ;; XXX Matching "." hints that we could= do + ;; something simpler here... + (list ".") + (match (golang-inputs inputs) + (((_ . dir) ...) + dir))) + + ;; Add the source code of the package being built to GOPATH. + (if (getenv "GOPATH") + (setenv "GOPATH" (string-append (getcwd) ":" (getenv "GOPATH"))) + (setenv "GOPATH" (getcwd))) + ;; Where to install compiled executable files ('commands' in Go parlan= ce'). + (setenv "GOBIN" out) + #t)) + +(define* (build #:key import-path #:allow-other-keys) + "Build the package named by IMPORT-PATH." + (or + (zero? (system* "go" "install" + "-v" ; print the name of packages as they are compiled + "-x" ; print each command as it is invoked + import-path)) + (begin + (display (string-append "Building '" import-path "' failed.\n" + "Here are the results of `go env`:\n")) + (system* "go" "env") + #f))) + +(define* (check #:key tests? import-path #:allow-other-keys) + "Run the tests for the package named by IMPORT-PATH." + (if tests? + (zero? (system* "go" "test" import-path)))) + +(define* (install #:key outputs #:allow-other-keys) + "Install the compiled libraries. `go install` installs these files to +$GOPATH/pkg, so we have to copy them into the output direcotry manually. +Compiled executable files should have already been installed to the store = based +on $GOBIN in the build phase." + (when (file-exists? "pkg") + (copy-recursively "pkg" (string-append (assoc-ref outputs "out") "/pkg= "))) + #t) + +(define %standard-phases + (modify-phases gnu:%standard-phases + (delete 'configure) + (delete 'patch-generated-file-shebangs) + (replace 'unpack unpack) + (add-after 'unpack 'install-source install-source) + (add-before 'build 'setup-environment setup-environment) + (replace 'build build) + (replace 'check check) + (replace 'install install))) + +(define* (go-build #:key inputs (phases %standard-phases) + #:allow-other-keys #:rest args) + "Build the given Go package, applying all of PHASES in order." + (apply gnu:gnu-build #:inputs inputs #:phases phases args)) --=20 2.14.2 --gKMricLos+KVdGMg Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: attachment; filename="0002-gnu-Add-Syncthing.patch" Content-Transfer-Encoding: quoted-printable =46rom 01f4ab3b7f4caab41352ed2f5c9ab69c695c72ae Mon Sep 17 00:00:00 2001 =46rom: Leo Famulari Date: Tue, 19 Sep 2017 21:08:42 -0400 Subject: [PATCH 2/2] gnu: Add Syncthing. * gnu/packages/syncthing.scm: New file. Co-authored-by: Petter --- gnu/local.mk | 1 + gnu/packages/syncthing.scm | 1845 ++++++++++++++++++++++++++++++++++++++++= ++++ 2 files changed, 1846 insertions(+) create mode 100644 gnu/packages/syncthing.scm diff --git a/gnu/local.mk b/gnu/local.mk index edd6d8237..fd26beab3 100644 --- a/gnu/local.mk +++ b/gnu/local.mk @@ -381,6 +381,7 @@ GNU_SYSTEM_MODULES =3D \ %D%/packages/suckless.scm \ %D%/packages/swig.scm \ %D%/packages/sync.scm \ + %D%/packages/syncthing.scm \ %D%/packages/synergy.scm \ %D%/packages/syndication.scm \ %D%/packages/task-management.scm \ diff --git a/gnu/packages/syncthing.scm b/gnu/packages/syncthing.scm new file mode 100644 index 000000000..1dffb9f18 --- /dev/null +++ b/gnu/packages/syncthing.scm @@ -0,0 +1,1845 @@ +;;; GNU Guix --- Functional package management for GNU +;;; Copyright =A9 2016 Petter +;;; Copyright =A9 2016, 2017 Leo Famulari +;;; +;;; This file is part of GNU Guix. +;;; +;;; GNU Guix is free software; you can redistribute it and/or modify it +;;; under the terms of the GNU General Public License as published by +;;; the Free Software Foundation; either version 3 of the License, or (at +;;; your option) any later version. +;;; +;;; GNU Guix 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 +;;; GNU General Public License for more details. +;;; +;;; You should have received a copy of the GNU General Public License +;;; along with GNU Guix. If not, see . + +(define-module (gnu packages syncthing) + #:use-module (guix build-system go) + #:use-module (guix build-system trivial) + #:use-module (guix packages) + #:use-module (guix download) + #:use-module (guix git-download) + #:use-module (guix licenses)) + +(define-public syncthing + (package + (name "syncthing") + (version "0.14.38") + (source (origin + (method url-fetch) + (uri (string-append "https://github.com/syncthing/syncthing" + "/releases/download/v" version + "/syncthing-source-v" version ".tar.gz")) + (sha256 + (base32 + "0zh4096vr47mxh0823xzyigz55kdh0lg2lil15bm5v8jxfpmpmfg")))) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/syncthing/syncthing" + #:unpack-path "github.com/syncthing" + #:phases + (modify-phases %standard-phases + (add-after 'unpack 'delete-bundled-source-code + (lambda _ + ;; Keep the bundled cznic libraries. There are some "internal" + ;; cznic libraries that complicate the use of non-bundled cop= ies. + (rename-file "src/github.com/syncthing/syncthing/vendor/githu= b.com/cznic" + "cznic") + (delete-file-recursively "src/github.com/syncthing/syncthing/= vendor") + (mkdir-p "src/github.com/syncthing/syncthing/vendor/github.co= m/") + (rename-file "cznic" + "src/github.com/syncthing/syncthing/vendor/githu= b.com/cznic") + #t)) + + ;; We don't need to install the source code for end-user applicat= ions. + (delete 'install-source) + + (add-before 'build 'increase-test-timeout + (lambda _ + (substitute* "src/github.com/syncthing/syncthing/build.go" + (("60s") "999s")) + #t)) + + (replace 'build + (lambda* (#:key inputs #:allow-other-keys) + (with-directory-excursion "src/github.com/syncthing/syncthing" + (zero? (system* "go" "run" "build.go" "-no-upgrade"))))) + + (replace 'check + (lambda _ + (with-directory-excursion "src/github.com/syncthing/syncthing" + (zero? (system* "go" "run" "build.go" "test"))))) + + (replace 'install + (lambda _ + (copy-recursively "src/github.com/syncthing/syncthing/bin/" + (string-append (assoc-ref %outputs "out") "= /bin")) + #t)) + + (add-after 'install 'install-docs + (lambda* (#:key outputs #:allow-other-keys) + (let* ((out (assoc-ref outputs "out")) + (man (string-append out "/share/man/man")) + (src "src/github.com/syncthing/syncthing/man/")) + (for-each + (lambda (file) + (install-file file + (string-append man (string-take-right fil= e 1)))) + (find-files src "\\.[1-9]")) + #t)))))) + (inputs + `(("golang-github-com-audriusbutkevicius-cli" + ,golang-github-com-audriusbutkevicius-cli) + ("golang-github-com-audriusbutkevicius-kcp-go" + ,golang-github-com-audriusbutkevicius-kcp-go) + ("golang-github-com-audriusbutkevicius-go-nat-pmp" + ,golang-github-com-audriusbutkevicius-go-nat-pmp) + ("golang-github-com-audriusbutkevicius-pfilter" + ,golang-github-com-audriusbutkevicius-pfilter) + ("golang-github-com-bkaradzic-go-lz4" ,golang-github-com-bkaradzic-= go-lz4) + ("golang-github-com-calmh-du" ,golang-github-com-calmh-du) + ("golang-github-com-calmh-luhn" ,golang-github-com-calmh-luhn) + ("golang-github-com-calmh-xdr" ,golang-github-com-calmh-xdr) + ("golang-github-com-ccding-go-stun" + ,golang-github-com-ccding-go-stun) + ("golang-github-com-chmduquesne-rollinghash-adler32" + ,golang-github-com-chmduquesne-rollinghash-adler32) +; ("golang-github-com-cznic-ql" ,golang-github-com-cznic-ql) ; bundl= ed + ; Used by bundled ql + ("golang-github-com-edsrzf-mmap-go" ,golang-github-com-edsrzf-mmap-= go) + ("golang-github-com-gobwas-glob" ,golang-github-com-gobwas-glob) + ("golang-github-com-gogo-protobuf-union" + ,(golang-github-com-gogo-protobuf-union)) + ("golang-github-com-golang-groupcache-lru" + ,golang-github-com-golang-groupcache-lru) + ("golang-github-com-jackpal-gateway" ,golang-github-com-jackpal-gat= eway) + ("golang-github-com-kardianos-osext" ,golang-github-com-kardianos-o= sext) + ("golang-github-com-kballard-go-shellquote" + ,golang-github-com-kballard-go-shellquote) + ("golang-github-com-lib-pq" ,golang-github-com-lib-pq) + ("golang-github-com-minio-sha256-simd" ,golang-github-com-minio-sha= 256-simd) + ("golang-github-com-oschwald-geoip2-golang" + ,golang-github-com-oschwald-geoip2-golang) + ("golang-github-com-rcrowley-go-metrics" ,golang-github-com-rcrowle= y-go-metrics) + ("golang-github-com-sasha-s-go-deadlock" ,golang-github-com-sasha-s= -go-deadlock) + ("golang-github-com-syndtr-goleveldb" ,golang-github-com-syndtr-gol= eveldb) + ("golang-github-com-thejerf-suture" ,golang-github-com-thejerf-sutu= re) + ("golang-github-com-vitrun-qart" ,(golang-github-com-vitrun-qart-un= ion)) + ("golang-github-com-xtaci-smux" ,golang-github-com-xtaci-smux) + ("golang-org-x-crypto" ,(golang-org-x-crypto-union)) + ("golang.org-x-net" ,(golang-org-x-net-union)) + ("golang-org-x-text" ,(golang-org-x-text-union)) + ("golang-org-x-time-rate" ,golang-org-x-time-rate) + ; Tests + ("golang-github-com-d4l3k-messagediff" + ,golang-github-com-d4l3k-messagediff))) + (synopsis "Decentralized continuous filesystem synchronization") + (description "Syncthing is a peer-to-peer file synchronization tool th= at +supports a wide variety of computing platforms. It uses the Block Exchange +Protocol.") + (home-page "https://github.com/syncthing/syncthing") + (license mpl2.0))) + +(define-public golang-github-com-audriusbutkevicius-go-nat-pmp + (let ((commit "452c97607362b2ab5a7839b8d1704f0396b640ca") + (revision "0")) + (package + (name "golang-github-com-audriusbutkevicius-go-nat-pmp") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/AudriusButkevicius/go-nat-p= mp") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 "1accmpl1llk16a19nlyy991fqrgfay6l53gb64hgmdfmqljd= vbk7")))) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/AudriusButkevicius/go-nat-pmp")) + (synopsis "Port mapping and discovery of external IP address") + (description "This packages provides a Go client for the NAT-PMP int= ernet +protocol for port mapping and discovering the external IP address of a +firewall.") + (home-page "https://github.com/AudriusButkevicius/go-nat-pmp") + (license asl2.0)))) + +(define-public golang-github-com-bkaradzic-go-lz4 + (let ((commit "7224d8d8f27ef618c0a95f1ae69dbb0488abc33a") + (revision "0")) + (package + (name "golang-github-com-bkaradzic-go-lz4") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/bkaradzic/go-lz4") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "10lmya17vdqg2pvqni0p73iahni48s1v11ya9a0hcz4jh5vw4dkb"= )))) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/bkaradzic/go-lz4")) + (synopsis "LZ4 compression algorithm") + (description "This package provides @code{go-lz4}, a Go implementati= on of +the LZ4 compression algorithm.") + (home-page "https://github.com/bkaradzic/go-lz4") + (license bsd-2)))) + +(define-public golang-github-com-calmh-du + (package + (name "golang-github-com-calmh-du") + (version "1.0.1") + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/calmh/du") + (commit (string-append "v" version)))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "0qb3a6y3p9nkyn3s66k6zcm16y8n8578qh23ddj14cxf2scrr2n2")))) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/calmh/du")) + (synopsis "Get total and available disk space of a given volume") + (description "This is a Go implementation of `du`. It provides disk u= sage +information, such as how much storage space is available, free, and used.") + (home-page "https://github.com/calmh/du") + (license public-domain))) + +(define-public golang-github-com-calmh-luhn + (package + (name "golang-github-com-calmh-luhn") + (version "1.1.0") + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/calmh/luhn") + (commit (string-append "v" version)))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "0wr0wq20b1y3d9dgykwz6qhvic3ych39rzcfi60xi2vcb7a3jmxi")))) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/calmh/luhn")) + (synopsis "Luhn-mod-N implementation in Go") + (description "This packages provides a Luhn-mod-N implementation in Go= =2E") + (home-page "https://github.com/calmh/luhn") + (license expat))) + +(define-public golang-github-com-calmh-xdr + (let ((commit "08e072f9cb164f943a92eb59f90f3abc64ac6e8f") + (revision "0")) + (package + (name "golang-github-com-calmh-xdr") + (version (string-append "2.0.1-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/calmh/xdr") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "072wqdncz3nd4a3zkhvzzx1y3in1lm29wfvl0d8wrnqs5pyqh0mh"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/calmh/xdr")) + (synopsis "XDR marshalling and unmarshalling") + (description "XDR is an External Data Representation (XDR) +marshalling and unmarshalling library in Go. It uses code generation and = not +reflection.") + (home-page "https://github.com/calmh/xdr") + (license expat)))) + +(define-public golang-github-com-d4l3k-messagediff + (let ((commit "29f32d820d112dbd66e58492a6ffb7cc3106312b") + (revision "0")) + (package + (name "golang-github-com-d4l3k-messagediff") + (version (string-append "1.1.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/d4l3k/messagediff") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "104hl8x57ciaz7mzafg1vp9qggxcyfm8hsv9bmlihbz9ml3nyr8v"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/d4l3k/messagediff")) + (synopsis "Diff arbitrary Go structs") + (description "Messagediff is a library for calculating diffs of arbi= trary +structs in the Go programming language.") + (home-page "https://github.com/d4l3k/messagediff") + (license expat)))) + +(define-public golang-github-com-edsrzf-mmap-go + (let ((commit "0bce6a6887123b67a60366d2c9fe2dfb74289d2e") + (revision "0")) + (package + (name "golang-github-com-edsrzf-mmap-go") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/edsrzf/mmap-go") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "1am4m2k451bksnbiqj6lxknk4lsgmrhv0q3ajqac818vj0cpfgs9"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/edsrzf/mmap-go")) + (synopsis "Go implementation of mmap") + (description "This packages provides a Go implementation of mmap.") + (home-page "https://github.com/edsrzf/mmap-go") + (license bsd-3)))) + +(define-public golang-github-com-gobwas-glob + (let ((commit "51eb1ee00b6d931c66d229ceeb7c31b985563420") + (revision "0")) + (package + (name "golang-github-com-gobwas-glob") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/gobwas/glob") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "090wzpwsjana1qas8ipwh1pj959gvc4b7vwybzi01f3bmd79jwlp"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/gobwas/glob")) + (synopsis "Go globbing library") + (description "This packages provides a Go implementation of globs.") + (home-page "https://github.com/gobwas/glob") + (license expat)))) + +(define* (golang-github-com-gogo-protobuf-union + #:optional (packages (list golang-github-com-gogo-protobuf + golang-github-com-gogo-protobuf-prot= oc-gen-gogo))) + (package + (name "golang-github-com-gogo-protobuf-union") + (version (package-version golang-github-com-gogo-protobuf)) + (source #f) + (build-system trivial-build-system) + (arguments + '(#:modules ((guix build union)) + #:builder (begin + (use-modules (ice-9 match) + (guix build union)) + (match %build-inputs + (((names . directories) ...) + (union-build (assoc-ref %outputs "out") + directories)))))) + (inputs (map (lambda (package) + (list (package-name package) package)) + packages)) + (synopsis "Union of Go protobuf libraries") + (description "This is a union of Go protobuf libraries") + (home-page (package-home-page golang-github-com-gogo-protobuf)) + (license (package-license golang-github-com-gogo-protobuf)))) + +(define-public golang-github-com-gogo-protobuf + (let ((commit "efccd33a0c20aa078705571d5ddbfa14c8395a63") + (revision "0")) + (package + (name "golang-github-com-gogo-protobuf") + (version (string-append "0.2-" revision "." (string-take commit 7))) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/gogo/protobuf") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "09kfa3aqmhh7p0rc6wd4fw5cjccidsk9vgcy13albv0g8vnbmmgw"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/gogo/protobuf/proto" + #:unpack-path "github.com/gogo/protobuf")) + (propagated-inputs + `(("golang-github-com-gogo-protobuf-protoc-gen-gogo" + ,golang-github-com-gogo-protobuf-protoc-gen-gogo))) + (synopsis "Protocol Buffers for Go with Gadgets") + (description "Gogoprotobuf is a fork of golang/protobuf with extra c= ode +generation features. This code generation is used to achieve: +@itemize +@item fast marshalling and unmarshalling +@item more canonical Go structures +@item goprotobuf compatibility +@item less typing by optionally generating extra helper code +@item peace of mind by optionally generating test and benchmark code +@item other serialization formats +@end itemize") + (home-page "https://github.com/gogo/protobuf") + (license bsd-3)))) + +(define-public golang-github-com-gogo-protobuf-protoc-gen-gogo + (let ((commit "efccd33a0c20aa078705571d5ddbfa14c8395a63") + (revision "0")) + (package + (name "golang-github-com-gogo-protobuf-protoc-gen-gogo") + (version (string-append "0.2-" revision "0" (string-take commit 7))) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/gogo/protobuf") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "09kfa3aqmhh7p0rc6wd4fw5cjccidsk9vgcy13albv0g8vnbmmgw"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/gogo/protobuf/protoc-gen-gogo" + #:unpack-path "github.com/gogo/protobuf")) + (synopsis "Protocol Buffers for Go with Gadgets") + (description "Gogoprotobuf is a fork of golang/protobuf with extra c= ode +generation features. This code generation is used to achieve: +@itemize +@item fast marshalling and unmarshalling +@item more canonical Go structures +@item goprotobuf compatibility +@item less typing by optionally generating extra helper code +@item peace of mind by optionally generating test and benchmark code +@item other serialization formats +@end itemize") + (home-page "https://github.com/gogo/protobuf") + (license bsd-3)))) + +(define-public golang-github-com-golang-groupcache-lru + (let ((commit "72d04f9fcdec7d3821820cc4a6f150eae553639a") + (revision "0")) + (package + (name "golang-github-com-golang-groupcache-lru") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/golang/groupcache") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "1l3ryh7bq1f2mhr3sd3x1wav99pd27r8l3ydgqh375wn4x7v5qd6"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/golang/groupcache/lru" + #:unpack-path "github.com/golang/groupcache")) + (synopsis "Groupcache is a caching and cache-filling library") + (description "Groupcache is a caching and cache-filling library, int= ended +as a replacement for memcached in many cases. It provides a data loading +mechanism with caching and de-duplication that works across a set of peer +processes.") + (home-page "https://github.com/golang/groupcache") + (license asl2.0)))) + +(define-public golang-github-com-golang-snappy + (let ((commit "553a641470496b2327abcac10b36396bd98e45c9") + (revision "0")) + (package + (name "golang-github-com-golang-snappy") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/golang/snappy") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "0kssxnih1l722hx9219c7javganjqkqhvl3i0hp0hif6xm6chvqk"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/golang/snappy")) + (synopsis "Snappy compression format in the Go programming language") + (description "This package provides a Go implementation of the Snappy +compression format.") + (home-page "https://github.com/golang/snappy") + (license bsd-3)))) + +(define-public golang-github-com-jackpal-gateway + (let ((commit "5795ac81146e01d3fab7bcf21c043c3d6a32b006") + (revision "0")) + (package + (name "golang-github-com-jackpal-gateway") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/jackpal/gateway") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "0fkwkwmhfadwk3cha8616bhqxfkr9gjjnynhhxyldlphixgs3f25"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/jackpal/gateway")) + (synopsis "Discover the address of a LAN gateway") + (description "@code{gateway} is a Go library for discovering the IP +address of the default LAN gateway.") + (home-page "https://github.com/jackpal/gateway") + (license bsd-3)))) + +(define-public golang-github-com-kardianos-osext + (let ((commit "9d302b58e975387d0b4d9be876622c86cefe64be") + (revision "0")) + (package + (name "golang-github-com-kardianos-osext") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/kardianos/osext") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "0r6f727s16g4f66k8c2z1xh8ga1p53hg9g2v95pmhd1i60fhy47a"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/kardianos/osext")) + (synopsis "Find the running executable") + (description "Osext provides a method for finding the current execut= able +file that is running. This can be used for upgrading the current executab= le or +finding resources located relative to the executable file.") + (home-page "https://github.com/kardianos/osext") + (license bsd-3)))) + +(define-public golang-github-com-lib-pq + (let ((commit "2704adc878c21e1329f46f6e56a1c387d788ff94") + (revision "0")) + (package + (name "golang-github-com-lib-pq") + (version (string-append "0.0.0" revision "." (string-take commit 7))) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/lib/pq") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "160fmvi7bczxw3i3h5s821hv029ph5ld8x3c36b4cz2sr30wp110"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/lib/pq" + ;; The tests seem to fail without access to the network or a runn= ing + ;; Postgres instance. + #:tests? #f)) + (synopsis "Golang Postgres driver for Go's database/sql") + (description "This packages provides a pure Go Postgres driver for G= o's +database/sql package.") + (home-page "https://github.com/lib/pq") + (license expat)))) + +(define-public golang-github-com-minio-sha256-simd + (let ((commit "6124d070eb4e7001c244b6ccc282620a5dce44a0") + (revision "0")) + (package + (name "golang-github-com-minio-sha256-simd") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/minio/sha256-simd") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "1azrdp7x7vl9ngkxs890blspz0345xhadvssdlb0435hdqa0gkll"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/minio/sha256-simd")) + (synopsis "Hardware-accelerated SHA256 in Go using SIMD") + (description "This packages provides a pure Go implementation of SHA= 256 +using SIMD (Single instruction, multiple data) instructions for Intel and = ARM +architectures.") + (home-page "https://github.com/minio/sha256-simd") + (license asl2.0)))) + +(define-public golang-github-com-oschwald-geoip2-golang + (let ((commit "0fd242da7906550802871efe101abfdb1cc550a8") + (revision "0")) + (package + (name "golang-github-com-oschwald-geoip2-golang") + (version (string-append "0.1.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/oschwald/geoip2-golang") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "0kglnix0r5sjkk346ip30l7dwq1gv2g4wjy2cjmgjvb8x778hnww"))= )) + (build-system go-build-system) + (propagated-inputs + `(("golang-github-com-oschwald-maxminddb-golang" + ,golang-github-com-oschwald-maxminddb-golang) + ("golang-org-x-sys-unix" ,golang-org-x-sys-unix))) + (arguments + `(#:import-path "github.com/oschwald/geoip2-golang" + #:tests? #f)) ; Requires some unpackaged software and test data + (synopsis "MaxMind GeoIP2 reader") + (description "This packages provides a library for reading MaxMind +GeoLite2 and GeoIP2 databases in Go.") + (home-page "https://github.com/oschwald/geoip2-golang") + (license isc)))) + +(define-public golang-github-com-oschwald-maxminddb-golang + (let ((commit "697da8075d2061aa8ed639346443f5d3e8c80b30") + (revision "0")) + (package + (name "golang-github-com-oschwald-maxminddb-golang") + (version (string-append "0.2.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/oschwald/maxminddb-golang") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "00kkxzlvra0kcbkl56wp0dp1yw3cmfjqqlwbqy7bq5r34s7iavq0"))= )) + (build-system go-build-system) + (propagated-inputs + `(("golang-org-x-sys-unix" ,golang-org-x-sys-unix))) + (arguments + `(#:import-path "github.com/oschwald/maxminddb-golang" + #:tests? #f)) ; Requires some unpackaged software and test data + (synopsis "MaxMind DB Reader for Go") + (description "This is a Go reader for the MaxMind DB format. Althou= gh +this can be used to read GeoLite2 and GeoIP2 databases, @code{geoip2} prov= ides a +higher-level API for doing so.") + (home-page "https://github.com/oschwald/maxminddb-golang") + (license isc)))) + +(define-public golang-github-com-rcrowley-go-metrics + (let ((commit "1f30fe9094a513ce4c700b9a54458bbb0c96996c") + (revision "0")) + (package + (name "golang-github-com-rcrowley-go-metrics") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/rcrowley/go-metrics") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "1hvbiaq4b6dqgjz6jkkxglfh9gf71zin6qsg508sh0r0ixfavrzj"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/rcrowley/go-metrics")) + (synopsis "Go port of Coda Hale's Metrics library") + (description "This package provides a Go implementation of Coda Hale= 's +Metrics library.") + (home-page "https://github.com/rcrowley/go-metrics") + (license bsd-2)))) + +(define-public golang-github-com-sasha-s-go-deadlock + (let ((commit "341000892f3dd25f440e6231e8533eb3688ed7ec") + (revision "0")) + (package + (name "golang-github-com-sasha-s-go-deadlock") + (version (string-append "0.1.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/sasha-s/go-deadlock") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "1bcdyxwm5qpqynxahwaahbqi7ghgdajmg7b4276pdalkxkxkhsv8"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/sasha-s/go-deadlock")) + (propagated-inputs + `(("golang-github-com-petermattis-goid" ,golang-github-com-petermat= tis-goid))) + (synopsis "Deadlock detection in go") + (description "This package provides tools for detecting deadlocks at +run-time in Go.") + (home-page "https://github.com/sasha-s/go-deadlock") + (license asl2.0)))) + +(define-public golang-github-com-stathat-go + (let ((commit "74669b9f388d9d788c97399a0824adbfee78400e") + (revision "0")) + (package + (name "golang-github-com-stathat-go") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/stathat/go") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 "105ql5v8r4hqcsq0ag7asdxqg9n7rvf83y1q1dj2nfjyn4ma= nv6r")))) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/stathat/go")) + (synopsis "Post statistics to StatHat") + (description "This is a Go package for posting to a StatHat account.= ") + (home-page "https://github.com/stathat/go") + (license expat)))) + +(define-public golang-github-com-syndtr-goleveldb + (let ((commit "3c5717caf1475fd25964109a0fc640bd150fce43") + (revision "0")) + (package + (name "golang-github-com-syndtr-goleveldb") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/syndtr/goleveldb") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "0wng25bw885ppiny9rz42kq0a7ddkym5zl0glb8rfk0m8dpvi1dd"))= )) + (build-system go-build-system) + (propagated-inputs + `(("github.com-golang-snappy" ,golang-github-com-golang-snappy))) + (arguments + `(#:import-path "github.com/syndtr/goleveldb/leveldb" + #:unpack-path "github.com/syndtr/goleveldb" + #:tests? #f)) ; XXX needs 'github.com/onsi/gomega' package + (synopsis "LevelDB key/value database") + (description "This is an implementation of the LevelDB key / value +database in Go.") + (home-page "https://github.com/syndtr/goleveldb") + (license bsd-2)))) + +(define-public golang-github-com-thejerf-suture + (let ((commit "0ac47afae95ad5bc5184ed346bc945168e883f5d") + (revision "0")) + (package + (name "golang-github-com-thejerf-suture") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/thejerf/suture") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "0f860fkaibnnkmh4q6q9yn3r26sraaj8wx9irwm76cmsp48zcxfy"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/thejerf/suture")) + (synopsis "Supervisor trees for Go") + (description "Suture provides Erlang-ish supervisor trees for Go. +\"Supervisor trees\" -> \"sutree\" -> \"suture\" -> holds your code togeth= er +when it's trying to die. + +It is intended to deal gracefully with the real failure cases that can occ= ur +with supervision trees (such as burning all your CPU time endlessly restar= ting +dead services), while also making no unnecessary demands on the \"service\" +code, and providing hooks to perform adequate logging with in a production +environment") + (home-page "https://github.com/thejerf/suture") + (license expat)))) + +(define* (golang-github-com-vitrun-qart-union + #:optional (packages (list golang-github-com-vitrun-qart-coding + golang-github-com-vitrun-qart-gf256 + golang-github-com-vitrun-qart-qr))) + (package + (name "golang-github-com-vitrun-qart") + (version (package-version golang-github-com-vitrun-qart-qr)) + (source #f) + (build-system trivial-build-system) + (arguments + '(#:modules ((guix build union)) + #:builder (begin + (use-modules (ice-9 match) + (guix build union)) + (match %build-inputs + (((names . directories) ...) + (union-build (assoc-ref %outputs "out") + directories)))))) + (inputs (map (lambda (package) + (list (package-name package) package)) + packages)) + (synopsis "Union of qart libraries") + (description "This is a union of qart libraries.") + (home-page (package-home-page golang-github-com-vitrun-qart-qr)) + (license (package-license golang-github-com-vitrun-qart-qr)))) + +(define-public golang-github-com-vitrun-qart-coding + (let ((commit "bf64b92db6b05651d6c25a3dabf2d543b360c0aa") + (revision "0")) + (package + (name "golang-github-com-vitrun-qart-coding") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/vitrun/qart") + (commit commit))) + (file-name (string-append "golang-github-com-vitrun-qart-" + version "-checkout")) + (sha256 + (base32 + "1xk7qki703xmay9ghi3kq2bjf1iw9dz8wik55739d6i7sn77vvkc"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/vitrun/qart/coding" + #:unpack-path "github.com/vitrun/qart")) + (synopsis "Low-level QR coding library") + (description "This package provides a library for embedding +human-meaningful graphics in QR codes. However, instead of scribbling on +redundant pieces and relying on error correction to preserve the meaning, +@code{qart} engineers the encoded values to create the picture in a code w= ith no +inherent errors. This @code{qart} component, @code{coding}, implements +low-level QR coding details.") + (home-page "https://github.com/vitrun/qart/") + (license bsd-3)))) + +(define-public golang-github-com-vitrun-qart-gf256 + (let ((commit "bf64b92db6b05651d6c25a3dabf2d543b360c0aa") + (revision "0")) + (package + (name "golang-github-com-vitrun-qart-gf256") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/vitrun/qart") + (commit commit))) + (file-name (string-append "golang-github-com-vitrun-qart-" + version "-checkout")) + (sha256 + (base32 + "1xk7qki703xmay9ghi3kq2bjf1iw9dz8wik55739d6i7sn77vvkc"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/vitrun/qart/gf256" + #:unpack-path "github.com/vitrun/qart")) + (synopsis "Qart library for Galois Field GF(256) math") + (description "This package, a component of @code{qart}, provides @co= de{gf256}, +implements arithmetic over the Galois Field GF(256).") + (home-page "https://github.com/vitrun/qart") + (license bsd-3)))) + +(define-public golang-github-com-vitrun-qart-qr + (let ((commit "bf64b92db6b05651d6c25a3dabf2d543b360c0aa") + (revision "0")) + (package + (name "golang-github-com-vitrun-qart-qr") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/vitrun/qart") + (commit commit))) + (file-name (string-append "golang-github-com-vitrun-qart-" + version "-checkout")) + (sha256 + (base32 + "1xk7qki703xmay9ghi3kq2bjf1iw9dz8wik55739d6i7sn77vvkc"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/vitrun/qart/qr" + #:unpack-path "github.com/vitrun/qart")) + (synopsis "Qart component for generating QR codes") + (description "This package, a component of @code{qart}, provides +@code{qr}, for QR code generation.") + (description "This package provides a library for embedding +human-meaningful graphics in QR codes. However, instead of scribbling on +redundant pieces and relying on error correction to preserve the meaning, +@code{qart} engineers the encoded values to create the picture in a code w= ith no +inherent errors. This @code{qart} component, @code{qr}, provides QR code +generation.") + (home-page "https://github.com/vitrun/qart") + (license bsd-3)))) + +;; Go searches for library modules by looking in the GOPATH environment +;; variable. This variable is a list of paths. However, Go does not +;; keep searching on GOPATH if it tries and fails to import a module. +;; So, we use a union for packages sharing a namespace. +(define* (golang-org-x-crypto-union #:optional + (packages (list golang-org-x-crypto-bl= owfish + golang-org-x-crypto-bc= rypt + golang-org-x-crypto-tea + golang-org-x-crypto-xt= ea + golang-org-x-crypto-pb= kdf2 + golang-org-x-crypto-tw= ofish + golang-org-x-crypto-ca= st5 + golang-org-x-crypto-sa= lsa20))) + (package + (name "golang-org-x-crypto") + (version (package-version golang-org-x-crypto-bcrypt)) + (source #f) + (build-system trivial-build-system) + (arguments + '(#:modules ((guix build union)) + #:builder (begin + (use-modules (ice-9 match) + (guix build union)) + (match %build-inputs + (((names . directories) ...) + (union-build (assoc-ref %outputs "out") + directories)))))) + (inputs (map (lambda (package) + (list (package-name package) package)) + packages)) + (synopsis "Union of the Go x crypto libraries") + (description "A union of the Golang cryptographic libraries. A +union is required because `go build` assumes that all of the headers and +libraries are in the same directory.") + (home-page (package-home-page golang-org-x-crypto-bcrypt)) + (license (package-license golang-org-x-crypto-bcrypt)))) + +(define-public golang-org-x-crypto-bcrypt + (let ((commit "c78caca803c95773f48a844d3dcab04b9bc4d6dd") + (revision "0")) + (package + (name "golang-org-x-crypto-bcrypt") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://go.googlesource.com/crypto") + (commit commit))) + (file-name (string-append "go.googlesource.com-crypto-" + version "-checkout")) + (sha256 + (base32 + "0vxlfxr9y681yn2cfh6dbqmq35vvq4f45ay0mm31ffkny9cms0y4"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "golang.org/x/crypto/bcrypt" + #:unpack-path "golang.org/x/crypto" + #:phases + (modify-phases %standard-phases + (add-before 'reset-gzip-timestamps 'make-gzip-archive-writable + (lambda* (#:key outputs #:allow-other-keys) + (map (lambda (file) + (make-file-writable file)) + (find-files + (string-append (assoc-ref outputs "out") + "/src/golang.org/x/crypto/ed25519/tes= tdata") + ".*\\.gz$")) + #t))))) + (synopsis "Bcrypt in Go") + (description "This package provides a Go implementation of the bcrypt +password hashing function.") + (home-page "https://go.googlesource.com/crypto/") + (license bsd-3)))) + +(define-public golang-org-x-crypto-blowfish + (let ((commit "c78caca803c95773f48a844d3dcab04b9bc4d6dd") + (revision "0")) + (package + (name "golang-org-x-crypto-blowfish") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://go.googlesource.com/crypto") + (commit commit))) + (file-name (string-append "go.googlesource.com-crypto-" + version "-checkout")) + (sha256 + (base32 + "0vxlfxr9y681yn2cfh6dbqmq35vvq4f45ay0mm31ffkny9cms0y4"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "golang.org/x/crypto/blowfish" + #:unpack-path "golang.org/x/crypto" + #:phases + (modify-phases %standard-phases + (add-before 'reset-gzip-timestamps 'make-gzip-archive-writable + (lambda* (#:key outputs #:allow-other-keys) + (map (lambda (file) + (make-file-writable file)) + (find-files + (string-append (assoc-ref outputs "out") + "/src/golang.org/x/crypto/ed25519/tes= tdata") + ".*\\.gz$")) + #t))))) + (synopsis "Blowfish in Go") + (description "This package provides a Go implementation of the Blowf= ish +symmetric-key block cipher.") + (home-page "https://go.googlesource.com/crypto/") + (license bsd-3)))) + +(define-public golang-org-x-crypto-pbkdf2 + (let ((commit "c78caca803c95773f48a844d3dcab04b9bc4d6dd") + (revision "0")) + (package + (name "golang-org-x-crypto-pbkdf2") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://go.googlesource.com/crypto") + (commit commit))) + (file-name (string-append "go.googlesource.com-crypto-" + version "-checkout")) + (sha256 + (base32 + "0vxlfxr9y681yn2cfh6dbqmq35vvq4f45ay0mm31ffkny9cms0y4"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "golang.org/x/crypto/pbkdf2" + #:unpack-path "golang.org/x/crypto" + #:phases + (modify-phases %standard-phases + (add-before 'reset-gzip-timestamps 'make-gzip-archive-writable + (lambda* (#:key outputs #:allow-other-keys) + (map (lambda (file) + (make-file-writable file)) + (find-files + (string-append (assoc-ref outputs "out") + "/src/golang.org/x/crypto/ed25519/tes= tdata") + ".*\\.gz$")) + #t))))) + (synopsis "PBKDF2 in Go") + (description "This package provides a Go implementation of the PBKDF= 2 key +derivation function.") + (home-page "https://go.googlesource.com/crypto/") + (license bsd-3)))) + +(define-public golang-org-x-crypto-tea + (let ((commit "c78caca803c95773f48a844d3dcab04b9bc4d6dd") + (revision "0")) + (package + (name "golang-org-x-crypto-tea") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://go.googlesource.com/crypto") + (commit commit))) + (file-name (string-append "go.googlesource.com-crypto-" + version "-checkout")) + (sha256 + (base32 + "0vxlfxr9y681yn2cfh6dbqmq35vvq4f45ay0mm31ffkny9cms0y4"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "golang.org/x/crypto/tea" + #:unpack-path "golang.org/x/crypto" + #:phases + (modify-phases %standard-phases + (add-before 'reset-gzip-timestamps 'make-gzip-archive-writable + (lambda* (#:key outputs #:allow-other-keys) + (map (lambda (file) + (make-file-writable file)) + (find-files + (string-append (assoc-ref outputs "out") + "/src/golang.org/x/crypto/ed25519/tes= tdata") + ".*\\.gz$")) + #t))))) + (synopsis "Tiny Encryption Algorithm (TEA) in Go") + (description "This packages a Go implementation of the Tiny Encrypti= on +Algorithm (TEA) block cipher.") + (home-page "https://go.googlesource.com/crypto/") + (license bsd-3)))) + +(define-public golang-org-x-crypto-salsa20 + (let ((commit "c78caca803c95773f48a844d3dcab04b9bc4d6dd") + (revision "0")) + (package + (name "golang-org-x-crypto-salsa20") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://go.googlesource.com/crypto") + (commit commit))) + (file-name (string-append "go.googlesource.com-crypto-" + version "-checkout")) + (sha256 + (base32 + "0vxlfxr9y681yn2cfh6dbqmq35vvq4f45ay0mm31ffkny9cms0y4"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "golang.org/x/crypto/salsa20" + #:unpack-path "golang.org/x/crypto" + #:phases + (modify-phases %standard-phases + (add-before 'reset-gzip-timestamps 'make-gzip-archive-writable + (lambda* (#:key outputs #:allow-other-keys) + (map (lambda (file) + (make-file-writable file)) + (find-files + (string-append (assoc-ref outputs "out") + "/src/golang.org/x/crypto/ed25519/tes= tdata") + ".*\\.gz$")) + #t))))) + (synopsis "Salsa20 in Go") + (description "This packages provides a Go implementation of the Sals= a20 +stream cipher.") + (home-page "https://go.googlesource.com/crypto/") + (license bsd-3)))) + +(define-public golang-org-x-crypto-cast5 + (let ((commit "c78caca803c95773f48a844d3dcab04b9bc4d6dd") + (revision "0")) + (package + (name "golang-org-x-crypto-cast5") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://go.googlesource.com/crypto") + (commit commit))) + (file-name (string-append "go.googlesource.com-crypto-" + version "-checkout")) + (sha256 + (base32 + "0vxlfxr9y681yn2cfh6dbqmq35vvq4f45ay0mm31ffkny9cms0y4"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "golang.org/x/crypto/cast5" + #:unpack-path "golang.org/x/crypto" + #:phases + (modify-phases %standard-phases + (add-before 'reset-gzip-timestamps 'make-gzip-archive-writable + (lambda* (#:key outputs #:allow-other-keys) + (map (lambda (file) + (make-file-writable file)) + (find-files + (string-append (assoc-ref outputs "out") + "/src/golang.org/x/crypto/ed25519/tes= tdata") + ".*\\.gz$")) + #t))))) + (synopsis "Cast5 in Go") + (description "This packages provides a Go implementation of the Cast5 +symmetric-key block cipher.") + (home-page "https://go.googlesource.com/crypto/") + (license bsd-3)))) + +(define-public golang-org-x-crypto-twofish + (let ((commit "c78caca803c95773f48a844d3dcab04b9bc4d6dd") + (revision "0")) + (package + (name "golang-org-x-crypto-twofish") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://go.googlesource.com/crypto") + (commit commit))) + (file-name (string-append "go.googlesource.com-crypto-" + version "-checkout")) + (sha256 + (base32 + "0vxlfxr9y681yn2cfh6dbqmq35vvq4f45ay0mm31ffkny9cms0y4"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "golang.org/x/crypto/twofish" + #:unpack-path "golang.org/x/crypto" + #:phases + (modify-phases %standard-phases + (add-before 'reset-gzip-timestamps 'make-gzip-archive-writable + (lambda* (#:key outputs #:allow-other-keys) + (map (lambda (file) + (make-file-writable file)) + (find-files + (string-append (assoc-ref outputs "out") + "/src/golang.org/x/crypto/ed25519/tes= tdata") + ".*\\.gz$")) + #t))))) + (synopsis "Twofish in Go") + (description "This packages provides a Go implementation of the Twof= ish +symmetric-key block cipher.") + (home-page "https://go.googlesource.com/crypto/") + (license bsd-3)))) + +(define-public golang-org-x-crypto-xtea + (let ((commit "c78caca803c95773f48a844d3dcab04b9bc4d6dd") + (revision "0")) + (package + (name "golang-org-x-crypto-xtea") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://go.googlesource.com/crypto") + (commit commit))) + (file-name (string-append "go.googlesource.com-crypto-" + version "-checkout")) + (sha256 + (base32 + "0vxlfxr9y681yn2cfh6dbqmq35vvq4f45ay0mm31ffkny9cms0y4"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "golang.org/x/crypto/xtea" + #:unpack-path "golang.org/x/crypto" + #:phases + (modify-phases %standard-phases + (add-before 'reset-gzip-timestamps 'make-gzip-archive-writable + (lambda* (#:key outputs #:allow-other-keys) + (map (lambda (file) + (make-file-writable file)) + (find-files + (string-append (assoc-ref outputs "out") + "/src/golang.org/x/crypto/ed25519/tes= tdata") + ".*\\.gz$")) + #t))))) + (synopsis "eXtended Tiny Encryption Algorithm (XTEA) in Go") + (description "This package provides a Go implementation of the eXten= ded +Tiny Encryption Algorithm (XTEA) block cipher.") + (home-page "https://go.googlesource.com/crypto/") + (license bsd-3)))) + +(define* (golang-org-x-net-union #:optional + (packages (list golang-org-x-net-ipv4 + golang-org-x-net-bpf + golang-org-x-net-context + golang-org-x-net-ipv6 + golang-org-x-net-proxy + golang-org-x-net-internal= -iana))) + (package + (name "golang-org-x-net") + (version (package-version golang-org-x-net-ipv4)) + (source #f) + (build-system trivial-build-system) + (arguments + '(#:modules ((guix build union)) + #:builder (begin + (use-modules (ice-9 match) + (guix build union)) + (match %build-inputs + (((names . directories) ...) + (union-build (assoc-ref %outputs "out") + directories)))))) + (inputs (map (lambda (package) + (list (package-name package) package)) + packages)) + (synopsis "Union of the Go net libraries") + (description "A union of the Golang net libraries.") + (home-page (package-home-page golang-org-x-net-ipv4)) + (license (package-license golang-org-x-net-ipv4)))) + +(define-public golang-org-x-net-ipv4 + (let ((commit "ffcf1bedda3b04ebb15a168a59800a73d6dc0f4d") + (revision "0")) + (package + (name "golang-org-x-net-ipv4") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://go.googlesource.com/net") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "1ifqw09pj9q23mza1d0im99yy3jp72dvq9dcx2bs1n1m11cjdjzp"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "golang.org/x/net/ipv4" + #:unpack-path "golang.org/x/net")) + (synopsis "Go IPv4 support") + (description "This package provides @code{ipv4}, which implements IP= -level +socket options for the Internet Protocol version 4.") + (home-page "https://go.googlesource.com/net") + (license bsd-3)))) + +(define-public golang-org-x-net-bpf + (let ((commit "ffcf1bedda3b04ebb15a168a59800a73d6dc0f4d") + (revision "0")) + (package + (name "golang-org-x-net-bpf") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://go.googlesource.com/net") + (commit commit))) + (file-name (string-append "go.googlesource.com-net-" + version "-checkout")) + (sha256 + (base32 + "1ifqw09pj9q23mza1d0im99yy3jp72dvq9dcx2bs1n1m11cjdjzp"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "golang.org/x/net/bpf" + #:unpack-path "golang.org/x/net")) + (synopsis "Berkeley Packet Filters (BPF) in Go") + (description "This packages provides a Go implementation of the Berk= eley +Packet Filter (BPF) virtual machine.") + (home-page "https://go.googlesource.com/net/") + (license bsd-3)))) + +(define-public golang-org-x-net-context + (let ((commit "ffcf1bedda3b04ebb15a168a59800a73d6dc0f4d") + (revision "0")) + (package + (name "golang-org-x-net-context") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://go.googlesource.com/net") + (commit commit))) + (file-name (string-append "go.googlesource.com-net-" + version "-checkout")) + (sha256 + (base32 + "1ifqw09pj9q23mza1d0im99yy3jp72dvq9dcx2bs1n1m11cjdjzp"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "golang.org/x/net/context" + #:unpack-path "golang.org/x/net")) + (synopsis "Golang Context type") + (description "This packages provides @code{context}, which defines t= he +Context type, which carries deadlines, cancelation signals, and other +request-scoped values across API boundaries and between processes.") + (home-page "https://go.googlesource.com/net/") + (license bsd-3)))) + +(define-public golang-org-x-net-internal-iana + (let ((commit "ffcf1bedda3b04ebb15a168a59800a73d6dc0f4d") + (revision "0")) + (package + (name "golang-org-x-net-internal-iana") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://go.googlesource.com/net") + (commit commit))) + (file-name (string-append "go.googlesource.com-net-" + version "-checkout")) + (sha256 + (base32 + "1ifqw09pj9q23mza1d0im99yy3jp72dvq9dcx2bs1n1m11cjdjzp"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "golang.org/x/net/internal/iana" + #:unpack-path "golang.org/x/net")) + (synopsis "Go support for assigned numbers (IANA)") + (description "This packages provides @code{iana}, which provides pro= tocol +number resources managed by the Internet Assigned Numbers Authority (IANA)= =2E") + (home-page "https://go.googlesource.com/net/") + (license bsd-3)))) + +(define-public golang-org-x-net-ipv6 + (let ((commit "ffcf1bedda3b04ebb15a168a59800a73d6dc0f4d") + (revision "0")) + (package + (name "golang-org-x-net-ipv6") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://go.googlesource.com/net") + (commit commit))) + (file-name (string-append "go.googlesource.com-net-" + version "-checkout")) + (sha256 + (base32 + "1ifqw09pj9q23mza1d0im99yy3jp72dvq9dcx2bs1n1m11cjdjzp"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "golang.org/x/net/ipv6" + #:unpack-path "golang.org/x/net")) + (synopsis "Go IPv6 support") + (description "This packages provides @code{ipv6}, which implements +IP-level socket options for the Internet Protocol version 6.") + (home-page "https://go.googlesource.com/net") + (license bsd-3)))) + +(define-public golang-org-x-net-proxy + (let ((commit "ffcf1bedda3b04ebb15a168a59800a73d6dc0f4d") + (revision "0")) + (package + (name "golang-org-x-net-proxy") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://go.googlesource.com/net") + (commit commit))) + (file-name (string-append "go.googlesource.com-net-" + version "-checkout")) + (sha256 + (base32 + "1ifqw09pj9q23mza1d0im99yy3jp72dvq9dcx2bs1n1m11cjdjzp"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "golang.org/x/net/proxy" + #:unpack-path "golang.org/x/net/")) + (synopsis "Go support for network proxies") + (description "This packages provides @code{proxy}, which provides su= pport +for a variety of protocols to proxy network data.") + (home-page "https://go.googlesource.com/net") + (license bsd-3)))) + +(define-public golang-org-x-sys-unix + (let ((commit "f3918c30c5c2cb527c0b071a27c35120a6c0719a") + (revision "0")) + (package + (name "golang-org-x-sys-unix") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://go.googlesource.com/sys") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "02967mw0nq7hp39bcf8rdbid4jgz2fn6hd1x03mmavvca03scxbh"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "golang.org/x/sys/unix" + #:unpack-path "golang.org/x/sys")) + (synopsis "Go support for low-level system interaction") + (description "This package provides @code{unix}, which offers Go sup= port +for low-level interaction with the operating system.") + (home-page "https://go.googlesource.com/sys") + (license bsd-3)))) + +(define* (golang-org-x-text-union #:optional + (packages (list golang-org-x-text-transf= orm + golang-org-x-text-unicod= e-norm))) + (package + (name "golang-org-x-text") + (version (package-version golang-org-x-text-transform)) + (source #f) + (build-system trivial-build-system) + (arguments + '(#:modules ((guix build union)) + #:builder (begin + (use-modules (ice-9 match) + (guix build union)) + (match %build-inputs + (((names . directories) ...) + (union-build (assoc-ref %outputs "out") + directories)))))) + (inputs (map (lambda (package) + (list (package-name package) package)) + packages)) + (synopsis "Union of the Go text libraries") + (description "A union of the Golang text libraries.") + (home-page (package-home-page golang-org-x-text-transform)) + (license (package-license golang-org-x-text-transform)))) + +(define-public golang-org-x-text-transform + (let ((commit "f4b4367115ec2de254587813edaa901bc1c723a8") + (revision "0")) + (package + (name "golang-org-x-text-transform") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://go.googlesource.com/text") + (commit commit))) + (file-name (string-append "go.googlesource.com-text-" + version "-checkout")) + (sha256 + (base32 + "1a5m97y7sdxks02p4swg8ffp8bgr95aaf5fhfw511p7h3xg1dm0d"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "golang.org/x/text/transform" + #:unpack-path "golang.org/x/text")) + (synopsis "Go text transformation") + (description "This package provides @code{transform}, which provides +reader and writer wrappers that transform the bytes passing through. Exam= ple +transformations provided by other packages include normalization and conve= rsion +between character sets.") + (home-page "https://go.googlesource.com/text") + (license bsd-3)))) + +(define-public golang-org-x-text-unicode-norm + (let ((commit "f4b4367115ec2de254587813edaa901bc1c723a8") + (revision "0")) + (package + (name "golang-org-x-text-unicode-norm") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://go.googlesource.com/text") + (commit commit))) + (file-name (string-append "go.googlesource.com-text-" + version "-checkout")) + (sha256 + (base32 + "1a5m97y7sdxks02p4swg8ffp8bgr95aaf5fhfw511p7h3xg1dm0d"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "golang.org/x/text/unicode/norm" + #:unpack-path "golang.org/x/text")) + (synopsis "Unicode normalization in Go") + (description "This package provides @code{norm}, which contains type= s and +functions for normalizing Unicode strings.") + (home-page "https://go.googlesource.com/text") + (license bsd-3)))) + +(define-public golang-github-com-audriusbutkevicius-pfilter + (let ((commit "09b3cfdd04de89f0196caecb0b335d7149a6593a") + (revision "0")) + (package + (name "golang-github-com-audriusbutkevicius-pfilter") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/AudriusButkevicius/pfilter.git") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "176g8dmi2i94bxpnpgvj3dv5y9hripi45kbrfvy2bk884hwbp1zq")))) + (build-system go-build-system) + (arguments + '(#:import-path "github.com/AudriusButkevicius/pfilter")) + (synopsis "Filter packets into mulitple virtual connections") + (description "Pfilter is a Go package for filtering packets into mul= tiple +virtual connections from a single physical connection.") + (home-page "https://github.com/AudriusButkevicius/pfilter") + (license expat)))) + +(define-public golang-github-com-ccding-go-stun + (let ((commit "04a4eed61c57ecc9903f8983d1d2c17b88d2e9e1") + (revision "0")) + (package + (name "golang-github-com-ccding-go-stun") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/ccding/go-stun.git") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "09fgmkvm0vzinl3ifrixyyxk2c9hbahrja7i0ir400harzq3my10")))) + (build-system go-build-system) + (arguments + '(#:import-path "github.com/ccding/go-stun")) + (synopsis "STUN client implementation") + (description "Go-stun is a go implementation of the STUN client (RFC= 3489 +and RFC 5389).") + (home-page "https://github.com/ccding/go-stun") + (license asl2.0)))) + +(define-public golang-github-com-chmduquesne-rollinghash-adler32 + (let ((commit "043b8fdecc9816f0011a056f6d92f9a091ab63dd") + (revision "0")) + (package + (name "golang-github-com-chmduquesne-rollinghash-adler32") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/chmduquesne/rollinghash.git") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "0pc87laxgydqv03bdirfv32y9k0bdk2cwjxn28yh42nvay9p6y0k")))) + (build-system go-build-system) + (arguments + '(#:import-path "github.com/chmduquesne/rollinghash/adler32" + #:unpack-path "github.com/chmduquesne/rollinghash")) + (synopsis "Adler-32 rolling hash in Go") + (description "This package provides a Go implementation of the Adler= -32 +rolling hash.") + (home-page "https://github.com/chmduquesne/rollinghash") + (license expat)))) + +(define-public golang-github-com-audriusbutkevicius-kcp-go + (let ((commit "d17218ba2121268b854dd84f2bb54679541c4048") + (revision "0")) + (package + (name "golang-github-com-audriusbutkevicius-kcp-go") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/AudriusButkevicius/kcp-go") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "0faci7cfc7qs2vpsmjr3mcb72n7j8i4qk54dqczzzgi3z7gx6kbj")))) + (build-system go-build-system) + (propagated-inputs + `(("golang-org-x-net-ipv4" ,golang-org-x-net-ipv4) + ("golang-github-com-klauspost-reedsolomon" + ,golang-github-com-klauspost-reedsolomon) + ("golang-github-com-klauspost-cpuid" ,golang-github-com-klauspost= -cpuid) + ("golang-github-com-pkg-errors" ,golang-github-com-pkg-errors) + ("golang-org-x-crypto" ,(golang-org-x-crypto-union)) + ("golang-github-com-templexxx-xor" ,golang-github-com-templexxx-x= or))) + (arguments + '(#:import-path "github.com/AudriusButkevicius/kcp-go" + ;; 'TestListenerClose' is known to fail. It seems that the test s= uite + ;; is not being used upstream: + ;; https://github.com/AudriusButkevicius/kcp-go/pull/1 + #:tests? #f)) + (synopsis "Reliable UDP connections in Go") + (description "This package provides @code{kcp-go}, a reliable UDP li= brary +written in Go. It offers fast, ordered and error-checked delivery of stre= ams +over UDP packets.") + (home-page "https://github.com/xtaci/kcp-go") + (license expat)))) + +(define-public golang-github-com-templexxx-xor + (let ((commit "42f9c041c330b560afb991153bf183c25444bcdc") + (revision "0")) + (package + (name "golang-github-com-templexxx-xor") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/templexxx/xor.git") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "0ixzk64nyyzas4lyqxdih824xg5f5vph18vyiibmnflwd61m0i78")))) + (build-system go-build-system) + (arguments + '(#:import-path "github.com/templexxx/xor")) + (synopsis "XOR in Go") + (description "This packages provides a Go implementation of XOR.") + (home-page "https://github.com/templexxx/xor") + (license expat)))) + +(define-public golang-github-com-xtaci-smux + (let ((commit "0f6b9aaecaaf354357adc7def9239011ad276776") + (revision "0")) + (package + (name "golang-github-com-xtaci-smux") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/xtaci/smux.git") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "0wx9j0id2f5iqvyalhm4i80fr9k25klr7qqj8sd9acwp5vfl5fas")))) + (build-system go-build-system) + (propagated-inputs + `(("golang-github-com-pkg-errors" ,golang-github-com-pkg-errors))) + (arguments + '(#:import-path "github.com/xtaci/smux")) + (synopsis "Network multiplexing in Go") + (description "Smux ( Simple MUltipleXing) is a multiplexing library = for +Golang. It relies on an underlying connection to provide reliability and +ordering, such as TCP or KCP, and provides stream-oriented multiplexing.") + (home-page "https://github.com/xtaci/smux") + (license expat)))) + +(define-public golang-github-com-klauspost-reedsolomon + (let ((commit "5abf0ee302ccf4834e84f63ff74eca3e8b88e4e2") + (revision "0")) + (package + (name "golang-github-com-klauspost-reedsolomon") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/klauspost/reedsolomon.git") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "1za3db8zc76rg2f4kpvw4x8pykbyhmacnhdhyys73421f0m50a0s"))= )) + (build-system go-build-system) + (propagated-inputs + `(("golang-github-com-klauspost-cpuid" + ,golang-github-com-klauspost-cpuid))) + (arguments + `(#:import-path "github.com/klauspost/reedsolomon")) + (synopsis "Reed-Solomon Erasure Coding in Go") + (description "This package provides and implemenation of Reed-Solomon +Erasure Coding in Go.") + (home-page "https://github.com/klauspost/reedsolomon") + (license expat)))) + +(define-public golang-github-com-klauspost-cpuid + (let ((commit "09cded8978dc9e80714c4d85b0322337b0a1e5e0") + (revision "0")) + (package + (name "golang-github-com-klauspost-cpuid") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/klauspost/cpuid.git") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "05l8pfch0gvxh0khapwxhsk4xajn40vbjr360n49vh2z5531v2xq"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/klauspost/cpuid")) + (synopsis "CPU feature identification for Go") + (description "This package provides @code{cpuid}, which provides +information about the CPU running the current program. CPU features are +detected on startup, and kept for access through the life of the +application. Currently x86 / x64 (AMD64) is supported, and no external C = (cgo) +code is used.") + (home-page "https://github.com/klauspost/cpuid") + (license expat)))) + +(define-public golang-github-com-pkg-errors + (let ((commit "ff09b135c25aae272398c51a07235b90a75aa4f0") + (revision "0")) + (package + (name "golang-github-com-pkg-errors") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/pkg/errors.git") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "0pwl6v3hmc22zp32gkyqykl4kg69xk1mlp0vmhgd1f44difd5fvz"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "github.com/pkg/errors")) + (synopsis "Go error handling primitives") + (description "This packages provides @code{error}, which offers simp= le +error handling primitives in Go.") + (home-page "https://github.com/pkg/errors") + (license bsd-2)))) + +(define-public golang-org-x-time-rate + (let ((commit "f51c12702a4d776e4c1fa9b0fabab841babae631") + (revision "0")) + (package + (name "golang-org-x-time-rate") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://go.googlesource.com/time") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "07wc6g2fvafkr6djsscm0jpbpl4135khhb6kpyx1953hi5d1jvyy"))= )) + (build-system go-build-system) + (arguments + `(#:import-path "golang.org/x/time/rate" + #:unpack-path "golang.org/x/time")) + (propagated-inputs + `(("golang-org-x-net-context" ,golang-org-x-net-context))) + (synopsis "Rate limiting in Go") + (description "This package provides @{rate}, which implements rate +limiting in Go.") + (home-page "https://godoc.org/golang.org/x/time/rate") + (license bsd-3)))) + +(define-public golang-github-com-petermattis-goid + (let ((commit "3db12ebb2a599ba4a96bea1c17b61c2f78a40e02") + (revision "0")) + (package + (name "golang-github-com-petermattis-goid") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/petermattis/goid.git") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + + (base32 + "0z18a3mr72c52g7g94n08gxw0ksnaafbfwdl5p5jav2sffirb0kd"))= )) + (build-system go-build-system) + (arguments + '(#:import-path "github.com/petermattis/goid")) + (synopsis "Identify the running goroutine") + (description "This package offers a method of programatically retrie= ving +the current goroutine's ID.") + (home-page "https://github.com/petermattis/goid") + (license asl2.0)))) + +(define-public golang-github-com-audriusbutkevicius-cli + (let ((commit "7f561c78b5a4aad858d9fd550c92b5da6d55efbb") + (revision "0")) + (package + (name "golang-github-com-audriusbutkevicius-cli") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/AudriusButkevicius/cli.git= ") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "0bg26pfg25vr16jmczig2m493mja2nxjxyswz3hha7avxw20rpi5"))= )) + (build-system go-build-system) + (arguments + '(#:import-path "github.com/AudriusButkevicius/cli")) + (synopsis "Library for building command-line interfaces in Go") + (description "This package provides a library for building command-l= ine +interfaces in Go.") + (home-page "https://github.com/AudriusButkevicius/cli") + (license expat)))) + +(define-public golang-github-com-kballard-go-shellquote + (let ((commit "cd60e84ee657ff3dc51de0b4f55dd299a3e136f2") + (revision "0")) + (package + (name "golang-github-com-kballard-go-shellquote") + (version (string-append "0.0.0-" revision "." (string-take commit 7)= )) + (source (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/kballard/go-shellquote.git= ") + (commit commit))) + (file-name (string-append name "-" version "-checkout")) + (sha256 + (base32 + "1xjpin4jq1zl84dcn96xhjmn9bsfyszf6g9aqyj2dc0xfi6c88y0"))= )) + (build-system go-build-system) + (arguments + '(#:import-path "github.com/kballard/go-shellquote")) + (synopsis "Shell-style string joins and splits") + (description "Shellquote provides utilities for joining/splitting st= rings +using sh's word-splitting rules.") + (home-page "https://github.com/kballard/go-shellquote") + (license expat)))) --=20 2.14.2 --gKMricLos+KVdGMg-- --1LKvkjL3sHcu1TtY Content-Type: application/pgp-signature; name="signature.asc" -----BEGIN PGP SIGNATURE----- iQIzBAABCAAdFiEEsFFZSPHn08G5gDigJkb6MLrKfwgFAlnSoD0ACgkQJkb6MLrK fwiGTA/+JPEK0ijkbmTxksmVvpg4nnF1QrosSMhq/05LFs1ln/wmRkIric8pm1gs paJFaA/0xk5st3t6R8xEPI9kvgdHozaQkrlvuJ033G5XSd0OXbAftbCnb563LA60 JtExAHR+9gSRXpvh/SJDWPL3YYzKuSt2Uj5CYKitbA52YurmL5ij1Rj1PeysvjQm ap6pYxwKkVgBHGqG3ElVWXtvAX8TJSHgVB/0BY096R/BoCQt2f9C5ur9sX7d4Jb7 6WKptNwLC8u354E5Jn9r0VXcAw7f6Mvnk+QgOmhjBxWySyLIO+u7+eMQBUl5w8TL N2bixNOzlT+AZSRq8AWJpuqOZvU12DQ1JHzA2rgs0/iPxM8QxRC58wtx496WHmTK JtGXbbo5dIRqXxx5uagZJ63ly5SEAAeZkaMYh6156Qz8Zel1L0REy5CXJOM9eDbD 6R7siDnC9nhEb926zPOLyNLg6h7AjOn99AbPtYJ2l11IIw3iFS3Waw4N3VzgFkZj o16rcKYMbtT1loYM80X/bW7qcg+7nI7HxsT+B9PjUuc+c3o2QfxRBNX6SRZ3RWTQ eDDTp5xyq74raxIsajSYGiLXHRZxOEiBgR9VvxcWCyUTkylWGaMPRM48PEQPGETM GRGHWsR7nCoLc5VkiEYw1/ZCRGlSeNi2LD0GVSe4E7cA5bTifpU= =SCAA -----END PGP SIGNATURE----- --1LKvkjL3sHcu1TtY--