From: Leo Famulari <leo@famulari.name>
To: 28586@debbugs.gnu.org
Subject: [bug#28586] go-build-system and Syncthing
Date: Mon, 2 Oct 2017 16:23:25 -0400 [thread overview]
Message-ID: <20171002202325.GA12172@jasmine.lan> (raw)
In-Reply-To: <20170924203651.GA29973@jasmine.lan>
[-- Attachment #1.1: Type: text/plain, Size: 271 bytes --]
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.
[-- Attachment #1.2: 0001-build-Add-the-Go-build-system.patch --]
[-- Type: text/plain, Size: 18252 bytes --]
From c07a2204ab6c5deb353699a67660841630d40feb Mon Sep 17 00:00:00 2001
From: Leo Famulari <leo@famulari.name>
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 = \
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 = \
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 code is compiled with
@code{-O2 -g}, as is the case for Autoconf-based packages by default.
@end defvr
+@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 © 2016 Petter <petter@mykolab.ch>
+;;; Copyright © 2017 Leo Famulari <leo@famulari.name>
+;;;
+;;; 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 <http://www.gnu.org/licenses/>.
+
+(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-compilation
+ (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 © 2016 Petter <petter@mykolab.ch>
+;;; Copyright © 2017 Leo Famulari <leo@famulari.name>
+;;;
+;;; 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 <http://www.gnu.org/licenses/>.
+
+(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 hierarchy
+;; 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
+;; <https://github.com/calmh/du>. Thus, the import path is
+;; <github.com/calmh/du>. [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
+;; <https://golang.org/x/{net,text,crypto, et cetera}>. The Go IPv4
+;; library's import path is <golang.org/x/net/ipv4>. 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 <golang.org/x/net>. 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_dependencies
+;; [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 OUTPUTS,
+respectively."
+ (let ((out (assoc-ref outputs "out")))
+ ;; GOPATH is where Go looks for the source code of the build's dependencies.
+ (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 parlance').
+ (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))
--
2.14.2
[-- Attachment #1.3: 0002-gnu-Add-Syncthing.patch --]
[-- Type: text/plain, Size: 86028 bytes --]
From 01f4ab3b7f4caab41352ed2f5c9ab69c695c72ae Mon Sep 17 00:00:00 2001
From: Leo Famulari <leo@famulari.name>
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 <petter@mykolab.ch>
---
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 = \
%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 © 2016 Petter <petter@mykolab.ch>
+;;; Copyright © 2016, 2017 Leo Famulari <leo@famulari.name>
+;;;
+;;; 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 <http://www.gnu.org/licenses/>.
+
+(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 copies.
+ (rename-file "src/github.com/syncthing/syncthing/vendor/github.com/cznic"
+ "cznic")
+ (delete-file-recursively "src/github.com/syncthing/syncthing/vendor")
+ (mkdir-p "src/github.com/syncthing/syncthing/vendor/github.com/")
+ (rename-file "cznic"
+ "src/github.com/syncthing/syncthing/vendor/github.com/cznic")
+ #t))
+
+ ;; We don't need to install the source code for end-user applications.
+ (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 file 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) ; bundled
+ ; 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-gateway)
+ ("golang-github-com-kardianos-osext" ,golang-github-com-kardianos-osext)
+ ("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-sha256-simd)
+ ("golang-github-com-oschwald-geoip2-golang"
+ ,golang-github-com-oschwald-geoip2-golang)
+ ("golang-github-com-rcrowley-go-metrics" ,golang-github-com-rcrowley-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-goleveldb)
+ ("golang-github-com-thejerf-suture" ,golang-github-com-thejerf-suture)
+ ("golang-github-com-vitrun-qart" ,(golang-github-com-vitrun-qart-union))
+ ("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 that
+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-pmp")
+ (commit commit)))
+ (file-name (string-append name "-" version "-checkout"))
+ (sha256
+ (base32 "1accmpl1llk16a19nlyy991fqrgfay6l53gb64hgmdfmqljdvbk7"))))
+ (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 internet
+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 implementation 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 usage
+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.")
+ (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 arbitrary
+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-protoc-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 code
+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 code
+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, intended
+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 executable
+file that is running. This can be used for upgrading the current executable 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 running
+ ;; Postgres instance.
+ #:tests? #f))
+ (synopsis "Golang Postgres driver for Go's database/sql")
+ (description "This packages provides a pure Go Postgres driver for Go'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 SHA256
+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. Although
+this can be used to read GeoLite2 and GeoIP2 databases, @code{geoip2} provides 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-petermattis-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 "105ql5v8r4hqcsq0ag7asdxqg9n7rvf83y1q1dj2nfjyn4manv6r"))))
+ (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 together
+when it's trying to die.
+
+It is intended to deal gracefully with the real failure cases that can occur
+with supervision trees (such as burning all your CPU time endlessly restarting
+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 with 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 @code{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 with 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-blowfish
+ golang-org-x-crypto-bcrypt
+ golang-org-x-crypto-tea
+ golang-org-x-crypto-xtea
+ golang-org-x-crypto-pbkdf2
+ golang-org-x-crypto-twofish
+ golang-org-x-crypto-cast5
+ golang-org-x-crypto-salsa20)))
+ (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/testdata")
+ ".*\\.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/testdata")
+ ".*\\.gz$"))
+ #t)))))
+ (synopsis "Blowfish in Go")
+ (description "This package provides a Go implementation of the Blowfish
+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/testdata")
+ ".*\\.gz$"))
+ #t)))))
+ (synopsis "PBKDF2 in Go")
+ (description "This package provides a Go implementation of the PBKDF2 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/testdata")
+ ".*\\.gz$"))
+ #t)))))
+ (synopsis "Tiny Encryption Algorithm (TEA) in Go")
+ (description "This packages a Go implementation of the Tiny Encryption
+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/testdata")
+ ".*\\.gz$"))
+ #t)))))
+ (synopsis "Salsa20 in Go")
+ (description "This packages provides a Go implementation of the Salsa20
+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/testdata")
+ ".*\\.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/testdata")
+ ".*\\.gz$"))
+ #t)))))
+ (synopsis "Twofish in Go")
+ (description "This packages provides a Go implementation of the Twofish
+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/testdata")
+ ".*\\.gz$"))
+ #t)))))
+ (synopsis "eXtended Tiny Encryption Algorithm (XTEA) in Go")
+ (description "This package provides a Go implementation of the eXtended
+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 Berkeley
+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 the
+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 protocol
+number resources managed by the Internet Assigned Numbers Authority (IANA).")
+ (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 support
+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 support
+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-transform
+ golang-org-x-text-unicode-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. Example
+transformations provided by other packages include normalization and conversion
+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 types 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 multiple
+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-xor)))
+ (arguments
+ '(#:import-path "github.com/AudriusButkevicius/kcp-go"
+ ;; 'TestListenerClose' is known to fail. It seems that the test suite
+ ;; 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 library
+written in Go. It offers fast, ordered and error-checked delivery of streams
+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 simple
+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 retrieving
+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-line
+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 strings
+using sh's word-splitting rules.")
+ (home-page "https://github.com/kballard/go-shellquote")
+ (license expat))))
--
2.14.2
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
next prev parent reply other threads:[~2017-10-02 20:25 UTC|newest]
Thread overview: 12+ messages / expand[flat|nested] mbox.gz Atom feed top
2017-09-24 20:36 [bug#28586] go-build-system and Syncthing Leo Famulari
2017-09-24 20:40 ` [bug#28586] [PATCH 1/2] build: Add the Go build system Leo Famulari
2017-09-24 20:40 ` [bug#28586] [PATCH 2/2] gnu: Add Syncthing Leo Famulari
2017-09-25 18:21 ` Leo Famulari
2017-09-25 19:28 ` Leo Famulari
2017-09-26 7:41 ` Ludovic Courtès
2017-09-29 19:24 ` Leo Famulari
2017-10-02 20:23 ` Leo Famulari [this message]
2017-10-02 21:01 ` [bug#28586] go-build-system and Syncthing ng0
2017-10-02 21:42 ` Leo Famulari
2017-10-13 1:47 ` bug#28586: " Leo Famulari
2017-10-13 8:39 ` [bug#28586] " Ludovic Courtès
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20171002202325.GA12172@jasmine.lan \
--to=leo@famulari.name \
--cc=28586@debbugs.gnu.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
Code repositories for project(s) associated with this external index
https://git.savannah.gnu.org/cgit/guix.git
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.