Merge pull request #39103 from lsilvs/master
Add Satoshi Nakamoto to names generator
diff --git a/.mailmap b/.mailmap
index 4e349e5..01865a6 100644
--- a/.mailmap
+++ b/.mailmap
@@ -17,7 +17,9 @@
AJ Bowen <aj@soulshake.net> <aj@gandi.net>
AJ Bowen <aj@soulshake.net> <amy@gandi.net>
Akihiro Matsushima <amatsusbit@gmail.com> <amatsus@users.noreply.github.com>
-Akihiro Suda <suda.akihiro@lab.ntt.co.jp> <suda.kyoto@gmail.com>
+Akihiro Suda <akihiro.suda.cz@hco.ntt.co.jp>
+Akihiro Suda <akihiro.suda.cz@hco.ntt.co.jp> <suda.kyoto@gmail.com>
+Akihiro Suda <akihiro.suda.cz@hco.ntt.co.jp> <suda.akihiro@lab.ntt.co.jp>
Aleksa Sarai <asarai@suse.de>
Aleksa Sarai <asarai@suse.de> <asarai@suse.com>
Aleksa Sarai <asarai@suse.de> <cyphar@cyphar.com>
@@ -125,6 +127,8 @@
Deshi Xiao <dxiao@redhat.com> <xiaods@gmail.com>
Diego Siqueira <dieg0@live.com>
Diogo Monica <diogo@docker.com> <diogo.monica@gmail.com>
+Dmitry Sharshakov <d3dx12.xx@gmail.com>
+Dmitry Sharshakov <d3dx12.xx@gmail.com> <sh7dm@outlook.com>
Dominik Honnef <dominik@honnef.co> <dominikh@fork-bomb.org>
Doug Davis <dug@us.ibm.com> <duglin@users.noreply.github.com>
Doug Tangren <d.tangren@gmail.com>
@@ -153,6 +157,7 @@
Francisco Carriedo <fcarriedo@gmail.com>
Frank Rosquin <frank.rosquin+github@gmail.com> <frank.rosquin@gmail.com>
Frederick F. Kautz IV <fkautz@redhat.com> <fkautz@alumni.cmu.edu>
+Fu JinLin <withlin@yeah.net>
Gabriel Nicolas Avellaneda <avellaneda.gabriel@gmail.com>
Gaetan de Villele <gdevillele@gmail.com>
Gang Qiao <qiaohai8866@gmail.com> <1373319223@qq.com>
@@ -160,6 +165,7 @@
George Kontridze <george@bugsnag.com>
Gerwim Feiken <g.feiken@tfe.nl> <gerwim@gmail.com>
Giampaolo Mancini <giampaolo@trampolineup.com>
+Giovan Isa Musthofa <giovanism@outlook.co.id>
Gopikannan Venugopalsamy <gopikannan.venugopalsamy@gmail.com>
Gou Rao <gou@portworx.com> <gourao@users.noreply.github.com>
Greg Stephens <greg@udon.org>
@@ -327,6 +333,8 @@
Matthew Mueller <mattmuelle@gmail.com>
Matthias Kühnle <git.nivoc@neverbox.com> <kuehnle@online.de>
Mauricio Garavaglia <mauricio@medallia.com> <mauriciogaravaglia@gmail.com>
+Maxwell <csuhp007@gmail.com>
+Maxwell <csuhp007@gmail.com> <csuhqg@foxmail.com>
Michael Crosby <michael@docker.com> <crosby.michael@gmail.com>
Michael Crosby <michael@docker.com> <crosbymichael@gmail.com>
Michael Crosby <michael@docker.com> <michael@crosbymichael.com>
@@ -501,6 +509,7 @@
Xian Chaobo <xianchaobo@huawei.com> <jimmyxian2004@yahoo.com.cn>
Xianglin Gao <xlgao@zju.edu.cn>
Xianlu Bird <xianlubird@gmail.com>
+Xiao YongBiao <xyb4638@gmail.com>
Xiaodong Zhang <a4012017@sina.com>
Xiaoyu Zhang <zhang.xiaoyu33@zte.com.cn>
Xuecong Liao <satorulogic@gmail.com>
diff --git a/AUTHORS b/AUTHORS
index 851e810..c5f725b 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -44,7 +44,7 @@
ajneu <ajneu@users.noreply.github.com>
Akash Gupta <akagup@microsoft.com>
Akihiro Matsushima <amatsusbit@gmail.com>
-Akihiro Suda <suda.akihiro@lab.ntt.co.jp>
+Akihiro Suda <akihiro.suda.cz@hco.ntt.co.jp>
Akim Demaille <akim.demaille@docker.com>
Akira Koyasu <mail@akirakoyasu.net>
Akshay Karle <akshay.a.karle@gmail.com>
@@ -81,6 +81,7 @@
Alexandre González <agonzalezro@gmail.com>
Alexandre Jomin <alexandrejomin@gmail.com>
Alexandru Sfirlogea <alexandru.sfirlogea@gmail.com>
+Alexei Margasov <alexei38@yandex.ru>
Alexey Guskov <lexag@mail.ru>
Alexey Kotlyarov <alexey@infoxchange.net.au>
Alexey Shamrin <shamrin@gmail.com>
@@ -153,6 +154,7 @@
Anes Hasicic <anes.hasicic@gmail.com>
Anil Belur <askb23@gmail.com>
Anil Madhavapeddy <anil@recoil.org>
+Ankit Jain <ajatkj@yahoo.co.in>
Ankush Agarwal <ankushagarwal11@gmail.com>
Anonmily <michelle@michelleliu.io>
Anran Qiao <anran.qiao@daocloud.io>
@@ -184,6 +186,7 @@
Asbjørn Enge <asbjorn@hanafjedle.net>
averagehuman <averagehuman@users.noreply.github.com>
Avi Das <andas222@gmail.com>
+Avi Kivity <avi@scylladb.com>
Avi Miller <avi.miller@oracle.com>
Avi Vaid <avaid1996@gmail.com>
ayoshitake <airandfingers@gmail.com>
@@ -507,6 +510,7 @@
Dmitry Demeshchuk <demeshchuk@gmail.com>
Dmitry Gusev <dmitry.gusev@gmail.com>
Dmitry Kononenko <d@dm42.ru>
+Dmitry Sharshakov <d3dx12.xx@gmail.com>
Dmitry Shyshkin <dmitry@shyshkin.org.ua>
Dmitry Smirnov <onlyjob@member.fsf.org>
Dmitry V. Krivenok <krivenok.dmitry@gmail.com>
@@ -656,6 +660,7 @@
Frederik Nordahl Jul Sabroe <frederikns@gmail.com>
Freek Kalter <freek@kalteronline.org>
Frieder Bluemle <frieder.bluemle@gmail.com>
+Fu JinLin <withlin@yeah.net>
Félix Baylac-Jacqué <baylac.felix@gmail.com>
Félix Cantournet <felix.cantournet@cloudwatt.com>
Gabe Rosenhouse <gabe@missionst.com>
@@ -688,6 +693,7 @@
Giampaolo Mancini <giampaolo@trampolineup.com>
Gianluca Borello <g.borello@gmail.com>
Gildas Cuisinier <gildas.cuisinier@gcuisinier.net>
+Giovan Isa Musthofa <giovanism@outlook.co.id>
gissehel <public-devgit-dantus@gissehel.org>
Giuseppe Mazzotta <gdm85@users.noreply.github.com>
Gleb Fotengauer-Malinovskiy <glebfm@altlinux.org>
@@ -898,6 +904,7 @@
Jimmy Puckett <jimmy.puckett@spinen.com>
Jimmy Song <rootsongjc@gmail.com>
Jinsoo Park <cellpjs@gmail.com>
+Jintao Zhang <zhangjintao9020@gmail.com>
Jiri Appl <jiria@microsoft.com>
Jiri Popelka <jpopelka@redhat.com>
Jiuyue Ma <majiuyue@huawei.com>
@@ -1079,6 +1086,7 @@
Kunal Tyagi <tyagi.kunal@live.com>
Kyle Conroy <kyle.j.conroy@gmail.com>
Kyle Linden <linden.kyle@gmail.com>
+Kyle Wuolle <kyle.wuolle@gmail.com>
kyu <leehk1227@gmail.com>
Lachlan Coote <lcoote@vmware.com>
Lai Jiangshan <jiangshanlai@gmail.com>
@@ -1255,6 +1263,7 @@
Maxim Treskin <zerthurd@gmail.com>
Maxime Petazzoni <max@signalfuse.com>
Maximiliano Maccanti <maccanti@amazon.com>
+Maxwell <csuhp007@gmail.com>
Meaglith Ma <genedna@gmail.com>
meejah <meejah@meejah.ca>
Megan Kostick <mkostick@us.ibm.com>
@@ -1519,6 +1528,7 @@
Quentin Perez <qperez@ocs.online.net>
Quentin Tayssier <qtayssier@gmail.com>
r0n22 <cameron.regan@gmail.com>
+Radostin Stoyanov <rstoyanov1@gmail.com>
Rafal Jeczalik <rjeczalik@gmail.com>
Rafe Colton <rafael.colton@gmail.com>
Raghavendra K T <raghavendra.kt@linux.vnet.ibm.com>
@@ -1976,6 +1986,7 @@
Xian Chaobo <xianchaobo@huawei.com>
Xianglin Gao <xlgao@zju.edu.cn>
Xianlu Bird <xianlubird@gmail.com>
+Xiao YongBiao <xyb4638@gmail.com>
XiaoBing Jiang <s7v7nislands@gmail.com>
Xiaodong Zhang <a4012017@sina.com>
Xiaoxi He <xxhe@alauda.io>
diff --git a/Dockerfile b/Dockerfile
index b20332d..bc50584 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -94,16 +94,28 @@
hello-world:latest@sha256:be0cd392e45be79ffeffa6b05338b98ebb16c87b255f48e297ec7f98e123905c
# See also ensureFrozenImagesLinux() in "integration-cli/fixtures_linux_daemon_test.go" (which needs to be updated when adding images to this list)
-# Just a little hack so we don't have to install these deps twice, once for runc and once for dockerd
-FROM base AS runtime-dev-cross-false
+FROM base AS cross-false
+
+FROM base AS cross-true
+RUN dpkg --add-architecture armhf
+RUN dpkg --add-architecture arm64
+RUN dpkg --add-architecture armel
+RUN if [ "$(go env GOHOSTARCH)" = "amd64" ]; then \
+ apt-get update \
+ && apt-get install -y --no-install-recommends \
+ crossbuild-essential-armhf \
+ crossbuild-essential-arm64 \
+ crossbuild-essential-armel; \
+ fi
+
+FROM cross-${CROSS} as dev-base
+
+FROM dev-base AS runtime-dev-cross-false
RUN apt-get update && apt-get install -y \
libapparmor-dev \
libseccomp-dev
-FROM runtime-dev-cross-false AS runtime-dev-cross-true
-RUN dpkg --add-architecture armhf
-RUN dpkg --add-architecture arm64
-RUN dpkg --add-architecture armel
+FROM cross-true AS runtime-dev-cross-true
# These crossbuild packages rely on gcc-<arch>, but this doesn't want to install
# on non-amd64 systems.
# Additionally, the crossbuild-amd64 is currently only on debian:buster, so
@@ -111,12 +123,16 @@
RUN if [ "$(go env GOHOSTARCH)" = "amd64" ]; then \
apt-get update \
&& apt-get install -y \
- crossbuild-essential-armhf \
- crossbuild-essential-arm64 \
- crossbuild-essential-armel \
libseccomp-dev:armhf \
libseccomp-dev:arm64 \
- libseccomp-dev:armel; \
+ libseccomp-dev:armel \
+ libapparmor-dev:armhf \
+ libapparmor-dev:arm64 \
+ libapparmor-dev:armel \
+ # install this arches seccomp here due to compat issues with the v0 builder
+ # This is as opposed to inheriting from runtime-dev-cross-false
+ libapparmor-dev \
+ libseccomp-dev; \
fi
FROM runtime-dev-cross-${CROSS} AS runtime-dev
@@ -133,14 +149,14 @@
COPY hack/dockerfile/install/$INSTALL_BINARY_NAME.installer ./
RUN PREFIX=/build ./install.sh $INSTALL_BINARY_NAME
-FROM base AS containerd
+FROM dev-base AS containerd
RUN apt-get update && apt-get install -y btrfs-tools
ENV INSTALL_BINARY_NAME=containerd
COPY hack/dockerfile/install/install.sh ./install.sh
COPY hack/dockerfile/install/$INSTALL_BINARY_NAME.installer ./
RUN PREFIX=/build ./install.sh $INSTALL_BINARY_NAME
-FROM base AS proxy
+FROM dev-base AS proxy
ENV INSTALL_BINARY_NAME=proxy
COPY hack/dockerfile/install/install.sh ./install.sh
COPY hack/dockerfile/install/$INSTALL_BINARY_NAME.installer ./
@@ -152,7 +168,7 @@
COPY hack/dockerfile/install/$INSTALL_BINARY_NAME.installer ./
RUN PREFIX=/build ./install.sh $INSTALL_BINARY_NAME
-FROM base AS dockercli
+FROM dev-base AS dockercli
ENV INSTALL_BINARY_NAME=dockercli
COPY hack/dockerfile/install/install.sh ./install.sh
COPY hack/dockerfile/install/$INSTALL_BINARY_NAME.installer ./
@@ -164,14 +180,14 @@
COPY hack/dockerfile/install/$INSTALL_BINARY_NAME.installer ./
RUN PREFIX=/build ./install.sh $INSTALL_BINARY_NAME
-FROM base AS tini
+FROM dev-base AS tini
RUN apt-get update && apt-get install -y cmake vim-common
COPY hack/dockerfile/install/install.sh ./install.sh
ENV INSTALL_BINARY_NAME=tini
COPY hack/dockerfile/install/$INSTALL_BINARY_NAME.installer ./
RUN PREFIX=/build ./install.sh $INSTALL_BINARY_NAME
-FROM base AS rootlesskit
+FROM dev-base AS rootlesskit
ENV INSTALL_BINARY_NAME=rootlesskit
COPY hack/dockerfile/install/install.sh ./install.sh
COPY hack/dockerfile/install/$INSTALL_BINARY_NAME.installer ./
diff --git a/MAINTAINERS b/MAINTAINERS
index 9f8b9e4..93013e0 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -240,7 +240,7 @@
[people.akihirosuda]
Name = "Akihiro Suda"
- Email = "suda.akihiro@lab.ntt.co.jp"
+ Email = "akihiro.suda.cz@hco.ntt.co.jp"
GitHub = "AkihiroSuda"
[people.aluzzardi]
diff --git a/client/client.go b/client/client.go
index 317aac1..b63d4d6 100644
--- a/client/client.go
+++ b/client/client.go
@@ -81,6 +81,15 @@
customHTTPHeaders map[string]string
// manualOverride is set to true when the version was set by users.
manualOverride bool
+
+ // negotiateVersion indicates if the client should automatically negotiate
+ // the API version to use when making requests. API version negotiation is
+ // performed on the first request, after which negotiated is set to "true"
+ // so that subsequent requests do not re-negotiate.
+ negotiateVersion bool
+
+ // negotiated indicates that API version negotiation took place
+ negotiated bool
}
// CheckRedirect specifies the policy for dealing with redirect responses:
@@ -169,8 +178,11 @@
// getAPIPath returns the versioned request path to call the api.
// It appends the query parameters to the path if they are not empty.
-func (cli *Client) getAPIPath(p string, query url.Values) string {
+func (cli *Client) getAPIPath(ctx context.Context, p string, query url.Values) string {
var apiPath string
+ if cli.negotiateVersion && !cli.negotiated {
+ cli.NegotiateAPIVersion(ctx)
+ }
if cli.version != "" {
v := strings.TrimPrefix(cli.version, "v")
apiPath = path.Join(cli.basePath, "/v"+v, p)
@@ -186,19 +198,31 @@
}
// NegotiateAPIVersion queries the API and updates the version to match the
-// API version. Any errors are silently ignored.
+// API version. Any errors are silently ignored. If a manual override is in place,
+// either through the `DOCKER_API_VERSION` environment variable, or if the client
+// was initialized with a fixed version (`opts.WithVersion(xx)`), no negotiation
+// will be performed.
func (cli *Client) NegotiateAPIVersion(ctx context.Context) {
- ping, _ := cli.Ping(ctx)
- cli.NegotiateAPIVersionPing(ping)
+ if !cli.manualOverride {
+ ping, _ := cli.Ping(ctx)
+ cli.negotiateAPIVersionPing(ping)
+ }
}
// NegotiateAPIVersionPing updates the client version to match the Ping.APIVersion
-// if the ping version is less than the default version.
+// if the ping version is less than the default version. If a manual override is
+// in place, either through the `DOCKER_API_VERSION` environment variable, or if
+// the client was initialized with a fixed version (`opts.WithVersion(xx)`), no
+// negotiation is performed.
func (cli *Client) NegotiateAPIVersionPing(p types.Ping) {
- if cli.manualOverride {
- return
+ if !cli.manualOverride {
+ cli.negotiateAPIVersionPing(p)
}
+}
+// negotiateAPIVersionPing queries the API and updates the version to match the
+// API version. Any errors are silently ignored.
+func (cli *Client) negotiateAPIVersionPing(p types.Ping) {
// try the latest version before versioning headers existed
if p.APIVersion == "" {
p.APIVersion = "1.24"
@@ -213,6 +237,12 @@
if versions.LessThan(p.APIVersion, cli.version) {
cli.version = p.APIVersion
}
+
+ // Store the results, so that automatic API version negotiation (if enabled)
+ // won't be performed on the next request.
+ if cli.negotiateVersion {
+ cli.negotiated = true
+ }
}
// DaemonHost returns the host address used by the client
diff --git a/client/client_test.go b/client/client_test.go
index 56f6d86..8470143 100644
--- a/client/client_test.go
+++ b/client/client_test.go
@@ -2,10 +2,13 @@
import (
"bytes"
+ "context"
+ "io/ioutil"
"net/http"
"net/url"
"os"
"runtime"
+ "strings"
"testing"
"github.com/docker/docker/api"
@@ -123,9 +126,10 @@
{"v1.22", "/networks/kiwl$%^", nil, "/v1.22/networks/kiwl$%25%5E"},
}
+ ctx := context.TODO()
for _, testcase := range testcases {
c := Client{version: testcase.version, basePath: "/"}
- actual := c.getAPIPath(testcase.path, testcase.query)
+ actual := c.getAPIPath(ctx, testcase.path, testcase.query)
assert.Check(t, is.Equal(actual, testcase.expected))
}
}
@@ -265,6 +269,35 @@
assert.Check(t, is.Equal(expected, client.version))
}
+func TestNegotiateAPIVersionAutomatic(t *testing.T) {
+ var pingVersion string
+ httpClient := newMockClient(func(req *http.Request) (*http.Response, error) {
+ resp := &http.Response{StatusCode: http.StatusOK, Header: http.Header{}}
+ resp.Header.Set("API-Version", pingVersion)
+ resp.Body = ioutil.NopCloser(strings.NewReader("OK"))
+ return resp, nil
+ })
+
+ client, err := NewClientWithOpts(
+ WithHTTPClient(httpClient),
+ WithAPIVersionNegotiation(),
+ )
+ assert.NilError(t, err)
+
+ ctx := context.Background()
+ assert.Equal(t, client.ClientVersion(), api.DefaultVersion)
+
+ // First request should trigger negotiation
+ pingVersion = "1.35"
+ _, _ = client.Info(ctx)
+ assert.Equal(t, client.ClientVersion(), "1.35")
+
+ // Once successfully negotiated, subsequent requests should not re-negotiate
+ pingVersion = "1.25"
+ _, _ = client.Info(ctx)
+ assert.Equal(t, client.ClientVersion(), "1.35")
+}
+
// TestNegotiateAPIVersionWithEmptyVersion asserts that initializing a client
// with an empty version string does still allow API-version negotiation
func TestNegotiateAPIVersionWithEmptyVersion(t *testing.T) {
diff --git a/client/hijack.go b/client/hijack.go
index 8609982..e9c9a75 100644
--- a/client/hijack.go
+++ b/client/hijack.go
@@ -23,7 +23,7 @@
return types.HijackedResponse{}, err
}
- apiPath := cli.getAPIPath(path, query)
+ apiPath := cli.getAPIPath(ctx, path, query)
req, err := http.NewRequest("POST", apiPath, bodyEncoded)
if err != nil {
return types.HijackedResponse{}, err
diff --git a/client/options.go b/client/options.go
index 6c2d796..6f77f09 100644
--- a/client/options.go
+++ b/client/options.go
@@ -159,3 +159,14 @@
return nil
}
}
+
+// WithAPIVersionNegotiation enables automatic API version negotiation for the client.
+// With this option enabled, the client automatically negotiates the API version
+// to use when making requests. API version negotiation is performed on the first
+// request; subsequent requests will not re-negotiate.
+func WithAPIVersionNegotiation() Opt {
+ return func(c *Client) error {
+ c.negotiateVersion = true
+ return nil
+ }
+}
diff --git a/client/request.go b/client/request.go
index 0afe26d..3078335 100644
--- a/client/request.go
+++ b/client/request.go
@@ -115,7 +115,7 @@
}
func (cli *Client) sendRequest(ctx context.Context, method, path string, query url.Values, body io.Reader, headers headers) (serverResponse, error) {
- req, err := cli.buildRequest(method, cli.getAPIPath(path, query), body, headers)
+ req, err := cli.buildRequest(method, cli.getAPIPath(ctx, path, query), body, headers)
if err != nil {
return serverResponse{}, err
}
diff --git a/daemon/cluster/swarm.go b/daemon/cluster/swarm.go
index 18a9091..2b7487c 100644
--- a/daemon/cluster/swarm.go
+++ b/daemon/cluster/swarm.go
@@ -466,7 +466,7 @@
default:
if info.Managers == 2 {
const warn string = `WARNING: Running Swarm in a two-manager configuration. This configuration provides
- no fault tolerance, and poses a high risk to loose control over the cluster.
+ no fault tolerance, and poses a high risk to lose control over the cluster.
Refer to https://docs.docker.com/engine/swarm/admin_guide/ to configure the
Swarm for fault-tolerance.`
diff --git a/daemon/logger/fluentd/fluentd.go b/daemon/logger/fluentd/fluentd.go
index 19652d6..cf7f3e9 100644
--- a/daemon/logger/fluentd/fluentd.go
+++ b/daemon/logger/fluentd/fluentd.go
@@ -133,7 +133,7 @@
BufferLimit: bufferLimit,
RetryWait: retryWait,
MaxRetry: maxRetries,
- AsyncConnect: asyncConnect,
+ Async: asyncConnect,
SubSecondPrecision: subSecondPrecision,
}
diff --git a/hack/dockerfile/install/proxy.installer b/hack/dockerfile/install/proxy.installer
index 05876fd..f419693 100755
--- a/hack/dockerfile/install/proxy.installer
+++ b/hack/dockerfile/install/proxy.installer
@@ -3,7 +3,7 @@
# LIBNETWORK_COMMIT is used to build the docker-userland-proxy binary. When
# updating the binary version, consider updating github.com/docker/libnetwork
# in vendor.conf accordingly
-LIBNETWORK_COMMIT=ebcade70ad1059b070d0040d798ecca359bc5fed
+LIBNETWORK_COMMIT=9ff9b57c344df5cd47443ad9e65702ec85c5aeb0
install_proxy() {
case "$1" in
diff --git a/hack/make.ps1 b/hack/make.ps1
index 6239c95..2211f07 100644
--- a/hack/make.ps1
+++ b/hack/make.ps1
@@ -351,6 +351,8 @@
# Get the version of docker (eg 17.04.0-dev)
$dockerVersion="0.0.0-dev"
+ # Overwrite dockerVersion if VERSION Environment variable is available
+ if (Test-Path Env:\VERSION) { $dockerVersion=$env:VERSION }
# Give a warning if we are not running in a container and are building binaries or running unit tests.
# Not relevant for validation tests as these are fine to run outside of a container.
diff --git a/hack/make/.binary b/hack/make/.binary
index 357b456..53de674 100644
--- a/hack/make/.binary
+++ b/hack/make/.binary
@@ -80,6 +80,7 @@
esac
echo "Building: $DEST/$BINARY_FULLNAME"
+echo "GOOS=\"${GOOS}\" GOARCH=\"${GOARCH}\" GOARM=\"${GOARM}\""
go build \
-o "$DEST/$BINARY_FULLNAME" \
"${BUILDFLAGS[@]}" \
diff --git a/hack/make/cross b/hack/make/cross
index 47cb667..ab9f0b7 100644
--- a/hack/make/cross
+++ b/hack/make/cross
@@ -18,8 +18,14 @@
(
export KEEPDEST=1
export DEST="${DEST}/${platform}" # bundles/VERSION/cross/GOOS/GOARCH/docker-VERSION
- export GOOS=${platform%/*}
- export GOARCH=${platform##*/}
+ export GOOS=${platform%%/*}
+ export GOARCH=${platform#*/}
+
+ if [[ "${GOARCH}" = "arm/"* ]]; then
+ GOARM=${GOARCH##*/v}
+ GOARCH=${GOARCH%/v*}
+ export GOARM
+ fi
echo "Cross building: ${DEST}"
mkdir -p "${DEST}"
diff --git a/integration-cli/docker_cli_pull_test.go b/integration-cli/docker_cli_pull_test.go
index dbf9756..8526a10 100644
--- a/integration-cli/docker_cli_pull_test.go
+++ b/integration-cli/docker_cli_pull_test.go
@@ -266,12 +266,12 @@
func (s *DockerSuite) TestPullLinuxImageFailsOnWindows(c *check.C) {
testRequires(c, DaemonIsWindows, Network)
_, _, err := dockerCmdWithError("pull", "ubuntu")
- assert.ErrorContains(c, err, "no matching manifest")
+ assert.ErrorContains(c, err, "no matching manifest for windows")
}
// Regression test for https://github.com/docker/docker/issues/28892
func (s *DockerSuite) TestPullWindowsImageFailsOnLinux(c *check.C) {
testRequires(c, DaemonIsLinux, Network)
- _, _, err := dockerCmdWithError("pull", "microsoft/nanoserver")
- assert.ErrorContains(c, err, "cannot be used on this platform")
+ _, _, err := dockerCmdWithError("pull", "mcr.microsoft.com/windows/servercore:ltsc2019")
+ assert.ErrorContains(c, err, "no matching manifest for linux")
}
diff --git a/pkg/system/init_windows.go b/pkg/system/init_windows.go
index 7f67501..f303aa9 100644
--- a/pkg/system/init_windows.go
+++ b/pkg/system/init_windows.go
@@ -3,6 +3,7 @@
import (
"os"
+ "github.com/Microsoft/hcsshim/osversion"
"github.com/sirupsen/logrus"
)
@@ -15,10 +16,10 @@
containerdRuntimeSupported = false
)
-// InitLCOW sets whether LCOW is supported or not
+// InitLCOW sets whether LCOW is supported or not. Requires RS5+
func InitLCOW(experimental bool) {
v := GetOSVersion()
- if experimental && v.Build >= 16299 {
+ if experimental && v.Build >= osversion.RS5 {
lcowSupported = true
}
}
diff --git a/project/PACKAGERS.md b/project/PACKAGERS.md
index a5b0018..0fb6c20 100644
--- a/project/PACKAGERS.md
+++ b/project/PACKAGERS.md
@@ -233,6 +233,27 @@
This will create "./bundles/$VERSION/dynbinary-client/docker-$VERSION", which for
client-only builds is the important file to grab and install as appropriate.
+### Cross Compilation
+
+Limited cross compilation is supported due to requiring cgo for critical
+functionality (such as seccomp support).
+
+To cross compile run `make cross`. You can specify the platforms to target by
+setting the `DOCKER_CROSSPLATFORMS` environment variable to a list of platforms
+in the format `<GOOS>/<GOARCH>`. Specify multiple platforms by using a space
+in between each desired platform.
+
+For setting arm variants, you can specify the `GOARM` value by append `/v<GOARM>`
+to your `<GOOS>/arm`. Example:
+
+```
+make DOCKER_CROSSPLATFORMS=linux/arm/v7 cross
+```
+
+This will create a linux binary targeting arm 7.
+
+See `hack/make/.binary` for supported cross compliation platforms.
+
## System Dependencies
### Runtime Dependencies
diff --git a/vendor.conf b/vendor.conf
index 55c4e6f..6a70d92 100644
--- a/vendor.conf
+++ b/vendor.conf
@@ -1,5 +1,5 @@
github.com/Azure/go-ansiterm d6e3b3328b783f23731bc4d058875b0371ff8109
-github.com/Microsoft/hcsshim ba3d6667710fa905116f39a19d059c4c1016be7c
+github.com/Microsoft/hcsshim 672e52e9209d1e53718c1b6a7d68cc9272654ab5
github.com/Microsoft/go-winio c599b533b43b1363d7d7c6cfda5ede70ed73ff13
github.com/docker/libtrust 9cbd2a1374f46905c68a4eb3694a130610adc62a
github.com/go-check/check 4ed411733c5785b40214c70bce814c3a3a689609 https://github.com/cpuguy83/check.git
@@ -39,7 +39,7 @@
# libnetwork
# When updating, also update LIBNETWORK_COMMIT in hack/dockerfile/install/proxy.installer accordingly
-github.com/docker/libnetwork 48f846327bbe6a0dce0c556e8dc9f5bb939d5c16
+github.com/docker/libnetwork 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0
github.com/docker/go-events 9461782956ad83b30282bf90e31fa6a70c255ba9
github.com/armon/go-radix e39d623f12e8e41c7b5529e9a9dd67a1e2261f80
github.com/armon/go-metrics eb0af217e5e9747e41dd5303755356b62d28e3ec
@@ -57,7 +57,7 @@
github.com/BurntSushi/toml 3012a1dbe2e4bd1391d42b32f0577cb7bbc7f005 # v0.3.1
github.com/samuel/go-zookeeper d0e0d8e11f318e000a8cc434616d69e329edc374
github.com/deckarep/golang-set ef32fa3046d9f249d399f98ebaf9be944430fd1d
-github.com/coreos/etcd fca8add78a9d926166eb739b8e4a124434025ba3 # v3.3.9
+github.com/coreos/etcd d57e8b8d97adfc4a6c224fe116714bf1a1f3beb9 # v3.3.12
github.com/coreos/go-semver 8ab6407b697782a06568d4b7f1db25550ec2e4c6 # v0.2.0
github.com/ugorji/go b4c50a2b199d93b13dc15e78929cfb23bfdf21ab # v1.1.1
github.com/hashicorp/consul 9a9cc9341bb487651a0399e3fc5e1e8a42e62dd9 # v0.5.2
@@ -95,9 +95,9 @@
github.com/Graylog2/go-gelf 4143646226541087117ff2f83334ea48b3201841
# fluent-logger-golang deps
-github.com/fluent/fluent-logger-golang 8bbc2356beaf021b04c9bd5cdc76ea5a7ccb40ec # v1.3.0
+github.com/fluent/fluent-logger-golang 7a6c9dcd7f14c2ed5d8c55c11b894e5455ee311b # v1.4.0
github.com/philhofer/fwd bb6d471dc95d4fe11e432687f8b70ff496cf3136 # v1.0.0
-github.com/tinylib/msgp 3b556c64540842d4f82967be066a7f7fffc3adad
+github.com/tinylib/msgp af6442a0fcf6e2a1b824f70dd0c734f01e817751 # v1.1.0
# fsnotify
github.com/fsnotify/fsnotify 1485a34d5d5723fea214f5710708e19a831720e4 # v1.4.7-11-g1485a34
@@ -130,7 +130,7 @@
github.com/gogo/googleapis 08a7655d27152912db7aaf4f983275eaf8d128ef
# cluster
-github.com/docker/swarmkit 18e7e58ea1a5ec016625a636d0d52500eea123bc
+github.com/docker/swarmkit 59163bf75df38489d4a10392265d27156dc473c5
github.com/gogo/protobuf 4cbf7e384e768b4e01799441fdf2a706a5635ae7 # v1.2.0
github.com/cloudflare/cfssl 5d63dbd981b5c408effbb58c442d54761ff94fbd # 1.3.2
github.com/fernet/fernet-go 1b2437bc582b3cfbb341ee5a29f8ef5b42912ff2
@@ -141,7 +141,7 @@
github.com/hashicorp/go-immutable-radix 826af9ccf0feeee615d546d69b11f8e98da8c8f1 git://github.com/tonistiigi/go-immutable-radix.git
github.com/hashicorp/golang-lru 7087cb70de9f7a8bc0a10c375cb0d2280a8edf9c # v0.5.1
github.com/coreos/pkg 3ac0863d7acf3bc44daf49afef8919af12f704ef # v3
-github.com/pivotal-golang/clock 3fd3c1944c59d9742e1cd333672181cd1a6f9fa0
+code.cloudfoundry.org/clock 02e53af36e6c978af692887ed449b74026d76fec
# prometheus
github.com/prometheus/client_golang c5b7fccd204277076155f10851dad72b76a49317 # v0.8.0
@@ -150,7 +150,7 @@
github.com/prometheus/common 7600349dcfe1abd18d72d3a1770870d9800a7801
github.com/prometheus/procfs 7d6f385de8bea29190f15ba9931442a0eaef9af7
github.com/matttproud/golang_protobuf_extensions c12348ce28de40eed0136aa2b644d0ee0650e56c # v1.0.1
-github.com/pkg/errors 645ef00459ed84a119197bfb8d8205042c6df63d # v0.8.0
+github.com/pkg/errors ba968bfe8b2f7e042a574c888954fccecfa385b4 # v0.8.1
github.com/grpc-ecosystem/go-grpc-prometheus c225b8c3b01faf2899099b768856a9e916e5087b # v1.2.0
# cli
diff --git a/vendor/github.com/pivotal-golang/clock/LICENSE b/vendor/code.cloudfoundry.org/clock/LICENSE
similarity index 98%
rename from vendor/github.com/pivotal-golang/clock/LICENSE
rename to vendor/code.cloudfoundry.org/clock/LICENSE
index e06d208..f49a4e1 100644
--- a/vendor/github.com/pivotal-golang/clock/LICENSE
+++ b/vendor/code.cloudfoundry.org/clock/LICENSE
@@ -1,4 +1,4 @@
-Apache License
+ Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
@@ -178,7 +178,7 @@
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
- boilerplate notice, with the fields enclosed by brackets "{}"
+ boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
@@ -186,7 +186,7 @@
same "printed page" as the copyright notice for easier
identification within third-party archives.
- Copyright {yyyy} {name of copyright owner}
+ Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
@@ -198,5 +198,4 @@
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
- limitations under the License.
-
+ limitations under the License.
\ No newline at end of file
diff --git a/vendor/code.cloudfoundry.org/clock/NOTICE b/vendor/code.cloudfoundry.org/clock/NOTICE
new file mode 100644
index 0000000..29c0e5f
--- /dev/null
+++ b/vendor/code.cloudfoundry.org/clock/NOTICE
@@ -0,0 +1,20 @@
+Copyright (c) 2015-Present CloudFoundry.org Foundation, Inc. All Rights Reserved.
+
+This project contains software that is Copyright (c) 2015 Pivotal Software, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+This project may include a number of subcomponents with separate
+copyright notices and license terms. Your use of these subcomponents
+is subject to the terms and conditions of each subcomponent's license,
+as noted in the LICENSE file.
diff --git a/vendor/code.cloudfoundry.org/clock/README.md b/vendor/code.cloudfoundry.org/clock/README.md
new file mode 100644
index 0000000..abaf641
--- /dev/null
+++ b/vendor/code.cloudfoundry.org/clock/README.md
@@ -0,0 +1,5 @@
+# clock
+
+**Note**: This repository should be imported as `code.cloudfoundry.org/clock`.
+
+Provides a `Clock` interface, useful for injecting time dependencies in tests.
diff --git a/vendor/code.cloudfoundry.org/clock/clock.go b/vendor/code.cloudfoundry.org/clock/clock.go
new file mode 100644
index 0000000..6b091d9
--- /dev/null
+++ b/vendor/code.cloudfoundry.org/clock/clock.go
@@ -0,0 +1,53 @@
+package clock
+
+import "time"
+
+type Clock interface {
+ Now() time.Time
+ Sleep(d time.Duration)
+ Since(t time.Time) time.Duration
+ // After waits for the duration to elapse and then sends the current time
+ // on the returned channel.
+ // It is equivalent to clock.NewTimer(d).C.
+ // The underlying Timer is not recovered by the garbage collector
+ // until the timer fires. If efficiency is a concern, use clock.NewTimer
+ // instead and call Timer.Stop if the timer is no longer needed.
+ After(d time.Duration) <-chan time.Time
+
+ NewTimer(d time.Duration) Timer
+ NewTicker(d time.Duration) Ticker
+}
+
+type realClock struct{}
+
+func NewClock() Clock {
+ return &realClock{}
+}
+
+func (clock *realClock) Now() time.Time {
+ return time.Now()
+}
+
+func (clock *realClock) Since(t time.Time) time.Duration {
+ return time.Now().Sub(t)
+}
+
+func (clock *realClock) Sleep(d time.Duration) {
+ <-clock.NewTimer(d).C()
+}
+
+func (clock *realClock) After(d time.Duration) <-chan time.Time {
+ return clock.NewTimer(d).C()
+}
+
+func (clock *realClock) NewTimer(d time.Duration) Timer {
+ return &realTimer{
+ t: time.NewTimer(d),
+ }
+}
+
+func (clock *realClock) NewTicker(d time.Duration) Ticker {
+ return &realTicker{
+ t: time.NewTicker(d),
+ }
+}
diff --git a/vendor/code.cloudfoundry.org/clock/package.go b/vendor/code.cloudfoundry.org/clock/package.go
new file mode 100644
index 0000000..349f67c
--- /dev/null
+++ b/vendor/code.cloudfoundry.org/clock/package.go
@@ -0,0 +1 @@
+package clock // import "code.cloudfoundry.org/clock"
diff --git a/vendor/github.com/pivotal-golang/clock/ticker.go b/vendor/code.cloudfoundry.org/clock/ticker.go
similarity index 100%
rename from vendor/github.com/pivotal-golang/clock/ticker.go
rename to vendor/code.cloudfoundry.org/clock/ticker.go
diff --git a/vendor/github.com/pivotal-golang/clock/timer.go b/vendor/code.cloudfoundry.org/clock/timer.go
similarity index 100%
rename from vendor/github.com/pivotal-golang/clock/timer.go
rename to vendor/code.cloudfoundry.org/clock/timer.go
diff --git a/vendor/github.com/Microsoft/hcsshim/internal/guestrequest/types.go b/vendor/github.com/Microsoft/hcsshim/internal/guestrequest/types.go
deleted file mode 100644
index 5d3d0df..0000000
--- a/vendor/github.com/Microsoft/hcsshim/internal/guestrequest/types.go
+++ /dev/null
@@ -1,100 +0,0 @@
-package guestrequest
-
-import (
- "github.com/Microsoft/hcsshim/internal/schema2"
-)
-
-// Arguably, many of these (at least CombinedLayers) should have been generated
-// by swagger.
-//
-// This will also change package name due to an inbound breaking change.
-
-// This class is used by a modify request to add or remove a combined layers
-// structure in the guest. For windows, the GCS applies a filter in ContainerRootPath
-// using the specified layers as the parent content. Ignores property ScratchPath
-// since the container path is already the scratch path. For linux, the GCS unions
-// the specified layers and ScratchPath together, placing the resulting union
-// filesystem at ContainerRootPath.
-type CombinedLayers struct {
- ContainerRootPath string `json:"ContainerRootPath,omitempty"`
- Layers []hcsschema.Layer `json:"Layers,omitempty"`
- ScratchPath string `json:"ScratchPath,omitempty"`
-}
-
-// Defines the schema for hosted settings passed to GCS and/or OpenGCS
-
-// SCSI. Scratch space for remote file-system commands, or R/W layer for containers
-type LCOWMappedVirtualDisk struct {
- MountPath string `json:"MountPath,omitempty"` // /tmp/scratch for an LCOW utility VM being used as a service VM
- Lun uint8 `json:"Lun,omitempty"`
- Controller uint8 `json:"Controller,omitempty"`
- ReadOnly bool `json:"ReadOnly,omitempty"`
-}
-
-type WCOWMappedVirtualDisk struct {
- ContainerPath string `json:"ContainerPath,omitempty"`
- Lun int32 `json:"Lun,omitempty"`
-}
-
-type LCOWMappedDirectory struct {
- MountPath string `json:"MountPath,omitempty"`
- Port int32 `json:"Port,omitempty"`
- ShareName string `json:"ShareName,omitempty"` // If empty not using ANames (not currently supported)
- ReadOnly bool `json:"ReadOnly,omitempty"`
-}
-
-// Read-only layers over VPMem
-type LCOWMappedVPMemDevice struct {
- DeviceNumber uint32 `json:"DeviceNumber,omitempty"`
- MountPath string `json:"MountPath,omitempty"` // /tmp/pN
-}
-
-type LCOWNetworkAdapter struct {
- NamespaceID string `json:",omitempty"`
- ID string `json:",omitempty"`
- MacAddress string `json:",omitempty"`
- IPAddress string `json:",omitempty"`
- PrefixLength uint8 `json:",omitempty"`
- GatewayAddress string `json:",omitempty"`
- DNSSuffix string `json:",omitempty"`
- DNSServerList string `json:",omitempty"`
- EnableLowMetric bool `json:",omitempty"`
- EncapOverhead uint16 `json:",omitempty"`
-}
-
-type ResourceType string
-
-const (
- // These are constants for v2 schema modify guest requests.
- ResourceTypeMappedDirectory ResourceType = "MappedDirectory"
- ResourceTypeMappedVirtualDisk ResourceType = "MappedVirtualDisk"
- ResourceTypeNetwork ResourceType = "Network"
- ResourceTypeNetworkNamespace ResourceType = "NetworkNamespace"
- ResourceTypeCombinedLayers ResourceType = "CombinedLayers"
- ResourceTypeVPMemDevice ResourceType = "VPMemDevice"
-)
-
-// GuestRequest is for modify commands passed to the guest.
-type GuestRequest struct {
- RequestType string `json:"RequestType,omitempty"`
- ResourceType ResourceType `json:"ResourceType,omitempty"`
- Settings interface{} `json:"Settings,omitempty"`
-}
-
-type NetworkModifyRequest struct {
- AdapterId string `json:"AdapterId,omitempty"`
- RequestType string `json:"RequestType,omitempty"`
- Settings interface{} `json:"Settings,omitempty"`
-}
-
-type RS4NetworkModifyRequest struct {
- AdapterInstanceId string `json:"AdapterInstanceId,omitempty"`
- RequestType string `json:"RequestType,omitempty"`
- Settings interface{} `json:"Settings,omitempty"`
-}
-
-// SignalProcessOptions is the options passed to either WCOW or LCOW
-// to signal a given process.
-type SignalProcessOptions struct {
- Signal int `json:,omitempty`
-}
diff --git a/vendor/github.com/Microsoft/hcsshim/internal/hcs/callback.go b/vendor/github.com/Microsoft/hcsshim/internal/hcs/callback.go
index f9a922a..6d90987 100644
--- a/vendor/github.com/Microsoft/hcsshim/internal/hcs/callback.go
+++ b/vendor/github.com/Microsoft/hcsshim/internal/hcs/callback.go
@@ -1,10 +1,12 @@
package hcs
import (
+ "fmt"
"sync"
"syscall"
"github.com/Microsoft/hcsshim/internal/interop"
+ "github.com/Microsoft/hcsshim/internal/logfields"
"github.com/sirupsen/logrus"
)
@@ -40,16 +42,61 @@
)
type hcsNotification uint32
+
+func (hn hcsNotification) String() string {
+ switch hn {
+ case hcsNotificationSystemExited:
+ return "SystemExited"
+ case hcsNotificationSystemCreateCompleted:
+ return "SystemCreateCompleted"
+ case hcsNotificationSystemStartCompleted:
+ return "SystemStartCompleted"
+ case hcsNotificationSystemPauseCompleted:
+ return "SystemPauseCompleted"
+ case hcsNotificationSystemResumeCompleted:
+ return "SystemResumeCompleted"
+ case hcsNotificationSystemCrashReport:
+ return "SystemCrashReport"
+ case hcsNotificationSystemSiloJobCreated:
+ return "SystemSiloJobCreated"
+ case hcsNotificationSystemSaveCompleted:
+ return "SystemSaveCompleted"
+ case hcsNotificationSystemRdpEnhancedModeStateChanged:
+ return "SystemRdpEnhancedModeStateChanged"
+ case hcsNotificationSystemShutdownFailed:
+ return "SystemShutdownFailed"
+ case hcsNotificationSystemGetPropertiesCompleted:
+ return "SystemGetPropertiesCompleted"
+ case hcsNotificationSystemModifyCompleted:
+ return "SystemModifyCompleted"
+ case hcsNotificationSystemCrashInitiated:
+ return "SystemCrashInitiated"
+ case hcsNotificationSystemGuestConnectionClosed:
+ return "SystemGuestConnectionClosed"
+ case hcsNotificationProcessExited:
+ return "ProcessExited"
+ case hcsNotificationInvalid:
+ return "Invalid"
+ case hcsNotificationServiceDisconnect:
+ return "ServiceDisconnect"
+ default:
+ return fmt.Sprintf("Unknown: %d", hn)
+ }
+}
+
type notificationChannel chan error
type notifcationWatcherContext struct {
channels notificationChannels
handle hcsCallback
+
+ systemID string
+ processID int
}
type notificationChannels map[hcsNotification]notificationChannel
-func newChannels() notificationChannels {
+func newSystemChannels() notificationChannels {
channels := make(notificationChannels)
channels[hcsNotificationSystemExited] = make(notificationChannel, 1)
@@ -57,17 +104,14 @@
channels[hcsNotificationSystemStartCompleted] = make(notificationChannel, 1)
channels[hcsNotificationSystemPauseCompleted] = make(notificationChannel, 1)
channels[hcsNotificationSystemResumeCompleted] = make(notificationChannel, 1)
+
+ return channels
+}
+
+func newProcessChannels() notificationChannels {
+ channels := make(notificationChannels)
+
channels[hcsNotificationProcessExited] = make(notificationChannel, 1)
- channels[hcsNotificationServiceDisconnect] = make(notificationChannel, 1)
- channels[hcsNotificationSystemCrashReport] = make(notificationChannel, 1)
- channels[hcsNotificationSystemSiloJobCreated] = make(notificationChannel, 1)
- channels[hcsNotificationSystemSaveCompleted] = make(notificationChannel, 1)
- channels[hcsNotificationSystemRdpEnhancedModeStateChanged] = make(notificationChannel, 1)
- channels[hcsNotificationSystemShutdownFailed] = make(notificationChannel, 1)
- channels[hcsNotificationSystemGetPropertiesCompleted] = make(notificationChannel, 1)
- channels[hcsNotificationSystemModifyCompleted] = make(notificationChannel, 1)
- channels[hcsNotificationSystemCrashInitiated] = make(notificationChannel, 1)
- channels[hcsNotificationSystemGuestConnectionClosed] = make(notificationChannel, 1)
return channels
}
@@ -92,12 +136,28 @@
return 0
}
+ log := logrus.WithFields(logrus.Fields{
+ "notification-type": notificationType.String(),
+ "system-id": context.systemID,
+ })
+ if context.processID != 0 {
+ log.Data[logfields.ProcessID] = context.processID
+ }
+ log.Debug("")
+
+ // The HCS notification system can grow overtime. We explicitly opt-in to
+ // the notifications we would like to handle, all others we simply return.
+ // This means that as it grows we don't have issues associated with new
+ // notification types the code didn't know about.
+ switch notificationType {
+ case hcsNotificationSystemExited, hcsNotificationSystemCreateCompleted, hcsNotificationSystemStartCompleted, hcsNotificationSystemPauseCompleted, hcsNotificationSystemResumeCompleted:
+ case hcsNotificationProcessExited:
+ default:
+ return 0
+ }
+
if channel, ok := context.channels[notificationType]; ok {
channel <- result
- } else {
- logrus.WithFields(logrus.Fields{
- "notification-type": notificationType,
- }).Warn("Received a callback of an unsupported type")
}
return 0
diff --git a/vendor/github.com/Microsoft/hcsshim/internal/hcs/errors.go b/vendor/github.com/Microsoft/hcsshim/internal/hcs/errors.go
index 079b565..316853a 100644
--- a/vendor/github.com/Microsoft/hcsshim/internal/hcs/errors.go
+++ b/vendor/github.com/Microsoft/hcsshim/internal/hcs/errors.go
@@ -272,6 +272,13 @@
err == ErrVmcomputeUnknownMessage
}
+// IsOperationInvalidState returns true when err is caused by
+// `ErrVmcomputeOperationInvalidState`.
+func IsOperationInvalidState(err error) bool {
+ err = getInnerError(err)
+ return err == ErrVmcomputeOperationInvalidState
+}
+
func getInnerError(err error) error {
switch pe := err.(type) {
case nil:
diff --git a/vendor/github.com/Microsoft/hcsshim/internal/hcs/hcs.go b/vendor/github.com/Microsoft/hcsshim/internal/hcs/hcs.go
index b0d49cb..5bbb31d 100644
--- a/vendor/github.com/Microsoft/hcsshim/internal/hcs/hcs.go
+++ b/vendor/github.com/Microsoft/hcsshim/internal/hcs/hcs.go
@@ -27,7 +27,7 @@
//sys hcsOpenProcess(computeSystem hcsSystem, pid uint32, process *hcsProcess, result **uint16) (hr error) = vmcompute.HcsOpenProcess?
//sys hcsCloseProcess(process hcsProcess) (hr error) = vmcompute.HcsCloseProcess?
//sys hcsTerminateProcess(process hcsProcess, result **uint16) (hr error) = vmcompute.HcsTerminateProcess?
-//sys hcsSignalProcess(process hcsProcess, options string, result **uint16) (hr error) = vmcompute.HcsTerminateProcess?
+//sys hcsSignalProcess(process hcsProcess, options string, result **uint16) (hr error) = vmcompute.HcsSignalProcess?
//sys hcsGetProcessInfo(process hcsProcess, processInformation *hcsProcessInformation, result **uint16) (hr error) = vmcompute.HcsGetProcessInfo?
//sys hcsGetProcessProperties(process hcsProcess, processProperties **uint16, result **uint16) (hr error) = vmcompute.HcsGetProcessProperties?
//sys hcsModifyProcess(process hcsProcess, settings string, result **uint16) (hr error) = vmcompute.HcsModifyProcess?
diff --git a/vendor/github.com/Microsoft/hcsshim/internal/hcs/process.go b/vendor/github.com/Microsoft/hcsshim/internal/hcs/process.go
index c8db706..997a37a 100644
--- a/vendor/github.com/Microsoft/hcsshim/internal/hcs/process.go
+++ b/vendor/github.com/Microsoft/hcsshim/internal/hcs/process.go
@@ -7,7 +7,6 @@
"syscall"
"time"
- "github.com/Microsoft/hcsshim/internal/guestrequest"
"github.com/Microsoft/hcsshim/internal/interop"
"github.com/Microsoft/hcsshim/internal/logfields"
"github.com/sirupsen/logrus"
@@ -112,7 +111,11 @@
}
// Signal signals the process with `options`.
-func (process *Process) Signal(options guestrequest.SignalProcessOptions) (err error) {
+//
+// For LCOW `guestrequest.SignalProcessOptionsLCOW`.
+//
+// For WCOW `guestrequest.SignalProcessOptionsWCOW`.
+func (process *Process) Signal(options interface{}) (err error) {
process.handleLock.RLock()
defer process.handleLock.RUnlock()
@@ -189,7 +192,7 @@
<-process.waitBlock
if process.waitError != nil {
- return makeProcessError(process, operation, err, nil)
+ return makeProcessError(process, operation, process.waitError, nil)
}
return nil
}
@@ -432,7 +435,9 @@
func (process *Process) registerCallback() error {
context := ¬ifcationWatcherContext{
- channels: newChannels(),
+ channels: newProcessChannels(),
+ systemID: process.SystemID(),
+ processID: process.processID,
}
callbackMapLock.Lock()
diff --git a/vendor/github.com/Microsoft/hcsshim/internal/hcs/system.go b/vendor/github.com/Microsoft/hcsshim/internal/hcs/system.go
index fd5f485..29a734c 100644
--- a/vendor/github.com/Microsoft/hcsshim/internal/hcs/system.go
+++ b/vendor/github.com/Microsoft/hcsshim/internal/hcs/system.go
@@ -414,18 +414,19 @@
computeSystem.logOperationBegin(operation)
defer func() { computeSystem.logOperationEnd(operation, err) }()
- queryj, err := json.Marshal(schema1.PropertyQuery{types})
+ queryBytes, err := json.Marshal(schema1.PropertyQuery{PropertyTypes: types})
if err != nil {
return nil, makeSystemError(computeSystem, "Properties", "", err, nil)
}
+ queryString := string(queryBytes)
logrus.WithFields(computeSystem.logctx).
- WithField(logfields.JSON, queryj).
+ WithField(logfields.JSON, queryString).
Debug("HCS ComputeSystem Properties Query")
var resultp, propertiesp *uint16
syscallWatcher(computeSystem.logctx, func() {
- err = hcsGetComputeSystemProperties(computeSystem.handle, string(queryj), &propertiesp, &resultp)
+ err = hcsGetComputeSystemProperties(computeSystem.handle, string(queryString), &propertiesp, &resultp)
})
events := processHcsResult(resultp)
if err != nil {
@@ -625,7 +626,8 @@
func (computeSystem *System) registerCallback() error {
context := ¬ifcationWatcherContext{
- channels: newChannels(),
+ channels: newSystemChannels(),
+ systemID: computeSystem.id,
}
callbackMapLock.Lock()
diff --git a/vendor/github.com/Microsoft/hcsshim/internal/hcs/zsyscall_windows.go b/vendor/github.com/Microsoft/hcsshim/internal/hcs/zsyscall_windows.go
index fcd5cdc..20bfad2 100644
--- a/vendor/github.com/Microsoft/hcsshim/internal/hcs/zsyscall_windows.go
+++ b/vendor/github.com/Microsoft/hcsshim/internal/hcs/zsyscall_windows.go
@@ -56,13 +56,13 @@
procHcsOpenProcess = modvmcompute.NewProc("HcsOpenProcess")
procHcsCloseProcess = modvmcompute.NewProc("HcsCloseProcess")
procHcsTerminateProcess = modvmcompute.NewProc("HcsTerminateProcess")
-
- procHcsGetProcessInfo = modvmcompute.NewProc("HcsGetProcessInfo")
- procHcsGetProcessProperties = modvmcompute.NewProc("HcsGetProcessProperties")
- procHcsModifyProcess = modvmcompute.NewProc("HcsModifyProcess")
- procHcsGetServiceProperties = modvmcompute.NewProc("HcsGetServiceProperties")
- procHcsRegisterProcessCallback = modvmcompute.NewProc("HcsRegisterProcessCallback")
- procHcsUnregisterProcessCallback = modvmcompute.NewProc("HcsUnregisterProcessCallback")
+ procHcsSignalProcess = modvmcompute.NewProc("HcsSignalProcess")
+ procHcsGetProcessInfo = modvmcompute.NewProc("HcsGetProcessInfo")
+ procHcsGetProcessProperties = modvmcompute.NewProc("HcsGetProcessProperties")
+ procHcsModifyProcess = modvmcompute.NewProc("HcsModifyProcess")
+ procHcsGetServiceProperties = modvmcompute.NewProc("HcsGetServiceProperties")
+ procHcsRegisterProcessCallback = modvmcompute.NewProc("HcsRegisterProcessCallback")
+ procHcsUnregisterProcessCallback = modvmcompute.NewProc("HcsUnregisterProcessCallback")
)
func hcsEnumerateComputeSystems(query string, computeSystems **uint16, result **uint16) (hr error) {
@@ -417,10 +417,10 @@
}
func _hcsSignalProcess(process hcsProcess, options *uint16, result **uint16) (hr error) {
- if hr = procHcsTerminateProcess.Find(); hr != nil {
+ if hr = procHcsSignalProcess.Find(); hr != nil {
return
}
- r0, _, _ := syscall.Syscall(procHcsTerminateProcess.Addr(), 3, uintptr(process), uintptr(unsafe.Pointer(options)), uintptr(unsafe.Pointer(result)))
+ r0, _, _ := syscall.Syscall(procHcsSignalProcess.Addr(), 3, uintptr(process), uintptr(unsafe.Pointer(options)), uintptr(unsafe.Pointer(result)))
if int32(r0) < 0 {
if r0&0x1fff0000 == 0x00070000 {
r0 &= 0xffff
diff --git a/vendor/github.com/Microsoft/hcsshim/osversion/osversion_windows.go b/vendor/github.com/Microsoft/hcsshim/osversion/osversion_windows.go
new file mode 100644
index 0000000..916950c
--- /dev/null
+++ b/vendor/github.com/Microsoft/hcsshim/osversion/osversion_windows.go
@@ -0,0 +1,51 @@
+package osversion
+
+import (
+ "fmt"
+
+ "golang.org/x/sys/windows"
+)
+
+// OSVersion is a wrapper for Windows version information
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724439(v=vs.85).aspx
+type OSVersion struct {
+ Version uint32
+ MajorVersion uint8
+ MinorVersion uint8
+ Build uint16
+}
+
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724833(v=vs.85).aspx
+type osVersionInfoEx struct {
+ OSVersionInfoSize uint32
+ MajorVersion uint32
+ MinorVersion uint32
+ BuildNumber uint32
+ PlatformID uint32
+ CSDVersion [128]uint16
+ ServicePackMajor uint16
+ ServicePackMinor uint16
+ SuiteMask uint16
+ ProductType byte
+ Reserve byte
+}
+
+// Get gets the operating system version on Windows.
+// The calling application must be manifested to get the correct version information.
+func Get() OSVersion {
+ var err error
+ osv := OSVersion{}
+ osv.Version, err = windows.GetVersion()
+ if err != nil {
+ // GetVersion never fails.
+ panic(err)
+ }
+ osv.MajorVersion = uint8(osv.Version & 0xFF)
+ osv.MinorVersion = uint8(osv.Version >> 8 & 0xFF)
+ osv.Build = uint16(osv.Version >> 16)
+ return osv
+}
+
+func (osv OSVersion) ToString() string {
+ return fmt.Sprintf("%d.%d.%d", osv.MajorVersion, osv.MinorVersion, osv.Build)
+}
diff --git a/vendor/github.com/Microsoft/hcsshim/osversion/windowsbuilds.go b/vendor/github.com/Microsoft/hcsshim/osversion/windowsbuilds.go
new file mode 100644
index 0000000..c26d35a
--- /dev/null
+++ b/vendor/github.com/Microsoft/hcsshim/osversion/windowsbuilds.go
@@ -0,0 +1,23 @@
+package osversion
+
+const (
+ // RS1 (version 1607, codename "Redstone 1") corresponds to Windows Server
+ // 2016 (ltsc2016) and Windows 10 (Anniversary Update).
+ RS1 = 14393
+
+ // RS2 (version 1703, codename "Redstone 2") was a client-only update, and
+ // corresponds to Windows 10 (Creators Update).
+ RS2 = 15063
+
+ // RS3 (version 1709, codename "Redstone 3") corresponds to Windows Server
+ // 1709 (Semi-Annual Channel (SAC)), and Windows 10 (Fall Creators Update).
+ RS3 = 16299
+
+ // RS4 (version 1803, codename "Redstone 4") corresponds to Windows Server
+ // 1809 (Semi-Annual Channel (SAC)), and Windows 10 (April 2018 Update).
+ RS4 = 17134
+
+ // RS5 (version 1809, codename "Redstone 5") corresponds to Windows Server
+ // 2019 (ltsc2019), and Windows 10 (October 2018 Update).
+ RS5 = 17763
+)
diff --git a/vendor/github.com/Microsoft/hcsshim/vendor.conf b/vendor/github.com/Microsoft/hcsshim/vendor.conf
index bb25ae7..888336e 100644
--- a/vendor/github.com/Microsoft/hcsshim/vendor.conf
+++ b/vendor/github.com/Microsoft/hcsshim/vendor.conf
@@ -10,7 +10,7 @@
github.com/hashicorp/go-multierror ed905158d87462226a13fe39ddf685ea65f1c11f
github.com/konsorten/go-windows-terminal-sequences v1.0.1
github.com/linuxkit/virtsock 8e79449dea0735c1c056d814934dd035734cc97c
-github.com/Microsoft/go-winio c599b533b43b1363d7d7c6cfda5ede70ed73ff13
+github.com/Microsoft/go-winio 84b4ab48a50763fe7b3abcef38e5205c12027fac
github.com/Microsoft/opengcs v0.3.9
github.com/opencontainers/go-digest c9281466c8b2f606084ac71339773efd177436e7
github.com/opencontainers/runc 12f6a991201fdb8f82579582d5e00e28fba06d0a
diff --git a/vendor/github.com/coreos/etcd/snap/db.go b/vendor/github.com/coreos/etcd/snap/db.go
index 01d897a..dcbd3bd 100644
--- a/vendor/github.com/coreos/etcd/snap/db.go
+++ b/vendor/github.com/coreos/etcd/snap/db.go
@@ -21,6 +21,7 @@
"io/ioutil"
"os"
"path/filepath"
+ "time"
"github.com/coreos/etcd/pkg/fileutil"
)
@@ -30,6 +31,8 @@
// SaveDBFrom saves snapshot of the database from the given reader. It
// guarantees the save operation is atomic.
func (s *Snapshotter) SaveDBFrom(r io.Reader, id uint64) (int64, error) {
+ start := time.Now()
+
f, err := ioutil.TempFile(s.dir, "tmp")
if err != nil {
return 0, err
@@ -37,7 +40,9 @@
var n int64
n, err = io.Copy(f, r)
if err == nil {
+ fsyncStart := time.Now()
err = fileutil.Fsync(f)
+ snapDBFsyncSec.Observe(time.Since(fsyncStart).Seconds())
}
f.Close()
if err != nil {
@@ -57,6 +62,7 @@
plog.Infof("saved database snapshot to disk [total bytes: %d]", n)
+ snapDBSaveSec.Observe(time.Since(start).Seconds())
return n, nil
}
diff --git a/vendor/github.com/coreos/etcd/snap/metrics.go b/vendor/github.com/coreos/etcd/snap/metrics.go
index 433ef09..0d3b7e6 100644
--- a/vendor/github.com/coreos/etcd/snap/metrics.go
+++ b/vendor/github.com/coreos/etcd/snap/metrics.go
@@ -33,9 +33,33 @@
Help: "The marshalling cost distributions of save called by snapshot.",
Buckets: prometheus.ExponentialBuckets(0.001, 2, 14),
})
+
+ snapDBSaveSec = prometheus.NewHistogram(prometheus.HistogramOpts{
+ Namespace: "etcd",
+ Subsystem: "snap_db",
+ Name: "save_total_duration_seconds",
+ Help: "The total latency distributions of v3 snapshot save",
+
+ // lowest bucket start of upper bound 0.1 sec (100 ms) with factor 2
+ // highest bucket start of 0.1 sec * 2^9 == 51.2 sec
+ Buckets: prometheus.ExponentialBuckets(0.1, 2, 10),
+ })
+
+ snapDBFsyncSec = prometheus.NewHistogram(prometheus.HistogramOpts{
+ Namespace: "etcd",
+ Subsystem: "snap_db",
+ Name: "fsync_duration_seconds",
+ Help: "The latency distributions of fsyncing .snap.db file",
+
+ // lowest bucket start of upper bound 0.001 sec (1 ms) with factor 2
+ // highest bucket start of 0.001 sec * 2^13 == 8.192 sec
+ Buckets: prometheus.ExponentialBuckets(0.001, 2, 14),
+ })
)
func init() {
prometheus.MustRegister(saveDurations)
prometheus.MustRegister(marshallingDurations)
+ prometheus.MustRegister(snapDBSaveSec)
+ prometheus.MustRegister(snapDBFsyncSec)
}
diff --git a/vendor/github.com/coreos/etcd/version/version.go b/vendor/github.com/coreos/etcd/version/version.go
index 156e0f1..4bf2fd2 100644
--- a/vendor/github.com/coreos/etcd/version/version.go
+++ b/vendor/github.com/coreos/etcd/version/version.go
@@ -26,7 +26,7 @@
var (
// MinClusterVersion is the min cluster version this etcd binary is compatible with.
MinClusterVersion = "3.0.0"
- Version = "3.3.9"
+ Version = "3.3.12"
APIVersion = "unknown"
// Git SHA Value will be set during build
diff --git a/vendor/github.com/docker/libnetwork/drivers/windows/overlay/ov_endpoint_windows.go b/vendor/github.com/docker/libnetwork/drivers/windows/overlay/ov_endpoint_windows.go
index d1a4d9e..cc5679f 100644
--- a/vendor/github.com/docker/libnetwork/drivers/windows/overlay/ov_endpoint_windows.go
+++ b/vendor/github.com/docker/libnetwork/drivers/windows/overlay/ov_endpoint_windows.go
@@ -171,7 +171,19 @@
return err
}
- pbPolicy, err := windows.ConvertPortBindings(epConnectivity.PortBindings)
+ ep.portMapping = epConnectivity.PortBindings
+ ep.portMapping, err = windows.AllocatePorts(n.portMapper, ep.portMapping, ep.addr.IP)
+ if err != nil {
+ return err
+ }
+
+ defer func() {
+ if err != nil {
+ windows.ReleasePorts(n.portMapper, ep.portMapping)
+ }
+ }()
+
+ pbPolicy, err := windows.ConvertPortBindings(ep.portMapping)
if err != nil {
return err
}
@@ -229,6 +241,8 @@
return fmt.Errorf("endpoint id %q not found", eid)
}
+ windows.ReleasePorts(n.portMapper, ep.portMapping)
+
n.deleteEndpoint(eid)
_, err := endpointRequest("DELETE", ep.profileID, "")
diff --git a/vendor/github.com/docker/libnetwork/drivers/windows/overlay/ov_network_windows.go b/vendor/github.com/docker/libnetwork/drivers/windows/overlay/ov_network_windows.go
index 9cc46f8..592cfc6 100644
--- a/vendor/github.com/docker/libnetwork/drivers/windows/overlay/ov_network_windows.go
+++ b/vendor/github.com/docker/libnetwork/drivers/windows/overlay/ov_network_windows.go
@@ -11,6 +11,7 @@
"github.com/Microsoft/hcsshim"
"github.com/docker/libnetwork/driverapi"
"github.com/docker/libnetwork/netlabel"
+ "github.com/docker/libnetwork/portmapper"
"github.com/docker/libnetwork/types"
"github.com/sirupsen/logrus"
)
@@ -46,6 +47,7 @@
initErr error
subnets []*subnet
secure bool
+ portMapper *portmapper.PortMapper
sync.Mutex
}
@@ -89,10 +91,11 @@
}
n := &network{
- id: id,
- driver: d,
- endpoints: endpointTable{},
- subnets: []*subnet{},
+ id: id,
+ driver: d,
+ endpoints: endpointTable{},
+ subnets: []*subnet{},
+ portMapper: portmapper.New(""),
}
genData, ok := option[netlabel.GenericData].(map[string]string)
diff --git a/vendor/github.com/docker/libnetwork/drivers/windows/port_mapping.go b/vendor/github.com/docker/libnetwork/drivers/windows/port_mapping.go
new file mode 100644
index 0000000..51791fd
--- /dev/null
+++ b/vendor/github.com/docker/libnetwork/drivers/windows/port_mapping.go
@@ -0,0 +1,125 @@
+// +build windows
+
+package windows
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "net"
+
+ "github.com/docker/libnetwork/portmapper"
+ "github.com/docker/libnetwork/types"
+ "github.com/ishidawataru/sctp"
+ "github.com/sirupsen/logrus"
+)
+
+const (
+ maxAllocatePortAttempts = 10
+)
+
+// ErrUnsupportedAddressType is returned when the specified address type is not supported.
+type ErrUnsupportedAddressType string
+
+func (uat ErrUnsupportedAddressType) Error() string {
+ return fmt.Sprintf("unsupported address type: %s", string(uat))
+}
+
+// AllocatePorts allocates ports specified in bindings from the portMapper
+func AllocatePorts(portMapper *portmapper.PortMapper, bindings []types.PortBinding, containerIP net.IP) ([]types.PortBinding, error) {
+ bs := make([]types.PortBinding, 0, len(bindings))
+ for _, c := range bindings {
+ b := c.GetCopy()
+ if err := allocatePort(portMapper, &b, containerIP); err != nil {
+ // On allocation failure, release previously allocated ports. On cleanup error, just log a warning message
+ if cuErr := ReleasePorts(portMapper, bs); cuErr != nil {
+ logrus.Warnf("Upon allocation failure for %v, failed to clear previously allocated port bindings: %v", b, cuErr)
+ }
+ return nil, err
+ }
+ bs = append(bs, b)
+ }
+ return bs, nil
+}
+
+func allocatePort(portMapper *portmapper.PortMapper, bnd *types.PortBinding, containerIP net.IP) error {
+ var (
+ host net.Addr
+ err error
+ )
+
+ // Store the container interface address in the operational binding
+ bnd.IP = containerIP
+
+ // Adjust HostPortEnd if this is not a range.
+ if bnd.HostPortEnd == 0 {
+ bnd.HostPortEnd = bnd.HostPort
+ }
+
+ // Construct the container side transport address
+ container, err := bnd.ContainerAddr()
+ if err != nil {
+ return err
+ }
+
+ // Try up to maxAllocatePortAttempts times to get a port that's not already allocated.
+ for i := 0; i < maxAllocatePortAttempts; i++ {
+ if host, err = portMapper.MapRange(container, bnd.HostIP, int(bnd.HostPort), int(bnd.HostPortEnd), false); err == nil {
+ break
+ }
+ // There is no point in immediately retrying to map an explicitly chosen port.
+ if bnd.HostPort != 0 {
+ logrus.Warnf("Failed to allocate and map port %d-%d: %s", bnd.HostPort, bnd.HostPortEnd, err)
+ break
+ }
+ logrus.Warnf("Failed to allocate and map port: %s, retry: %d", err, i+1)
+ }
+ if err != nil {
+ return err
+ }
+
+ // Save the host port (regardless it was or not specified in the binding)
+ switch netAddr := host.(type) {
+ case *net.TCPAddr:
+ bnd.HostPort = uint16(host.(*net.TCPAddr).Port)
+ break
+ case *net.UDPAddr:
+ bnd.HostPort = uint16(host.(*net.UDPAddr).Port)
+ break
+ case *sctp.SCTPAddr:
+ bnd.HostPort = uint16(host.(*sctp.SCTPAddr).Port)
+ break
+ default:
+ // For completeness
+ return ErrUnsupportedAddressType(fmt.Sprintf("%T", netAddr))
+ }
+ //Windows does not support host port ranges.
+ bnd.HostPortEnd = bnd.HostPort
+ return nil
+}
+
+// ReleasePorts releases ports specified in bindings from the portMapper
+func ReleasePorts(portMapper *portmapper.PortMapper, bindings []types.PortBinding) error {
+ var errorBuf bytes.Buffer
+
+ // Attempt to release all port bindings, do not stop on failure
+ for _, m := range bindings {
+ if err := releasePort(portMapper, m); err != nil {
+ errorBuf.WriteString(fmt.Sprintf("\ncould not release %v because of %v", m, err))
+ }
+ }
+
+ if errorBuf.Len() != 0 {
+ return errors.New(errorBuf.String())
+ }
+ return nil
+}
+
+func releasePort(portMapper *portmapper.PortMapper, bnd types.PortBinding) error {
+ // Construct the host side transport address
+ host, err := bnd.HostAddr()
+ if err != nil {
+ return err
+ }
+ return portMapper.Unmap(host)
+}
diff --git a/vendor/github.com/docker/libnetwork/drivers/windows/windows.go b/vendor/github.com/docker/libnetwork/drivers/windows/windows.go
index c1cc61a..c8ab047 100644
--- a/vendor/github.com/docker/libnetwork/drivers/windows/windows.go
+++ b/vendor/github.com/docker/libnetwork/drivers/windows/windows.go
@@ -25,6 +25,7 @@
"github.com/docker/libnetwork/discoverapi"
"github.com/docker/libnetwork/driverapi"
"github.com/docker/libnetwork/netlabel"
+ "github.com/docker/libnetwork/portmapper"
"github.com/docker/libnetwork/types"
"github.com/sirupsen/logrus"
)
@@ -88,11 +89,12 @@
}
type hnsNetwork struct {
- id string
- created bool
- config *networkConfiguration
- endpoints map[string]*hnsEndpoint // key: endpoint id
- driver *driver // The network's driver
+ id string
+ created bool
+ config *networkConfiguration
+ endpoints map[string]*hnsEndpoint // key: endpoint id
+ driver *driver // The network's driver
+ portMapper *portmapper.PortMapper
sync.Mutex
}
@@ -252,10 +254,11 @@
func (d *driver) createNetwork(config *networkConfiguration) error {
network := &hnsNetwork{
- id: config.ID,
- endpoints: make(map[string]*hnsEndpoint),
- config: config,
- driver: d,
+ id: config.ID,
+ endpoints: make(map[string]*hnsEndpoint),
+ config: config,
+ driver: d,
+ portMapper: portmapper.New(""),
}
d.Lock()
@@ -610,7 +613,27 @@
endpointStruct.MacAddress = strings.Replace(macAddress.String(), ":", "-", -1)
}
- endpointStruct.Policies, err = ConvertPortBindings(epConnectivity.PortBindings)
+ portMapping := epConnectivity.PortBindings
+
+ if n.config.Type == "l2bridge" || n.config.Type == "l2tunnel" {
+ ip := net.IPv4(0, 0, 0, 0)
+ if ifInfo.Address() != nil {
+ ip = ifInfo.Address().IP
+ }
+
+ portMapping, err = AllocatePorts(n.portMapper, portMapping, ip)
+ if err != nil {
+ return err
+ }
+
+ defer func() {
+ if err != nil {
+ ReleasePorts(n.portMapper, portMapping)
+ }
+ }()
+ }
+
+ endpointStruct.Policies, err = ConvertPortBindings(portMapping)
if err != nil {
return err
}
@@ -721,6 +744,10 @@
return err
}
+ if n.config.Type == "l2bridge" || n.config.Type == "l2tunnel" {
+ ReleasePorts(n.portMapper, ep.portMapping)
+ }
+
n.Lock()
delete(n.endpoints, eid)
n.Unlock()
diff --git a/vendor/github.com/docker/libnetwork/portallocator/portallocator.go b/vendor/github.com/docker/libnetwork/portallocator/portallocator.go
index 191b478..9798d23 100644
--- a/vendor/github.com/docker/libnetwork/portallocator/portallocator.go
+++ b/vendor/github.com/docker/libnetwork/portallocator/portallocator.go
@@ -1,5 +1,3 @@
-// +build !windows
-
package portallocator
import (
diff --git a/vendor/github.com/docker/libnetwork/portallocator/portallocator_windows.go b/vendor/github.com/docker/libnetwork/portallocator/portallocator_windows.go
index f07ae88..98cae14 100644
--- a/vendor/github.com/docker/libnetwork/portallocator/portallocator_windows.go
+++ b/vendor/github.com/docker/libnetwork/portallocator/portallocator_windows.go
@@ -1 +1,10 @@
package portallocator
+
+const (
+ StartPortRange = 60000
+ EndPortRange = 65000
+)
+
+func getDynamicPortRange() (start int, end int, err error) {
+ return StartPortRange, EndPortRange, nil
+}
diff --git a/vendor/github.com/docker/libnetwork/portmapper/mapper.go b/vendor/github.com/docker/libnetwork/portmapper/mapper.go
index 7fa37b1..be4157b 100644
--- a/vendor/github.com/docker/libnetwork/portmapper/mapper.go
+++ b/vendor/github.com/docker/libnetwork/portmapper/mapper.go
@@ -4,9 +4,7 @@
"errors"
"fmt"
"net"
- "sync"
- "github.com/docker/libnetwork/iptables"
"github.com/docker/libnetwork/portallocator"
"github.com/ishidawataru/sctp"
"github.com/sirupsen/logrus"
@@ -32,20 +30,6 @@
ErrSCTPAddrNoIP = errors.New("sctp address does not contain any IP address")
)
-// PortMapper manages the network address translation
-type PortMapper struct {
- chain *iptables.ChainInfo
- bridgeName string
-
- // udp:ip:port
- currentMappings map[string]*mapping
- lock sync.Mutex
-
- proxyPath string
-
- Allocator *portallocator.PortAllocator
-}
-
// New returns a new instance of PortMapper
func New(proxyPath string) *PortMapper {
return NewWithPortAllocator(portallocator.Get(), proxyPath)
@@ -60,12 +44,6 @@
}
}
-// SetIptablesChain sets the specified chain into portmapper
-func (pm *PortMapper) SetIptablesChain(c *iptables.ChainInfo, bridgeName string) {
- pm.chain = c
- pm.bridgeName = bridgeName
-}
-
// Map maps the specified container transport address to the host's network address and transport port
func (pm *PortMapper) Map(container net.Addr, hostIP net.IP, hostPort int, useProxy bool) (host net.Addr, err error) {
return pm.MapRange(container, hostIP, hostPort, hostPort, useProxy)
@@ -174,7 +152,7 @@
containerIP, containerPort := getIPAndPort(m.container)
if hostIP.To4() != nil {
- if err := pm.forward(iptables.Append, m.proto, hostIP, allocatedHostPort, containerIP.String(), containerPort); err != nil {
+ if err := pm.AppendForwardingTableEntry(m.proto, hostIP, allocatedHostPort, containerIP.String(), containerPort); err != nil {
return nil, err
}
}
@@ -183,7 +161,7 @@
// need to undo the iptables rules before we return
m.userlandProxy.Stop()
if hostIP.To4() != nil {
- pm.forward(iptables.Delete, m.proto, hostIP, allocatedHostPort, containerIP.String(), containerPort)
+ pm.DeleteForwardingTableEntry(m.proto, hostIP, allocatedHostPort, containerIP.String(), containerPort)
if err := pm.Allocator.ReleasePort(hostIP, m.proto, allocatedHostPort); err != nil {
return err
}
@@ -222,7 +200,7 @@
containerIP, containerPort := getIPAndPort(data.container)
hostIP, hostPort := getIPAndPort(data.host)
- if err := pm.forward(iptables.Delete, data.proto, hostIP, hostPort, containerIP.String(), containerPort); err != nil {
+ if err := pm.DeleteForwardingTableEntry(data.proto, hostIP, hostPort, containerIP.String(), containerPort); err != nil {
logrus.Errorf("Error on iptables delete: %s", err)
}
@@ -248,7 +226,7 @@
for _, data := range pm.currentMappings {
containerIP, containerPort := getIPAndPort(data.container)
hostIP, hostPort := getIPAndPort(data.host)
- if err := pm.forward(iptables.Append, data.proto, hostIP, hostPort, containerIP.String(), containerPort); err != nil {
+ if err := pm.AppendForwardingTableEntry(data.proto, hostIP, hostPort, containerIP.String(), containerPort); err != nil {
logrus.Errorf("Error on iptables add: %s", err)
}
}
@@ -285,10 +263,3 @@
}
return nil, 0
}
-
-func (pm *PortMapper) forward(action iptables.Action, proto string, sourceIP net.IP, sourcePort int, containerIP string, containerPort int) error {
- if pm.chain == nil {
- return nil
- }
- return pm.chain.Forward(action, sourceIP, sourcePort, proto, containerIP, containerPort, pm.bridgeName)
-}
diff --git a/vendor/github.com/docker/libnetwork/portmapper/mapper_linux.go b/vendor/github.com/docker/libnetwork/portmapper/mapper_linux.go
new file mode 100644
index 0000000..0e76c54
--- /dev/null
+++ b/vendor/github.com/docker/libnetwork/portmapper/mapper_linux.go
@@ -0,0 +1,46 @@
+package portmapper
+
+import (
+ "net"
+ "sync"
+
+ "github.com/docker/libnetwork/iptables"
+ "github.com/docker/libnetwork/portallocator"
+)
+
+// PortMapper manages the network address translation
+type PortMapper struct {
+ bridgeName string
+
+ // udp:ip:port
+ currentMappings map[string]*mapping
+ lock sync.Mutex
+
+ proxyPath string
+
+ Allocator *portallocator.PortAllocator
+ chain *iptables.ChainInfo
+}
+
+// SetIptablesChain sets the specified chain into portmapper
+func (pm *PortMapper) SetIptablesChain(c *iptables.ChainInfo, bridgeName string) {
+ pm.chain = c
+ pm.bridgeName = bridgeName
+}
+
+// AppendForwardingTableEntry adds a port mapping to the forwarding table
+func (pm *PortMapper) AppendForwardingTableEntry(proto string, sourceIP net.IP, sourcePort int, containerIP string, containerPort int) error {
+ return pm.forward(iptables.Append, proto, sourceIP, sourcePort, containerIP, containerPort)
+}
+
+// DeleteForwardingTableEntry removes a port mapping from the forwarding table
+func (pm *PortMapper) DeleteForwardingTableEntry(proto string, sourceIP net.IP, sourcePort int, containerIP string, containerPort int) error {
+ return pm.forward(iptables.Delete, proto, sourceIP, sourcePort, containerIP, containerPort)
+}
+
+func (pm *PortMapper) forward(action iptables.Action, proto string, sourceIP net.IP, sourcePort int, containerIP string, containerPort int) error {
+ if pm.chain == nil {
+ return nil
+ }
+ return pm.chain.Forward(action, sourceIP, sourcePort, proto, containerIP, containerPort, pm.bridgeName)
+}
diff --git a/vendor/github.com/docker/libnetwork/portmapper/mapper_windows.go b/vendor/github.com/docker/libnetwork/portmapper/mapper_windows.go
new file mode 100644
index 0000000..89651e5
--- /dev/null
+++ b/vendor/github.com/docker/libnetwork/portmapper/mapper_windows.go
@@ -0,0 +1,31 @@
+package portmapper
+
+import (
+ "net"
+ "sync"
+
+ "github.com/docker/libnetwork/portallocator"
+)
+
+// PortMapper manages the network address translation
+type PortMapper struct {
+ bridgeName string
+
+ // udp:ip:port
+ currentMappings map[string]*mapping
+ lock sync.Mutex
+
+ proxyPath string
+
+ Allocator *portallocator.PortAllocator
+}
+
+// AppendForwardingTableEntry adds a port mapping to the forwarding table
+func (pm *PortMapper) AppendForwardingTableEntry(proto string, sourceIP net.IP, sourcePort int, containerIP string, containerPort int) error {
+ return nil
+}
+
+// DeleteForwardingTableEntry removes a port mapping from the forwarding table
+func (pm *PortMapper) DeleteForwardingTableEntry(proto string, sourceIP net.IP, sourcePort int, containerIP string, containerPort int) error {
+ return nil
+}
diff --git a/vendor/github.com/docker/libnetwork/portmapper/proxy_windows.go b/vendor/github.com/docker/libnetwork/portmapper/proxy_windows.go
new file mode 100644
index 0000000..06a9e24
--- /dev/null
+++ b/vendor/github.com/docker/libnetwork/portmapper/proxy_windows.go
@@ -0,0 +1,10 @@
+package portmapper
+
+import (
+ "errors"
+ "net"
+)
+
+func newProxyCommand(proto string, hostIP net.IP, hostPort int, containerIP net.IP, containerPort int, proxyPath string) (userlandProxy, error) {
+ return nil, errors.New("proxy is unsupported on windows")
+}
diff --git a/vendor/github.com/docker/swarmkit/manager/allocator/cnmallocator/networkallocator.go b/vendor/github.com/docker/swarmkit/manager/allocator/cnmallocator/networkallocator.go
index 2f50fd3..4df84d9 100644
--- a/vendor/github.com/docker/swarmkit/manager/allocator/cnmallocator/networkallocator.go
+++ b/vendor/github.com/docker/swarmkit/manager/allocator/cnmallocator/networkallocator.go
@@ -485,7 +485,7 @@
return false
}
- if networkAttachment == nil {
+ if networkAttachment == nil || networkAttachment.Network == nil {
return false
}
diff --git a/vendor/github.com/docker/swarmkit/manager/role_manager.go b/vendor/github.com/docker/swarmkit/manager/role_manager.go
index a68bc3f..e590152 100644
--- a/vendor/github.com/docker/swarmkit/manager/role_manager.go
+++ b/vendor/github.com/docker/swarmkit/manager/role_manager.go
@@ -4,12 +4,12 @@
"context"
"time"
+ "code.cloudfoundry.org/clock"
"github.com/docker/swarmkit/api"
"github.com/docker/swarmkit/log"
"github.com/docker/swarmkit/manager/state/raft"
"github.com/docker/swarmkit/manager/state/raft/membership"
"github.com/docker/swarmkit/manager/state/store"
- "github.com/pivotal-golang/clock"
)
const (
diff --git a/vendor/github.com/docker/swarmkit/manager/state/raft/raft.go b/vendor/github.com/docker/swarmkit/manager/state/raft/raft.go
index a1193b7..ec1d7f0 100644
--- a/vendor/github.com/docker/swarmkit/manager/state/raft/raft.go
+++ b/vendor/github.com/docker/swarmkit/manager/state/raft/raft.go
@@ -11,6 +11,7 @@
"sync/atomic"
"time"
+ "code.cloudfoundry.org/clock"
"github.com/coreos/etcd/pkg/idutil"
"github.com/coreos/etcd/raft"
"github.com/coreos/etcd/raft/raftpb"
@@ -28,7 +29,6 @@
"github.com/docker/swarmkit/manager/state/store"
"github.com/docker/swarmkit/watch"
"github.com/gogo/protobuf/proto"
- "github.com/pivotal-golang/clock"
"github.com/pkg/errors"
"github.com/sirupsen/logrus"
"golang.org/x/time/rate"
diff --git a/vendor/github.com/docker/swarmkit/node/node.go b/vendor/github.com/docker/swarmkit/node/node.go
index 70179fd..f82fc13 100644
--- a/vendor/github.com/docker/swarmkit/node/node.go
+++ b/vendor/github.com/docker/swarmkit/node/node.go
@@ -274,9 +274,10 @@
// configVXLANUDPPort sets vxlan port in libnetwork
func configVXLANUDPPort(ctx context.Context, vxlanUDPPort uint32) {
if err := overlayutils.ConfigVXLANUDPPort(vxlanUDPPort); err != nil {
- log.G(ctx).WithError(err).Error("Configuring VXLAN port failed")
+ log.G(ctx).WithError(err).Error("failed to configure VXLAN UDP port")
+ return
}
- logrus.Infof(" Swarm successfully initialized VXLAN UDP Port to %d ", vxlanUDPPort)
+ logrus.Infof("initialized VXLAN UDP port to %d ", vxlanUDPPort)
}
func (n *Node) run(ctx context.Context) (err error) {
diff --git a/vendor/github.com/docker/swarmkit/vendor.conf b/vendor/github.com/docker/swarmkit/vendor.conf
index 3a2c8f7..c55f29c 100644
--- a/vendor/github.com/docker/swarmkit/vendor.conf
+++ b/vendor/github.com/docker/swarmkit/vendor.conf
@@ -8,7 +8,7 @@
# In >=1.11, those errors were brought back but the string had changed again.
# After updating GRPC, if integration test failures occur, verify that the
# string matching there is correct.
-google.golang.org/grpc v1.12.0
+google.golang.org/grpc 7a6a684ca69eb4cae85ad0a484f2e531598c047b # v1.12.2
github.com/gogo/protobuf v1.0.0
github.com/golang/protobuf v1.1.0
github.com/matttproud/golang_protobuf_extensions v1.0.0
@@ -39,7 +39,7 @@
github.com/opencontainers/image-spec v1.0.1
github.com/ishidawataru/sctp 07191f837fedd2f13d1ec7b5f885f0f3ec54b1cb
-github.com/davecgh/go-spew 346938d642f2ec3594ed81d874461961cd0faa76 # v1.1.0
+github.com/davecgh/go-spew 8991bc29aa16c548c550c7ff78260e27b9ab7c73 # v1.1.1
github.com/Microsoft/go-winio v0.4.11
github.com/sirupsen/logrus v1.0.6
github.com/beorn7/perks 3a771d992973f24aa725d07868b467d1ddfceaf
@@ -52,15 +52,15 @@
github.com/hashicorp/golang-lru 0fb14efe8c47ae851c0034ed7a448854d3d34cf3
github.com/inconshreveable/mousetrap 76626ae9c91c4f2a10f34cad8ce83ea42c93bb75
github.com/phayes/permbits f7e3ac5e859d0b919c5068d581cc4c5d4f4f9bc5
-github.com/pivotal-golang/clock 3fd3c1944c59d9742e1cd333672181cd1a6f9fa0
+code.cloudfoundry.org/clock 02e53af36e6c978af692887ed449b74026d76fec
github.com/pkg/errors 645ef00459ed84a119197bfb8d8205042c6df63d
-github.com/pmezard/go-difflib 792786c7400a136282c1664665ae0a8db921c6c2
+github.com/pmezard/go-difflib 792786c7400a136282c1664665ae0a8db921c6c2 # v1.0.0
github.com/rcrowley/go-metrics 51425a2415d21afadfd55cd93432c0bc69e9598d
github.com/spf13/cobra 8e91712f174ced10270cf66615e0a9127e7c4de5
github.com/spf13/pflag 7f60f83a2c81bc3c3c0d5297f61ddfa68da9d3b7
-github.com/stretchr/testify v1.1.4
+github.com/stretchr/testify ffdc059bfe9ce6a4e144ba849dbedead332c6053 # v1.3.0
go.etcd.io/bbolt v1.3.1-etcd.8
-golang.org/x/crypto 0709b304e793a5edb4a2c0145f281ecdc20838a4
+golang.org/x/crypto b7391e95e576cacdcdd422573063bc057239113d
golang.org/x/net a680a1efc54dd51c040b3b5ce4939ea3cf2ea0d1
golang.org/x/sys 90868a75fefd03942536221d7c0e2f84ec62a668
golang.org/x/text f21a4dfb5e38f5895301dc265a8def02365cc3d0 # v0.3.0
diff --git a/vendor/github.com/fluent/fluent-logger-golang/README.md b/vendor/github.com/fluent/fluent-logger-golang/README.md
index cbb8bdc..5930602 100644
--- a/vendor/github.com/fluent/fluent-logger-golang/README.md
+++ b/vendor/github.com/fluent/fluent-logger-golang/README.md
@@ -64,6 +64,16 @@
Sets the timeout for Write call of logger.Post.
Since the default is zero value, Write will not time out.
+### Async
+
+Enable asynchronous I/O (connect and write) for sending events to Fluentd.
+The default is false.
+
+### RequestAck
+
+Sets whether to request acknowledgment from Fluentd to increase the reliability
+of the connection. The default is false.
+
## Tests
```
go test
diff --git a/vendor/github.com/fluent/fluent-logger-golang/fluent/fluent.go b/vendor/github.com/fluent/fluent-logger-golang/fluent/fluent.go
index 4693c5c..5bbd526 100644
--- a/vendor/github.com/fluent/fluent-logger-golang/fluent/fluent.go
+++ b/vendor/github.com/fluent/fluent-logger-golang/fluent/fluent.go
@@ -6,12 +6,17 @@
"fmt"
"math"
"net"
+ "os"
"reflect"
"strconv"
"sync"
"time"
+ "bytes"
+ "encoding/base64"
+ "encoding/binary"
"github.com/tinylib/msgp/msgp"
+ "math/rand"
)
const (
@@ -21,8 +26,9 @@
defaultPort = 24224
defaultTimeout = 3 * time.Second
defaultWriteTimeout = time.Duration(0) // Write() will not time out
- defaultBufferLimit = 8 * 1024 * 1024
+ defaultBufferLimit = 8 * 1024
defaultRetryWait = 500
+ defaultMaxRetryWait = 60000
defaultMaxRetry = 13
defaultReconnectWaitIncreRate = 1.5
// Default sub-second precision value to false since it is only compatible
@@ -40,24 +46,36 @@
BufferLimit int `json:"buffer_limit"`
RetryWait int `json:"retry_wait"`
MaxRetry int `json:"max_retry"`
+ MaxRetryWait int `json:"max_retry_wait"`
TagPrefix string `json:"tag_prefix"`
- AsyncConnect bool `json:"async_connect"`
- MarshalAsJSON bool `json:"marshal_as_json"`
+ Async bool `json:"async"`
+ // Deprecated: Use Async instead
+ AsyncConnect bool `json:"async_connect"`
+ MarshalAsJSON bool `json:"marshal_as_json"`
// Sub-second precision timestamps are only possible for those using fluentd
// v0.14+ and serializing their messages with msgpack.
SubSecondPrecision bool `json:"sub_second_precision"`
+
+ // RequestAck sends the chunk option with a unique ID. The server will
+ // respond with an acknowledgement. This option improves the reliability
+ // of the message transmission.
+ RequestAck bool `json:"request_ack"`
+}
+
+type msgToSend struct {
+ data []byte
+ ack string
}
type Fluent struct {
Config
- mubuff sync.Mutex
- pending []byte
+ pending chan *msgToSend
+ wg sync.WaitGroup
- muconn sync.Mutex
- conn net.Conn
- reconnecting bool
+ muconn sync.Mutex
+ conn net.Conn
}
// New creates a new Logger.
@@ -89,11 +107,22 @@
if config.MaxRetry == 0 {
config.MaxRetry = defaultMaxRetry
}
+ if config.MaxRetryWait == 0 {
+ config.MaxRetryWait = defaultMaxRetryWait
+ }
if config.AsyncConnect {
- f = &Fluent{Config: config, reconnecting: true}
- go f.reconnect()
+ fmt.Fprintf(os.Stderr, "fluent#New: AsyncConnect is now deprecated, please use Async instead")
+ config.Async = config.Async || config.AsyncConnect
+ }
+ if config.Async {
+ f = &Fluent{
+ Config: config,
+ pending: make(chan *msgToSend, config.BufferLimit),
+ }
+ f.wg.Add(1)
+ go f.run()
} else {
- f = &Fluent{Config: config, reconnecting: false}
+ f = &Fluent{Config: config}
err = f.connect()
}
return
@@ -173,28 +202,25 @@
}
func (f *Fluent) EncodeAndPostData(tag string, tm time.Time, message interface{}) error {
- var data []byte
+ var msg *msgToSend
var err error
- if data, err = f.EncodeData(tag, tm, message); err != nil {
+ if msg, err = f.EncodeData(tag, tm, message); err != nil {
return fmt.Errorf("fluent#EncodeAndPostData: can't convert '%#v' to msgpack:%v", message, err)
}
- return f.postRawData(data)
+ return f.postRawData(msg)
}
// Deprecated: Use EncodeAndPostData instead
-func (f *Fluent) PostRawData(data []byte) {
- f.postRawData(data)
+func (f *Fluent) PostRawData(msg *msgToSend) {
+ f.postRawData(msg)
}
-func (f *Fluent) postRawData(data []byte) error {
- if err := f.appendBuffer(data); err != nil {
- return err
+func (f *Fluent) postRawData(msg *msgToSend) error {
+ if f.Config.Async {
+ return f.appendBuffer(msg)
}
- if err := f.send(); err != nil {
- f.close()
- return err
- }
- return nil
+ // Synchronous write
+ return f.write(msg)
}
// For sending forward protocol adopted JSON
@@ -207,43 +233,80 @@
// So, it should write JSON marshaler by hand.
func (chunk *MessageChunk) MarshalJSON() ([]byte, error) {
data, err := json.Marshal(chunk.message.Record)
- return []byte(fmt.Sprintf("[\"%s\",%d,%s,null]", chunk.message.Tag,
- chunk.message.Time, data)), err
+ if err != nil {
+ return nil, err
+ }
+ option, err := json.Marshal(chunk.message.Option)
+ if err != nil {
+ return nil, err
+ }
+ return []byte(fmt.Sprintf("[\"%s\",%d,%s,%s]", chunk.message.Tag,
+ chunk.message.Time, data, option)), err
}
-func (f *Fluent) EncodeData(tag string, tm time.Time, message interface{}) (data []byte, err error) {
+// getUniqueID returns a base64 encoded unique ID that can be used for chunk/ack
+// mechanism, see
+// https://github.com/fluent/fluentd/wiki/Forward-Protocol-Specification-v1#option
+func getUniqueID(timeUnix int64) (string, error) {
+ buf := bytes.NewBuffer(nil)
+ enc := base64.NewEncoder(base64.StdEncoding, buf)
+ if err := binary.Write(enc, binary.LittleEndian, timeUnix); err != nil {
+ enc.Close()
+ return "", err
+ }
+ if err := binary.Write(enc, binary.LittleEndian, rand.Uint64()); err != nil {
+ enc.Close()
+ return "", err
+ }
+ // encoder needs to be closed before buf.String(), defer does not work
+ // here
+ enc.Close()
+ return buf.String(), nil
+}
+
+func (f *Fluent) EncodeData(tag string, tm time.Time, message interface{}) (msg *msgToSend, err error) {
+ option := make(map[string]string)
+ msg = &msgToSend{}
timeUnix := tm.Unix()
+ if f.Config.RequestAck {
+ var err error
+ msg.ack, err = getUniqueID(timeUnix)
+ if err != nil {
+ return nil, err
+ }
+ option["chunk"] = msg.ack
+ }
if f.Config.MarshalAsJSON {
- msg := Message{Tag: tag, Time: timeUnix, Record: message}
- chunk := &MessageChunk{message: msg}
- data, err = json.Marshal(chunk)
+ m := Message{Tag: tag, Time: timeUnix, Record: message, Option: option}
+ chunk := &MessageChunk{message: m}
+ msg.data, err = json.Marshal(chunk)
} else if f.Config.SubSecondPrecision {
- msg := &MessageExt{Tag: tag, Time: EventTime(tm), Record: message}
- data, err = msg.MarshalMsg(nil)
+ m := &MessageExt{Tag: tag, Time: EventTime(tm), Record: message, Option: option}
+ msg.data, err = m.MarshalMsg(nil)
} else {
- msg := &Message{Tag: tag, Time: timeUnix, Record: message}
- data, err = msg.MarshalMsg(nil)
+ m := &Message{Tag: tag, Time: timeUnix, Record: message, Option: option}
+ msg.data, err = m.MarshalMsg(nil)
}
return
}
-// Close closes the connection.
+// Close closes the connection, waiting for pending logs to be sent
func (f *Fluent) Close() (err error) {
- if len(f.pending) > 0 {
- err = f.send()
+ if f.Config.Async {
+ close(f.pending)
+ f.wg.Wait()
}
f.close()
return
}
// appendBuffer appends data to buffer with lock.
-func (f *Fluent) appendBuffer(data []byte) error {
- f.mubuff.Lock()
- defer f.mubuff.Unlock()
- if len(f.pending)+len(data) > f.Config.BufferLimit {
- return errors.New(fmt.Sprintf("fluent#appendBuffer: Buffer full, limit %v", f.Config.BufferLimit))
+func (f *Fluent) appendBuffer(msg *msgToSend) error {
+ select {
+ case f.pending <- msg:
+ default:
+ return fmt.Errorf("fluent#appendBuffer: Buffer full, limit %v", f.Config.BufferLimit)
}
- f.pending = append(f.pending, data...)
return nil
}
@@ -259,8 +322,6 @@
// connect establishes a new connection using the specified transport.
func (f *Fluent) connect() (err error) {
- f.muconn.Lock()
- defer f.muconn.Unlock()
switch f.Config.FluentNetwork {
case "tcp":
@@ -270,63 +331,78 @@
default:
err = net.UnknownNetworkError(f.Config.FluentNetwork)
}
+ return err
+}
- if err == nil {
- f.reconnecting = false
+func (f *Fluent) run() {
+ for {
+ select {
+ case entry, ok := <-f.pending:
+ if !ok {
+ f.wg.Done()
+ return
+ }
+ err := f.write(entry)
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "[%s] Unable to send logs to fluentd, reconnecting...\n", time.Now().Format(time.RFC3339))
+ }
+ }
}
- return
}
func e(x, y float64) int {
return int(math.Pow(x, y))
}
-func (f *Fluent) reconnect() {
- for i := 0; ; i++ {
- err := f.connect()
- if err == nil {
- f.send()
- return
+func (f *Fluent) write(msg *msgToSend) error {
+
+ for i := 0; i < f.Config.MaxRetry; i++ {
+
+ // Connect if needed
+ f.muconn.Lock()
+ if f.conn == nil {
+ err := f.connect()
+ if err != nil {
+ f.muconn.Unlock()
+ waitTime := f.Config.RetryWait * e(defaultReconnectWaitIncreRate, float64(i-1))
+ if waitTime > f.Config.MaxRetryWait {
+ waitTime = f.Config.MaxRetryWait
+ }
+ time.Sleep(time.Duration(waitTime) * time.Millisecond)
+ continue
+ }
}
- if i == f.Config.MaxRetry {
- // TODO: What we can do when connection failed MaxRetry times?
- panic("fluent#reconnect: failed to reconnect!")
- }
- waitTime := f.Config.RetryWait * e(defaultReconnectWaitIncreRate, float64(i-1))
- time.Sleep(time.Duration(waitTime) * time.Millisecond)
- }
-}
+ f.muconn.Unlock()
-func (f *Fluent) send() error {
- f.muconn.Lock()
- defer f.muconn.Unlock()
-
- if f.conn == nil {
- if f.reconnecting == false {
- f.reconnecting = true
- go f.reconnect()
- }
- return errors.New("fluent#send: can't send logs, client is reconnecting")
- }
-
- f.mubuff.Lock()
- defer f.mubuff.Unlock()
-
- var err error
- if len(f.pending) > 0 {
+ // We're connected, write msg
t := f.Config.WriteTimeout
if time.Duration(0) < t {
f.conn.SetWriteDeadline(time.Now().Add(t))
} else {
f.conn.SetWriteDeadline(time.Time{})
}
- _, err = f.conn.Write(f.pending)
+ _, err := f.conn.Write(msg.data)
if err != nil {
- f.conn.Close()
- f.conn = nil
+ f.close()
} else {
- f.pending = f.pending[:0]
+ // Acknowledgment check
+ if msg.ack != "" {
+ resp := &AckResp{}
+ if f.Config.MarshalAsJSON {
+ dec := json.NewDecoder(f.conn)
+ err = dec.Decode(resp)
+ } else {
+ r := msgp.NewReader(f.conn)
+ err = resp.DecodeMsg(r)
+ }
+ if err != nil || resp.Ack != msg.ack {
+ f.close()
+ continue
+ }
+ }
+ return err
}
}
- return err
+
+ return fmt.Errorf("fluent#write: failed to reconnect, max retry: %v", f.Config.MaxRetry)
}
diff --git a/vendor/github.com/fluent/fluent-logger-golang/fluent/proto.go b/vendor/github.com/fluent/fluent-logger-golang/fluent/proto.go
index 158e22d..76fc860 100644
--- a/vendor/github.com/fluent/fluent-logger-golang/fluent/proto.go
+++ b/vendor/github.com/fluent/fluent-logger-golang/fluent/proto.go
@@ -16,9 +16,9 @@
//msgp:tuple Forward
type Forward struct {
- Tag string `msg:"tag"`
- Entries []Entry `msg:"entries"`
- Option interface{} `msg:"option"`
+ Tag string `msg:"tag"`
+ Entries []Entry `msg:"entries"`
+ Option map[string]string
}
//msgp:tuple Message
@@ -26,7 +26,7 @@
Tag string `msg:"tag"`
Time int64 `msg:"time"`
Record interface{} `msg:"record"`
- Option interface{} `msg:"option"`
+ Option map[string]string
}
//msgp:tuple MessageExt
@@ -34,7 +34,11 @@
Tag string `msg:"tag"`
Time EventTime `msg:"time,extension"`
Record interface{} `msg:"record"`
- Option interface{} `msg:"option"`
+ Option map[string]string
+}
+
+type AckResp struct {
+ Ack string `json:"ack" msg:"ack"`
}
// EventTime is an extension to the serialized time value. It builds in support
diff --git a/vendor/github.com/fluent/fluent-logger-golang/fluent/proto_gen.go b/vendor/github.com/fluent/fluent-logger-golang/fluent/proto_gen.go
index 5b88a68..e808880 100644
--- a/vendor/github.com/fluent/fluent-logger-golang/fluent/proto_gen.go
+++ b/vendor/github.com/fluent/fluent-logger-golang/fluent/proto_gen.go
@@ -1,30 +1,134 @@
package fluent
-// NOTE: THIS FILE WAS PRODUCED BY THE
-// MSGP CODE GENERATION TOOL (github.com/tinylib/msgp)
-// DO NOT EDIT
+// Code generated by github.com/tinylib/msgp DO NOT EDIT.
import (
"github.com/tinylib/msgp/msgp"
)
// DecodeMsg implements msgp.Decodable
-func (z *Entry) DecodeMsg(dc *msgp.Reader) (err error) {
- var zxvk uint32
- zxvk, err = dc.ReadArrayHeader()
+func (z *AckResp) DecodeMsg(dc *msgp.Reader) (err error) {
+ var field []byte
+ _ = field
+ var zb0001 uint32
+ zb0001, err = dc.ReadMapHeader()
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ for zb0001 > 0 {
+ zb0001--
+ field, err = dc.ReadMapKeyPtr()
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ switch msgp.UnsafeString(field) {
+ case "ack":
+ z.Ack, err = dc.ReadString()
+ if err != nil {
+ err = msgp.WrapError(err, "Ack")
+ return
+ }
+ default:
+ err = dc.Skip()
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ }
+ }
+ return
+}
+
+// EncodeMsg implements msgp.Encodable
+func (z AckResp) EncodeMsg(en *msgp.Writer) (err error) {
+ // map header, size 1
+ // write "ack"
+ err = en.Append(0x81, 0xa3, 0x61, 0x63, 0x6b)
if err != nil {
return
}
- if zxvk != 2 {
- err = msgp.ArrayError{Wanted: 2, Got: zxvk}
+ err = en.WriteString(z.Ack)
+ if err != nil {
+ err = msgp.WrapError(err, "Ack")
+ return
+ }
+ return
+}
+
+// MarshalMsg implements msgp.Marshaler
+func (z AckResp) MarshalMsg(b []byte) (o []byte, err error) {
+ o = msgp.Require(b, z.Msgsize())
+ // map header, size 1
+ // string "ack"
+ o = append(o, 0x81, 0xa3, 0x61, 0x63, 0x6b)
+ o = msgp.AppendString(o, z.Ack)
+ return
+}
+
+// UnmarshalMsg implements msgp.Unmarshaler
+func (z *AckResp) UnmarshalMsg(bts []byte) (o []byte, err error) {
+ var field []byte
+ _ = field
+ var zb0001 uint32
+ zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ for zb0001 > 0 {
+ zb0001--
+ field, bts, err = msgp.ReadMapKeyZC(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ switch msgp.UnsafeString(field) {
+ case "ack":
+ z.Ack, bts, err = msgp.ReadStringBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Ack")
+ return
+ }
+ default:
+ bts, err = msgp.Skip(bts)
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ }
+ }
+ o = bts
+ return
+}
+
+// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
+func (z AckResp) Msgsize() (s int) {
+ s = 1 + 4 + msgp.StringPrefixSize + len(z.Ack)
+ return
+}
+
+// DecodeMsg implements msgp.Decodable
+func (z *Entry) DecodeMsg(dc *msgp.Reader) (err error) {
+ var zb0001 uint32
+ zb0001, err = dc.ReadArrayHeader()
+ if err != nil {
+ err = msgp.WrapError(err)
+ return
+ }
+ if zb0001 != 2 {
+ err = msgp.ArrayError{Wanted: 2, Got: zb0001}
return
}
z.Time, err = dc.ReadInt64()
if err != nil {
+ err = msgp.WrapError(err, "Time")
return
}
z.Record, err = dc.ReadIntf()
if err != nil {
+ err = msgp.WrapError(err, "Record")
return
}
return
@@ -35,14 +139,16 @@
// array header, size 2
err = en.Append(0x92)
if err != nil {
- return err
+ return
}
err = en.WriteInt64(z.Time)
if err != nil {
+ err = msgp.WrapError(err, "Time")
return
}
err = en.WriteIntf(z.Record)
if err != nil {
+ err = msgp.WrapError(err, "Record")
return
}
return
@@ -56,6 +162,7 @@
o = msgp.AppendInt64(o, z.Time)
o, err = msgp.AppendIntf(o, z.Record)
if err != nil {
+ err = msgp.WrapError(err, "Record")
return
}
return
@@ -63,21 +170,24 @@
// UnmarshalMsg implements msgp.Unmarshaler
func (z *Entry) UnmarshalMsg(bts []byte) (o []byte, err error) {
- var zbzg uint32
- zbzg, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0001 uint32
+ zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
+ err = msgp.WrapError(err)
return
}
- if zbzg != 2 {
- err = msgp.ArrayError{Wanted: 2, Got: zbzg}
+ if zb0001 != 2 {
+ err = msgp.ArrayError{Wanted: 2, Got: zb0001}
return
}
z.Time, bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
+ err = msgp.WrapError(err, "Time")
return
}
z.Record, bts, err = msgp.ReadIntfBytes(bts)
if err != nil {
+ err = msgp.WrapError(err, "Record")
return
}
o = bts
@@ -92,52 +202,83 @@
// DecodeMsg implements msgp.Decodable
func (z *Forward) DecodeMsg(dc *msgp.Reader) (err error) {
- var zcmr uint32
- zcmr, err = dc.ReadArrayHeader()
+ var zb0001 uint32
+ zb0001, err = dc.ReadArrayHeader()
if err != nil {
+ err = msgp.WrapError(err)
return
}
- if zcmr != 3 {
- err = msgp.ArrayError{Wanted: 3, Got: zcmr}
+ if zb0001 != 3 {
+ err = msgp.ArrayError{Wanted: 3, Got: zb0001}
return
}
z.Tag, err = dc.ReadString()
if err != nil {
+ err = msgp.WrapError(err, "Tag")
return
}
- var zajw uint32
- zajw, err = dc.ReadArrayHeader()
+ var zb0002 uint32
+ zb0002, err = dc.ReadArrayHeader()
if err != nil {
+ err = msgp.WrapError(err, "Entries")
return
}
- if cap(z.Entries) >= int(zajw) {
- z.Entries = (z.Entries)[:zajw]
+ if cap(z.Entries) >= int(zb0002) {
+ z.Entries = (z.Entries)[:zb0002]
} else {
- z.Entries = make([]Entry, zajw)
+ z.Entries = make([]Entry, zb0002)
}
- for zbai := range z.Entries {
- var zwht uint32
- zwht, err = dc.ReadArrayHeader()
+ for za0001 := range z.Entries {
+ var zb0003 uint32
+ zb0003, err = dc.ReadArrayHeader()
if err != nil {
+ err = msgp.WrapError(err, "Entries", za0001)
return
}
- if zwht != 2 {
- err = msgp.ArrayError{Wanted: 2, Got: zwht}
+ if zb0003 != 2 {
+ err = msgp.ArrayError{Wanted: 2, Got: zb0003}
return
}
- z.Entries[zbai].Time, err = dc.ReadInt64()
+ z.Entries[za0001].Time, err = dc.ReadInt64()
if err != nil {
+ err = msgp.WrapError(err, "Entries", za0001, "Time")
return
}
- z.Entries[zbai].Record, err = dc.ReadIntf()
+ z.Entries[za0001].Record, err = dc.ReadIntf()
if err != nil {
+ err = msgp.WrapError(err, "Entries", za0001, "Record")
return
}
}
- z.Option, err = dc.ReadIntf()
+ var zb0004 uint32
+ zb0004, err = dc.ReadMapHeader()
if err != nil {
+ err = msgp.WrapError(err, "Option")
return
}
+ if z.Option == nil {
+ z.Option = make(map[string]string, zb0004)
+ } else if len(z.Option) > 0 {
+ for key := range z.Option {
+ delete(z.Option, key)
+ }
+ }
+ for zb0004 > 0 {
+ zb0004--
+ var za0002 string
+ var za0003 string
+ za0002, err = dc.ReadString()
+ if err != nil {
+ err = msgp.WrapError(err, "Option")
+ return
+ }
+ za0003, err = dc.ReadString()
+ if err != nil {
+ err = msgp.WrapError(err, "Option", za0002)
+ return
+ }
+ z.Option[za0002] = za0003
+ }
return
}
@@ -146,35 +287,52 @@
// array header, size 3
err = en.Append(0x93)
if err != nil {
- return err
+ return
}
err = en.WriteString(z.Tag)
if err != nil {
+ err = msgp.WrapError(err, "Tag")
return
}
err = en.WriteArrayHeader(uint32(len(z.Entries)))
if err != nil {
+ err = msgp.WrapError(err, "Entries")
return
}
- for zbai := range z.Entries {
+ for za0001 := range z.Entries {
// array header, size 2
err = en.Append(0x92)
if err != nil {
- return err
- }
- err = en.WriteInt64(z.Entries[zbai].Time)
- if err != nil {
return
}
- err = en.WriteIntf(z.Entries[zbai].Record)
+ err = en.WriteInt64(z.Entries[za0001].Time)
if err != nil {
+ err = msgp.WrapError(err, "Entries", za0001, "Time")
+ return
+ }
+ err = en.WriteIntf(z.Entries[za0001].Record)
+ if err != nil {
+ err = msgp.WrapError(err, "Entries", za0001, "Record")
return
}
}
- err = en.WriteIntf(z.Option)
+ err = en.WriteMapHeader(uint32(len(z.Option)))
if err != nil {
+ err = msgp.WrapError(err, "Option")
return
}
+ for za0002, za0003 := range z.Option {
+ err = en.WriteString(za0002)
+ if err != nil {
+ err = msgp.WrapError(err, "Option")
+ return
+ }
+ err = en.WriteString(za0003)
+ if err != nil {
+ err = msgp.WrapError(err, "Option", za0002)
+ return
+ }
+ }
return
}
@@ -185,70 +343,103 @@
o = append(o, 0x93)
o = msgp.AppendString(o, z.Tag)
o = msgp.AppendArrayHeader(o, uint32(len(z.Entries)))
- for zbai := range z.Entries {
+ for za0001 := range z.Entries {
// array header, size 2
o = append(o, 0x92)
- o = msgp.AppendInt64(o, z.Entries[zbai].Time)
- o, err = msgp.AppendIntf(o, z.Entries[zbai].Record)
+ o = msgp.AppendInt64(o, z.Entries[za0001].Time)
+ o, err = msgp.AppendIntf(o, z.Entries[za0001].Record)
if err != nil {
+ err = msgp.WrapError(err, "Entries", za0001, "Record")
return
}
}
- o, err = msgp.AppendIntf(o, z.Option)
- if err != nil {
- return
+ o = msgp.AppendMapHeader(o, uint32(len(z.Option)))
+ for za0002, za0003 := range z.Option {
+ o = msgp.AppendString(o, za0002)
+ o = msgp.AppendString(o, za0003)
}
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *Forward) UnmarshalMsg(bts []byte) (o []byte, err error) {
- var zhct uint32
- zhct, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0001 uint32
+ zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
+ err = msgp.WrapError(err)
return
}
- if zhct != 3 {
- err = msgp.ArrayError{Wanted: 3, Got: zhct}
+ if zb0001 != 3 {
+ err = msgp.ArrayError{Wanted: 3, Got: zb0001}
return
}
z.Tag, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
+ err = msgp.WrapError(err, "Tag")
return
}
- var zcua uint32
- zcua, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0002 uint32
+ zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
+ err = msgp.WrapError(err, "Entries")
return
}
- if cap(z.Entries) >= int(zcua) {
- z.Entries = (z.Entries)[:zcua]
+ if cap(z.Entries) >= int(zb0002) {
+ z.Entries = (z.Entries)[:zb0002]
} else {
- z.Entries = make([]Entry, zcua)
+ z.Entries = make([]Entry, zb0002)
}
- for zbai := range z.Entries {
- var zxhx uint32
- zxhx, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ for za0001 := range z.Entries {
+ var zb0003 uint32
+ zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
+ err = msgp.WrapError(err, "Entries", za0001)
return
}
- if zxhx != 2 {
- err = msgp.ArrayError{Wanted: 2, Got: zxhx}
+ if zb0003 != 2 {
+ err = msgp.ArrayError{Wanted: 2, Got: zb0003}
return
}
- z.Entries[zbai].Time, bts, err = msgp.ReadInt64Bytes(bts)
+ z.Entries[za0001].Time, bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
+ err = msgp.WrapError(err, "Entries", za0001, "Time")
return
}
- z.Entries[zbai].Record, bts, err = msgp.ReadIntfBytes(bts)
+ z.Entries[za0001].Record, bts, err = msgp.ReadIntfBytes(bts)
if err != nil {
+ err = msgp.WrapError(err, "Entries", za0001, "Record")
return
}
}
- z.Option, bts, err = msgp.ReadIntfBytes(bts)
+ var zb0004 uint32
+ zb0004, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
+ err = msgp.WrapError(err, "Option")
return
}
+ if z.Option == nil {
+ z.Option = make(map[string]string, zb0004)
+ } else if len(z.Option) > 0 {
+ for key := range z.Option {
+ delete(z.Option, key)
+ }
+ }
+ for zb0004 > 0 {
+ var za0002 string
+ var za0003 string
+ zb0004--
+ za0002, bts, err = msgp.ReadStringBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Option")
+ return
+ }
+ za0003, bts, err = msgp.ReadStringBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Option", za0002)
+ return
+ }
+ z.Option[za0002] = za0003
+ }
o = bts
return
}
@@ -256,40 +447,75 @@
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *Forward) Msgsize() (s int) {
s = 1 + msgp.StringPrefixSize + len(z.Tag) + msgp.ArrayHeaderSize
- for zbai := range z.Entries {
- s += 1 + msgp.Int64Size + msgp.GuessSize(z.Entries[zbai].Record)
+ for za0001 := range z.Entries {
+ s += 1 + msgp.Int64Size + msgp.GuessSize(z.Entries[za0001].Record)
}
- s += msgp.GuessSize(z.Option)
+ s += msgp.MapHeaderSize
+ if z.Option != nil {
+ for za0002, za0003 := range z.Option {
+ _ = za0003
+ s += msgp.StringPrefixSize + len(za0002) + msgp.StringPrefixSize + len(za0003)
+ }
+ }
return
}
// DecodeMsg implements msgp.Decodable
func (z *Message) DecodeMsg(dc *msgp.Reader) (err error) {
- var zlqf uint32
- zlqf, err = dc.ReadArrayHeader()
+ var zb0001 uint32
+ zb0001, err = dc.ReadArrayHeader()
if err != nil {
+ err = msgp.WrapError(err)
return
}
- if zlqf != 4 {
- err = msgp.ArrayError{Wanted: 4, Got: zlqf}
+ if zb0001 != 4 {
+ err = msgp.ArrayError{Wanted: 4, Got: zb0001}
return
}
z.Tag, err = dc.ReadString()
if err != nil {
+ err = msgp.WrapError(err, "Tag")
return
}
z.Time, err = dc.ReadInt64()
if err != nil {
+ err = msgp.WrapError(err, "Time")
return
}
z.Record, err = dc.ReadIntf()
if err != nil {
+ err = msgp.WrapError(err, "Record")
return
}
- z.Option, err = dc.ReadIntf()
+ var zb0002 uint32
+ zb0002, err = dc.ReadMapHeader()
if err != nil {
+ err = msgp.WrapError(err, "Option")
return
}
+ if z.Option == nil {
+ z.Option = make(map[string]string, zb0002)
+ } else if len(z.Option) > 0 {
+ for key := range z.Option {
+ delete(z.Option, key)
+ }
+ }
+ for zb0002 > 0 {
+ zb0002--
+ var za0001 string
+ var za0002 string
+ za0001, err = dc.ReadString()
+ if err != nil {
+ err = msgp.WrapError(err, "Option")
+ return
+ }
+ za0002, err = dc.ReadString()
+ if err != nil {
+ err = msgp.WrapError(err, "Option", za0001)
+ return
+ }
+ z.Option[za0001] = za0002
+ }
return
}
@@ -298,24 +524,40 @@
// array header, size 4
err = en.Append(0x94)
if err != nil {
- return err
+ return
}
err = en.WriteString(z.Tag)
if err != nil {
+ err = msgp.WrapError(err, "Tag")
return
}
err = en.WriteInt64(z.Time)
if err != nil {
+ err = msgp.WrapError(err, "Time")
return
}
err = en.WriteIntf(z.Record)
if err != nil {
+ err = msgp.WrapError(err, "Record")
return
}
- err = en.WriteIntf(z.Option)
+ err = en.WriteMapHeader(uint32(len(z.Option)))
if err != nil {
+ err = msgp.WrapError(err, "Option")
return
}
+ for za0001, za0002 := range z.Option {
+ err = en.WriteString(za0001)
+ if err != nil {
+ err = msgp.WrapError(err, "Option")
+ return
+ }
+ err = en.WriteString(za0002)
+ if err != nil {
+ err = msgp.WrapError(err, "Option", za0001)
+ return
+ }
+ }
return
}
@@ -328,79 +570,145 @@
o = msgp.AppendInt64(o, z.Time)
o, err = msgp.AppendIntf(o, z.Record)
if err != nil {
+ err = msgp.WrapError(err, "Record")
return
}
- o, err = msgp.AppendIntf(o, z.Option)
- if err != nil {
- return
+ o = msgp.AppendMapHeader(o, uint32(len(z.Option)))
+ for za0001, za0002 := range z.Option {
+ o = msgp.AppendString(o, za0001)
+ o = msgp.AppendString(o, za0002)
}
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *Message) UnmarshalMsg(bts []byte) (o []byte, err error) {
- var zdaf uint32
- zdaf, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0001 uint32
+ zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
+ err = msgp.WrapError(err)
return
}
- if zdaf != 4 {
- err = msgp.ArrayError{Wanted: 4, Got: zdaf}
+ if zb0001 != 4 {
+ err = msgp.ArrayError{Wanted: 4, Got: zb0001}
return
}
z.Tag, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
+ err = msgp.WrapError(err, "Tag")
return
}
z.Time, bts, err = msgp.ReadInt64Bytes(bts)
if err != nil {
+ err = msgp.WrapError(err, "Time")
return
}
z.Record, bts, err = msgp.ReadIntfBytes(bts)
if err != nil {
+ err = msgp.WrapError(err, "Record")
return
}
- z.Option, bts, err = msgp.ReadIntfBytes(bts)
+ var zb0002 uint32
+ zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
+ err = msgp.WrapError(err, "Option")
return
}
+ if z.Option == nil {
+ z.Option = make(map[string]string, zb0002)
+ } else if len(z.Option) > 0 {
+ for key := range z.Option {
+ delete(z.Option, key)
+ }
+ }
+ for zb0002 > 0 {
+ var za0001 string
+ var za0002 string
+ zb0002--
+ za0001, bts, err = msgp.ReadStringBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Option")
+ return
+ }
+ za0002, bts, err = msgp.ReadStringBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Option", za0001)
+ return
+ }
+ z.Option[za0001] = za0002
+ }
o = bts
return
}
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *Message) Msgsize() (s int) {
- s = 1 + msgp.StringPrefixSize + len(z.Tag) + msgp.Int64Size + msgp.GuessSize(z.Record) + msgp.GuessSize(z.Option)
+ s = 1 + msgp.StringPrefixSize + len(z.Tag) + msgp.Int64Size + msgp.GuessSize(z.Record) + msgp.MapHeaderSize
+ if z.Option != nil {
+ for za0001, za0002 := range z.Option {
+ _ = za0002
+ s += msgp.StringPrefixSize + len(za0001) + msgp.StringPrefixSize + len(za0002)
+ }
+ }
return
}
// DecodeMsg implements msgp.Decodable
func (z *MessageExt) DecodeMsg(dc *msgp.Reader) (err error) {
- var zpks uint32
- zpks, err = dc.ReadArrayHeader()
+ var zb0001 uint32
+ zb0001, err = dc.ReadArrayHeader()
if err != nil {
+ err = msgp.WrapError(err)
return
}
- if zpks != 4 {
- err = msgp.ArrayError{Wanted: 4, Got: zpks}
+ if zb0001 != 4 {
+ err = msgp.ArrayError{Wanted: 4, Got: zb0001}
return
}
z.Tag, err = dc.ReadString()
if err != nil {
+ err = msgp.WrapError(err, "Tag")
return
}
err = dc.ReadExtension(&z.Time)
if err != nil {
+ err = msgp.WrapError(err, "Time")
return
}
z.Record, err = dc.ReadIntf()
if err != nil {
+ err = msgp.WrapError(err, "Record")
return
}
- z.Option, err = dc.ReadIntf()
+ var zb0002 uint32
+ zb0002, err = dc.ReadMapHeader()
if err != nil {
+ err = msgp.WrapError(err, "Option")
return
}
+ if z.Option == nil {
+ z.Option = make(map[string]string, zb0002)
+ } else if len(z.Option) > 0 {
+ for key := range z.Option {
+ delete(z.Option, key)
+ }
+ }
+ for zb0002 > 0 {
+ zb0002--
+ var za0001 string
+ var za0002 string
+ za0001, err = dc.ReadString()
+ if err != nil {
+ err = msgp.WrapError(err, "Option")
+ return
+ }
+ za0002, err = dc.ReadString()
+ if err != nil {
+ err = msgp.WrapError(err, "Option", za0001)
+ return
+ }
+ z.Option[za0001] = za0002
+ }
return
}
@@ -409,24 +717,40 @@
// array header, size 4
err = en.Append(0x94)
if err != nil {
- return err
+ return
}
err = en.WriteString(z.Tag)
if err != nil {
+ err = msgp.WrapError(err, "Tag")
return
}
err = en.WriteExtension(&z.Time)
if err != nil {
+ err = msgp.WrapError(err, "Time")
return
}
err = en.WriteIntf(z.Record)
if err != nil {
+ err = msgp.WrapError(err, "Record")
return
}
- err = en.WriteIntf(z.Option)
+ err = en.WriteMapHeader(uint32(len(z.Option)))
if err != nil {
+ err = msgp.WrapError(err, "Option")
return
}
+ for za0001, za0002 := range z.Option {
+ err = en.WriteString(za0001)
+ if err != nil {
+ err = msgp.WrapError(err, "Option")
+ return
+ }
+ err = en.WriteString(za0002)
+ if err != nil {
+ err = msgp.WrapError(err, "Option", za0001)
+ return
+ }
+ }
return
}
@@ -438,52 +762,90 @@
o = msgp.AppendString(o, z.Tag)
o, err = msgp.AppendExtension(o, &z.Time)
if err != nil {
+ err = msgp.WrapError(err, "Time")
return
}
o, err = msgp.AppendIntf(o, z.Record)
if err != nil {
+ err = msgp.WrapError(err, "Record")
return
}
- o, err = msgp.AppendIntf(o, z.Option)
- if err != nil {
- return
+ o = msgp.AppendMapHeader(o, uint32(len(z.Option)))
+ for za0001, za0002 := range z.Option {
+ o = msgp.AppendString(o, za0001)
+ o = msgp.AppendString(o, za0002)
}
return
}
// UnmarshalMsg implements msgp.Unmarshaler
func (z *MessageExt) UnmarshalMsg(bts []byte) (o []byte, err error) {
- var zjfb uint32
- zjfb, bts, err = msgp.ReadArrayHeaderBytes(bts)
+ var zb0001 uint32
+ zb0001, bts, err = msgp.ReadArrayHeaderBytes(bts)
if err != nil {
+ err = msgp.WrapError(err)
return
}
- if zjfb != 4 {
- err = msgp.ArrayError{Wanted: 4, Got: zjfb}
+ if zb0001 != 4 {
+ err = msgp.ArrayError{Wanted: 4, Got: zb0001}
return
}
z.Tag, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
+ err = msgp.WrapError(err, "Tag")
return
}
bts, err = msgp.ReadExtensionBytes(bts, &z.Time)
if err != nil {
+ err = msgp.WrapError(err, "Time")
return
}
z.Record, bts, err = msgp.ReadIntfBytes(bts)
if err != nil {
+ err = msgp.WrapError(err, "Record")
return
}
- z.Option, bts, err = msgp.ReadIntfBytes(bts)
+ var zb0002 uint32
+ zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
+ err = msgp.WrapError(err, "Option")
return
}
+ if z.Option == nil {
+ z.Option = make(map[string]string, zb0002)
+ } else if len(z.Option) > 0 {
+ for key := range z.Option {
+ delete(z.Option, key)
+ }
+ }
+ for zb0002 > 0 {
+ var za0001 string
+ var za0002 string
+ zb0002--
+ za0001, bts, err = msgp.ReadStringBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Option")
+ return
+ }
+ za0002, bts, err = msgp.ReadStringBytes(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Option", za0001)
+ return
+ }
+ z.Option[za0001] = za0002
+ }
o = bts
return
}
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *MessageExt) Msgsize() (s int) {
- s = 1 + msgp.StringPrefixSize + len(z.Tag) + msgp.ExtensionPrefixSize + z.Time.Len() + msgp.GuessSize(z.Record) + msgp.GuessSize(z.Option)
+ s = 1 + msgp.StringPrefixSize + len(z.Tag) + msgp.ExtensionPrefixSize + z.Time.Len() + msgp.GuessSize(z.Record) + msgp.MapHeaderSize
+ if z.Option != nil {
+ for za0001, za0002 := range z.Option {
+ _ = za0002
+ s += msgp.StringPrefixSize + len(za0001) + msgp.StringPrefixSize + len(za0002)
+ }
+ }
return
}
diff --git a/vendor/github.com/fluent/fluent-logger-golang/fluent/test_message_gen.go b/vendor/github.com/fluent/fluent-logger-golang/fluent/test_message_gen.go
index 17a45e2..591e1a9 100644
--- a/vendor/github.com/fluent/fluent-logger-golang/fluent/test_message_gen.go
+++ b/vendor/github.com/fluent/fluent-logger-golang/fluent/test_message_gen.go
@@ -1,8 +1,6 @@
package fluent
-// NOTE: THIS FILE WAS PRODUCED BY THE
-// MSGP CODE GENERATION TOOL (github.com/tinylib/msgp)
-// DO NOT EDIT
+// Code generated by github.com/tinylib/msgp DO NOT EDIT.
import (
"github.com/tinylib/msgp/msgp"
@@ -12,31 +10,36 @@
func (z *TestMessage) DecodeMsg(dc *msgp.Reader) (err error) {
var field []byte
_ = field
- var zxvk uint32
- zxvk, err = dc.ReadMapHeader()
+ var zb0001 uint32
+ zb0001, err = dc.ReadMapHeader()
if err != nil {
+ err = msgp.WrapError(err)
return
}
- for zxvk > 0 {
- zxvk--
+ for zb0001 > 0 {
+ zb0001--
field, err = dc.ReadMapKeyPtr()
if err != nil {
+ err = msgp.WrapError(err)
return
}
switch msgp.UnsafeString(field) {
case "foo":
z.Foo, err = dc.ReadString()
if err != nil {
+ err = msgp.WrapError(err, "Foo")
return
}
case "hoge":
z.Hoge, err = dc.ReadString()
if err != nil {
+ err = msgp.WrapError(err, "Hoge")
return
}
default:
err = dc.Skip()
if err != nil {
+ err = msgp.WrapError(err)
return
}
}
@@ -50,19 +53,21 @@
// write "foo"
err = en.Append(0x82, 0xa3, 0x66, 0x6f, 0x6f)
if err != nil {
- return err
+ return
}
err = en.WriteString(z.Foo)
if err != nil {
+ err = msgp.WrapError(err, "Foo")
return
}
// write "hoge"
err = en.Append(0xa4, 0x68, 0x6f, 0x67, 0x65)
if err != nil {
- return err
+ return
}
err = en.WriteString(z.Hoge)
if err != nil {
+ err = msgp.WrapError(err, "Hoge")
return
}
return
@@ -85,31 +90,36 @@
func (z *TestMessage) UnmarshalMsg(bts []byte) (o []byte, err error) {
var field []byte
_ = field
- var zbzg uint32
- zbzg, bts, err = msgp.ReadMapHeaderBytes(bts)
+ var zb0001 uint32
+ zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
if err != nil {
+ err = msgp.WrapError(err)
return
}
- for zbzg > 0 {
- zbzg--
+ for zb0001 > 0 {
+ zb0001--
field, bts, err = msgp.ReadMapKeyZC(bts)
if err != nil {
+ err = msgp.WrapError(err)
return
}
switch msgp.UnsafeString(field) {
case "foo":
z.Foo, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
+ err = msgp.WrapError(err, "Foo")
return
}
case "hoge":
z.Hoge, bts, err = msgp.ReadStringBytes(bts)
if err != nil {
+ err = msgp.WrapError(err, "Hoge")
return
}
default:
bts, err = msgp.Skip(bts)
if err != nil {
+ err = msgp.WrapError(err)
return
}
}
diff --git a/vendor/github.com/fluent/fluent-logger-golang/fluent/version.go b/vendor/github.com/fluent/fluent-logger-golang/fluent/version.go
index c6ec7e4..83e8932 100644
--- a/vendor/github.com/fluent/fluent-logger-golang/fluent/version.go
+++ b/vendor/github.com/fluent/fluent-logger-golang/fluent/version.go
@@ -1,3 +1,3 @@
package fluent
-const Version = "1.3.0"
+const Version = "1.4.0"
diff --git a/vendor/github.com/pivotal-golang/clock/README.md b/vendor/github.com/pivotal-golang/clock/README.md
deleted file mode 100644
index 9741b8b..0000000
--- a/vendor/github.com/pivotal-golang/clock/README.md
+++ /dev/null
@@ -1 +0,0 @@
-Provides a `Clock` interface, useful for injecting time dependencies in tests.
diff --git a/vendor/github.com/pivotal-golang/clock/clock.go b/vendor/github.com/pivotal-golang/clock/clock.go
deleted file mode 100644
index 9c7322c..0000000
--- a/vendor/github.com/pivotal-golang/clock/clock.go
+++ /dev/null
@@ -1,42 +0,0 @@
-package clock
-
-import "time"
-
-type Clock interface {
- Now() time.Time
- Sleep(d time.Duration)
- Since(t time.Time) time.Duration
-
- NewTimer(d time.Duration) Timer
- NewTicker(d time.Duration) Ticker
-}
-
-type realClock struct{}
-
-func NewClock() Clock {
- return &realClock{}
-}
-
-func (clock *realClock) Now() time.Time {
- return time.Now()
-}
-
-func (clock *realClock) Since(t time.Time) time.Duration {
- return time.Now().Sub(t)
-}
-
-func (clock *realClock) Sleep(d time.Duration) {
- <-clock.NewTimer(d).C()
-}
-
-func (clock *realClock) NewTimer(d time.Duration) Timer {
- return &realTimer{
- t: time.NewTimer(d),
- }
-}
-
-func (clock *realClock) NewTicker(d time.Duration) Ticker {
- return &realTicker{
- t: time.NewTicker(d),
- }
-}
diff --git a/vendor/github.com/pkg/errors/README.md b/vendor/github.com/pkg/errors/README.md
index 273db3c..6483ba2 100644
--- a/vendor/github.com/pkg/errors/README.md
+++ b/vendor/github.com/pkg/errors/README.md
@@ -1,4 +1,4 @@
-# errors [](https://travis-ci.org/pkg/errors) [](https://ci.appveyor.com/project/davecheney/errors/branch/master) [](http://godoc.org/github.com/pkg/errors) [](https://goreportcard.com/report/github.com/pkg/errors)
+# errors [](https://travis-ci.org/pkg/errors) [](https://ci.appveyor.com/project/davecheney/errors/branch/master) [](http://godoc.org/github.com/pkg/errors) [](https://goreportcard.com/report/github.com/pkg/errors) [](https://sourcegraph.com/github.com/pkg/errors?badge)
Package errors provides simple error handling primitives.
@@ -47,6 +47,6 @@
Before proposing a change, please discuss your change by raising an issue.
-## Licence
+## License
BSD-2-Clause
diff --git a/vendor/github.com/pkg/errors/errors.go b/vendor/github.com/pkg/errors/errors.go
index 842ee80..7421f32 100644
--- a/vendor/github.com/pkg/errors/errors.go
+++ b/vendor/github.com/pkg/errors/errors.go
@@ -6,7 +6,7 @@
// return err
// }
//
-// which applied recursively up the call stack results in error reports
+// which when applied recursively up the call stack results in error reports
// without context or debugging information. The errors package allows
// programmers to add context to the failure path in their code in a way
// that does not destroy the original value of the error.
@@ -15,16 +15,17 @@
//
// The errors.Wrap function returns a new error that adds context to the
// original error by recording a stack trace at the point Wrap is called,
-// and the supplied message. For example
+// together with the supplied message. For example
//
// _, err := ioutil.ReadAll(r)
// if err != nil {
// return errors.Wrap(err, "read failed")
// }
//
-// If additional control is required the errors.WithStack and errors.WithMessage
-// functions destructure errors.Wrap into its component operations of annotating
-// an error with a stack trace and an a message, respectively.
+// If additional control is required, the errors.WithStack and
+// errors.WithMessage functions destructure errors.Wrap into its component
+// operations: annotating an error with a stack trace and with a message,
+// respectively.
//
// Retrieving the cause of an error
//
@@ -38,7 +39,7 @@
// }
//
// can be inspected by errors.Cause. errors.Cause will recursively retrieve
-// the topmost error which does not implement causer, which is assumed to be
+// the topmost error that does not implement causer, which is assumed to be
// the original cause. For example:
//
// switch err := errors.Cause(err).(type) {
@@ -48,16 +49,16 @@
// // unknown error
// }
//
-// causer interface is not exported by this package, but is considered a part
-// of stable public API.
+// Although the causer interface is not exported by this package, it is
+// considered a part of its stable public interface.
//
// Formatted printing of errors
//
// All error values returned from this package implement fmt.Formatter and can
-// be formatted by the fmt package. The following verbs are supported
+// be formatted by the fmt package. The following verbs are supported:
//
// %s print the error. If the error has a Cause it will be
-// printed recursively
+// printed recursively.
// %v see %s
// %+v extended format. Each Frame of the error's StackTrace will
// be printed in detail.
@@ -65,13 +66,13 @@
// Retrieving the stack trace of an error or wrapper
//
// New, Errorf, Wrap, and Wrapf record a stack trace at the point they are
-// invoked. This information can be retrieved with the following interface.
+// invoked. This information can be retrieved with the following interface:
//
// type stackTracer interface {
// StackTrace() errors.StackTrace
// }
//
-// Where errors.StackTrace is defined as
+// The returned errors.StackTrace type is defined as
//
// type StackTrace []Frame
//
@@ -85,8 +86,8 @@
// }
// }
//
-// stackTracer interface is not exported by this package, but is considered a part
-// of stable public API.
+// Although the stackTracer interface is not exported by this package, it is
+// considered a part of its stable public interface.
//
// See the documentation for Frame.Format for more details.
package errors
@@ -192,7 +193,7 @@
}
// Wrapf returns an error annotating err with a stack trace
-// at the point Wrapf is call, and the format specifier.
+// at the point Wrapf is called, and the format specifier.
// If err is nil, Wrapf returns nil.
func Wrapf(err error, format string, args ...interface{}) error {
if err == nil {
@@ -220,6 +221,18 @@
}
}
+// WithMessagef annotates err with the format specifier.
+// If err is nil, WithMessagef returns nil.
+func WithMessagef(err error, format string, args ...interface{}) error {
+ if err == nil {
+ return nil
+ }
+ return &withMessage{
+ cause: err,
+ msg: fmt.Sprintf(format, args...),
+ }
+}
+
type withMessage struct {
cause error
msg string
diff --git a/vendor/github.com/pkg/errors/stack.go b/vendor/github.com/pkg/errors/stack.go
index 6b1f289..2874a04 100644
--- a/vendor/github.com/pkg/errors/stack.go
+++ b/vendor/github.com/pkg/errors/stack.go
@@ -46,7 +46,8 @@
//
// Format accepts flags that alter the printing of some verbs, as follows:
//
-// %+s path of source file relative to the compile time GOPATH
+// %+s function name and path of source file relative to the compile time
+// GOPATH separated by \n\t (<funcname>\n\t<path>)
// %+v equivalent to %+s:%d
func (f Frame) Format(s fmt.State, verb rune) {
switch verb {
@@ -79,6 +80,14 @@
// StackTrace is stack of Frames from innermost (newest) to outermost (oldest).
type StackTrace []Frame
+// Format formats the stack of Frames according to the fmt.Formatter interface.
+//
+// %s lists source files for each Frame in the stack
+// %v lists the source file and line number for each Frame in the stack
+//
+// Format accepts flags that alter the printing of some verbs, as follows:
+//
+// %+v Prints filename, function, and line number for each Frame in the stack.
func (st StackTrace) Format(s fmt.State, verb rune) {
switch verb {
case 'v':
@@ -136,43 +145,3 @@
i = strings.Index(name, ".")
return name[i+1:]
}
-
-func trimGOPATH(name, file string) string {
- // Here we want to get the source file path relative to the compile time
- // GOPATH. As of Go 1.6.x there is no direct way to know the compiled
- // GOPATH at runtime, but we can infer the number of path segments in the
- // GOPATH. We note that fn.Name() returns the function name qualified by
- // the import path, which does not include the GOPATH. Thus we can trim
- // segments from the beginning of the file path until the number of path
- // separators remaining is one more than the number of path separators in
- // the function name. For example, given:
- //
- // GOPATH /home/user
- // file /home/user/src/pkg/sub/file.go
- // fn.Name() pkg/sub.Type.Method
- //
- // We want to produce:
- //
- // pkg/sub/file.go
- //
- // From this we can easily see that fn.Name() has one less path separator
- // than our desired output. We count separators from the end of the file
- // path until it finds two more than in the function name and then move
- // one character forward to preserve the initial path segment without a
- // leading separator.
- const sep = "/"
- goal := strings.Count(name, sep) + 2
- i := len(file)
- for n := 0; n < goal; n++ {
- i = strings.LastIndex(file[:i], sep)
- if i == -1 {
- // not enough separators found, set i so that the slice expression
- // below leaves file unmodified
- i = -len(sep)
- break
- }
- }
- // get back to 0 or trim the leading separator
- file = file[i+len(sep):]
- return file
-}
diff --git a/vendor/github.com/tinylib/msgp/msgp/edit.go b/vendor/github.com/tinylib/msgp/msgp/edit.go
index 41f9298..b473a6f 100644
--- a/vendor/github.com/tinylib/msgp/msgp/edit.go
+++ b/vendor/github.com/tinylib/msgp/msgp/edit.go
@@ -198,6 +198,7 @@
if cap(raw)-len(raw) >= 2 {
raw = raw[0 : len(raw)+2]
copy(raw[5:], raw[3:])
+ raw[0] = mmap32
big.PutUint32(raw[1:], uint32(sz+delta))
return raw
}
diff --git a/vendor/github.com/tinylib/msgp/msgp/errors.go b/vendor/github.com/tinylib/msgp/msgp/errors.go
index 5c24f27..cc78a98 100644
--- a/vendor/github.com/tinylib/msgp/msgp/errors.go
+++ b/vendor/github.com/tinylib/msgp/msgp/errors.go
@@ -5,6 +5,8 @@
"reflect"
)
+const resumableDefault = false
+
var (
// ErrShortBytes is returned when the
// slice being decoded is too short to
@@ -26,84 +28,240 @@
// Resumable returns whether
// or not the error means that
// the stream of data is malformed
- // and the information is unrecoverable.
+ // and the information is unrecoverable.
Resumable() bool
}
+// contextError allows msgp Error instances to be enhanced with additional
+// context about their origin.
+type contextError interface {
+ Error
+
+ // withContext must not modify the error instance - it must clone and
+ // return a new error with the context added.
+ withContext(ctx string) error
+}
+
+// Cause returns the underlying cause of an error that has been wrapped
+// with additional context.
+func Cause(e error) error {
+ out := e
+ if e, ok := e.(errWrapped); ok && e.cause != nil {
+ out = e.cause
+ }
+ return out
+}
+
+// Resumable returns whether or not the error means that the stream of data is
+// malformed and the information is unrecoverable.
+func Resumable(e error) bool {
+ if e, ok := e.(Error); ok {
+ return e.Resumable()
+ }
+ return resumableDefault
+}
+
+// WrapError wraps an error with additional context that allows the part of the
+// serialized type that caused the problem to be identified. Underlying errors
+// can be retrieved using Cause()
+//
+// The input error is not modified - a new error should be returned.
+//
+// ErrShortBytes is not wrapped with any context due to backward compatibility
+// issues with the public API.
+//
+func WrapError(err error, ctx ...interface{}) error {
+ switch e := err.(type) {
+ case errShort:
+ return e
+ case contextError:
+ return e.withContext(ctxString(ctx))
+ default:
+ return errWrapped{cause: err, ctx: ctxString(ctx)}
+ }
+}
+
+// ctxString converts the incoming interface{} slice into a single string.
+func ctxString(ctx []interface{}) string {
+ out := ""
+ for idx, cv := range ctx {
+ if idx > 0 {
+ out += "/"
+ }
+ out += fmt.Sprintf("%v", cv)
+ }
+ return out
+}
+
+func addCtx(ctx, add string) string {
+ if ctx != "" {
+ return add + "/" + ctx
+ } else {
+ return add
+ }
+}
+
+// errWrapped allows arbitrary errors passed to WrapError to be enhanced with
+// context and unwrapped with Cause()
+type errWrapped struct {
+ cause error
+ ctx string
+}
+
+func (e errWrapped) Error() string {
+ if e.ctx != "" {
+ return fmt.Sprintf("%s at %s", e.cause, e.ctx)
+ } else {
+ return e.cause.Error()
+ }
+}
+
+func (e errWrapped) Resumable() bool {
+ if e, ok := e.cause.(Error); ok {
+ return e.Resumable()
+ }
+ return resumableDefault
+}
+
type errShort struct{}
func (e errShort) Error() string { return "msgp: too few bytes left to read object" }
func (e errShort) Resumable() bool { return false }
-type errFatal struct{}
+type errFatal struct {
+ ctx string
+}
-func (f errFatal) Error() string { return "msgp: fatal decoding error (unreachable code)" }
+func (f errFatal) Error() string {
+ out := "msgp: fatal decoding error (unreachable code)"
+ if f.ctx != "" {
+ out += " at " + f.ctx
+ }
+ return out
+}
+
func (f errFatal) Resumable() bool { return false }
+func (f errFatal) withContext(ctx string) error { f.ctx = addCtx(f.ctx, ctx); return f }
+
// ArrayError is an error returned
// when decoding a fix-sized array
// of the wrong size
type ArrayError struct {
Wanted uint32
Got uint32
+ ctx string
}
// Error implements the error interface
func (a ArrayError) Error() string {
- return fmt.Sprintf("msgp: wanted array of size %d; got %d", a.Wanted, a.Got)
+ out := fmt.Sprintf("msgp: wanted array of size %d; got %d", a.Wanted, a.Got)
+ if a.ctx != "" {
+ out += " at " + a.ctx
+ }
+ return out
}
// Resumable is always 'true' for ArrayErrors
func (a ArrayError) Resumable() bool { return true }
+func (a ArrayError) withContext(ctx string) error { a.ctx = addCtx(a.ctx, ctx); return a }
+
// IntOverflow is returned when a call
// would downcast an integer to a type
// with too few bits to hold its value.
type IntOverflow struct {
Value int64 // the value of the integer
FailedBitsize int // the bit size that the int64 could not fit into
+ ctx string
}
// Error implements the error interface
func (i IntOverflow) Error() string {
- return fmt.Sprintf("msgp: %d overflows int%d", i.Value, i.FailedBitsize)
+ str := fmt.Sprintf("msgp: %d overflows int%d", i.Value, i.FailedBitsize)
+ if i.ctx != "" {
+ str += " at " + i.ctx
+ }
+ return str
}
// Resumable is always 'true' for overflows
func (i IntOverflow) Resumable() bool { return true }
+func (i IntOverflow) withContext(ctx string) error { i.ctx = addCtx(i.ctx, ctx); return i }
+
// UintOverflow is returned when a call
// would downcast an unsigned integer to a type
// with too few bits to hold its value
type UintOverflow struct {
Value uint64 // value of the uint
FailedBitsize int // the bit size that couldn't fit the value
+ ctx string
}
// Error implements the error interface
func (u UintOverflow) Error() string {
- return fmt.Sprintf("msgp: %d overflows uint%d", u.Value, u.FailedBitsize)
+ str := fmt.Sprintf("msgp: %d overflows uint%d", u.Value, u.FailedBitsize)
+ if u.ctx != "" {
+ str += " at " + u.ctx
+ }
+ return str
}
// Resumable is always 'true' for overflows
func (u UintOverflow) Resumable() bool { return true }
+func (u UintOverflow) withContext(ctx string) error { u.ctx = addCtx(u.ctx, ctx); return u }
+
+// UintBelowZero is returned when a call
+// would cast a signed integer below zero
+// to an unsigned integer.
+type UintBelowZero struct {
+ Value int64 // value of the incoming int
+ ctx string
+}
+
+// Error implements the error interface
+func (u UintBelowZero) Error() string {
+ str := fmt.Sprintf("msgp: attempted to cast int %d to unsigned", u.Value)
+ if u.ctx != "" {
+ str += " at " + u.ctx
+ }
+ return str
+}
+
+// Resumable is always 'true' for overflows
+func (u UintBelowZero) Resumable() bool { return true }
+
+func (u UintBelowZero) withContext(ctx string) error {
+ u.ctx = ctx
+ return u
+}
+
// A TypeError is returned when a particular
// decoding method is unsuitable for decoding
// a particular MessagePack value.
type TypeError struct {
Method Type // Type expected by method
Encoded Type // Type actually encoded
+
+ ctx string
}
// Error implements the error interface
func (t TypeError) Error() string {
- return fmt.Sprintf("msgp: attempted to decode type %q with method for %q", t.Encoded, t.Method)
+ out := fmt.Sprintf("msgp: attempted to decode type %q with method for %q", t.Encoded, t.Method)
+ if t.ctx != "" {
+ out += " at " + t.ctx
+ }
+ return out
}
// Resumable returns 'true' for TypeErrors
func (t TypeError) Resumable() bool { return true }
+func (t TypeError) withContext(ctx string) error { t.ctx = addCtx(t.ctx, ctx); return t }
+
// returns either InvalidPrefixError or
// TypeError depending on whether or not
// the prefix is recognized
@@ -133,10 +291,24 @@
// to a function that takes `interface{}`.
type ErrUnsupportedType struct {
T reflect.Type
+
+ ctx string
}
// Error implements error
-func (e *ErrUnsupportedType) Error() string { return fmt.Sprintf("msgp: type %q not supported", e.T) }
+func (e *ErrUnsupportedType) Error() string {
+ out := fmt.Sprintf("msgp: type %q not supported", e.T)
+ if e.ctx != "" {
+ out += " at " + e.ctx
+ }
+ return out
+}
// Resumable returns 'true' for ErrUnsupportedType
func (e *ErrUnsupportedType) Resumable() bool { return true }
+
+func (e *ErrUnsupportedType) withContext(ctx string) error {
+ o := *e
+ o.ctx = addCtx(o.ctx, ctx)
+ return &o
+}
diff --git a/vendor/github.com/tinylib/msgp/msgp/extension.go b/vendor/github.com/tinylib/msgp/msgp/extension.go
index 588b18f..0b31dcd 100644
--- a/vendor/github.com/tinylib/msgp/msgp/extension.go
+++ b/vendor/github.com/tinylib/msgp/msgp/extension.go
@@ -445,26 +445,27 @@
o[n] = mfixext16
o[n+1] = byte(e.ExtensionType())
n += 2
- }
- switch {
- case l < math.MaxUint8:
- o, n = ensure(b, l+3)
- o[n] = mext8
- o[n+1] = byte(uint8(l))
- o[n+2] = byte(e.ExtensionType())
- n += 3
- case l < math.MaxUint16:
- o, n = ensure(b, l+4)
- o[n] = mext16
- big.PutUint16(o[n+1:], uint16(l))
- o[n+3] = byte(e.ExtensionType())
- n += 4
default:
- o, n = ensure(b, l+6)
- o[n] = mext32
- big.PutUint32(o[n+1:], uint32(l))
- o[n+5] = byte(e.ExtensionType())
- n += 6
+ switch {
+ case l < math.MaxUint8:
+ o, n = ensure(b, l+3)
+ o[n] = mext8
+ o[n+1] = byte(uint8(l))
+ o[n+2] = byte(e.ExtensionType())
+ n += 3
+ case l < math.MaxUint16:
+ o, n = ensure(b, l+4)
+ o[n] = mext16
+ big.PutUint16(o[n+1:], uint16(l))
+ o[n+3] = byte(e.ExtensionType())
+ n += 4
+ default:
+ o, n = ensure(b, l+6)
+ o[n] = mext32
+ big.PutUint32(o[n+1:], uint32(l))
+ o[n+5] = byte(e.ExtensionType())
+ n += 6
+ }
}
return o, e.MarshalBinaryTo(o[n:])
}
diff --git a/vendor/github.com/tinylib/msgp/msgp/appengine.go b/vendor/github.com/tinylib/msgp/msgp/purego.go
similarity index 88%
rename from vendor/github.com/tinylib/msgp/msgp/appengine.go
rename to vendor/github.com/tinylib/msgp/msgp/purego.go
index bff9e76..c828f7e 100644
--- a/vendor/github.com/tinylib/msgp/msgp/appengine.go
+++ b/vendor/github.com/tinylib/msgp/msgp/purego.go
@@ -1,4 +1,4 @@
-// +build appengine
+// +build purego appengine
package msgp
diff --git a/vendor/github.com/tinylib/msgp/msgp/read.go b/vendor/github.com/tinylib/msgp/msgp/read.go
index 20cd1ef..aa668c5 100644
--- a/vendor/github.com/tinylib/msgp/msgp/read.go
+++ b/vendor/github.com/tinylib/msgp/msgp/read.go
@@ -583,6 +583,14 @@
i = int64(getMint8(p))
return
+ case muint8:
+ p, err = m.R.Next(2)
+ if err != nil {
+ return
+ }
+ i = int64(getMuint8(p))
+ return
+
case mint16:
p, err = m.R.Next(3)
if err != nil {
@@ -591,6 +599,14 @@
i = int64(getMint16(p))
return
+ case muint16:
+ p, err = m.R.Next(3)
+ if err != nil {
+ return
+ }
+ i = int64(getMuint16(p))
+ return
+
case mint32:
p, err = m.R.Next(5)
if err != nil {
@@ -599,6 +615,14 @@
i = int64(getMint32(p))
return
+ case muint32:
+ p, err = m.R.Next(5)
+ if err != nil {
+ return
+ }
+ i = int64(getMuint32(p))
+ return
+
case mint64:
p, err = m.R.Next(9)
if err != nil {
@@ -607,6 +631,19 @@
i = getMint64(p)
return
+ case muint64:
+ p, err = m.R.Next(9)
+ if err != nil {
+ return
+ }
+ u := getMuint64(p)
+ if u > math.MaxInt64 {
+ err = UintOverflow{Value: u, FailedBitsize: 64}
+ return
+ }
+ i = int64(u)
+ return
+
default:
err = badPrefix(IntType, lead)
return
@@ -678,6 +715,19 @@
return
}
switch lead {
+ case mint8:
+ p, err = m.R.Next(2)
+ if err != nil {
+ return
+ }
+ v := int64(getMint8(p))
+ if v < 0 {
+ err = UintBelowZero{Value: v}
+ return
+ }
+ u = uint64(v)
+ return
+
case muint8:
p, err = m.R.Next(2)
if err != nil {
@@ -686,6 +736,19 @@
u = uint64(getMuint8(p))
return
+ case mint16:
+ p, err = m.R.Next(3)
+ if err != nil {
+ return
+ }
+ v := int64(getMint16(p))
+ if v < 0 {
+ err = UintBelowZero{Value: v}
+ return
+ }
+ u = uint64(v)
+ return
+
case muint16:
p, err = m.R.Next(3)
if err != nil {
@@ -694,6 +757,19 @@
u = uint64(getMuint16(p))
return
+ case mint32:
+ p, err = m.R.Next(5)
+ if err != nil {
+ return
+ }
+ v := int64(getMint32(p))
+ if v < 0 {
+ err = UintBelowZero{Value: v}
+ return
+ }
+ u = uint64(v)
+ return
+
case muint32:
p, err = m.R.Next(5)
if err != nil {
@@ -702,6 +778,19 @@
u = uint64(getMuint32(p))
return
+ case mint64:
+ p, err = m.R.Next(9)
+ if err != nil {
+ return
+ }
+ v := int64(getMint64(p))
+ if v < 0 {
+ err = UintBelowZero{Value: v}
+ return
+ }
+ u = uint64(v)
+ return
+
case muint64:
p, err = m.R.Next(9)
if err != nil {
@@ -711,7 +800,11 @@
return
default:
- err = badPrefix(UintType, lead)
+ if isnfixint(lead) {
+ err = UintBelowZero{Value: int64(rnfixint(lead))}
+ } else {
+ err = badPrefix(UintType, lead)
+ }
return
}
diff --git a/vendor/github.com/tinylib/msgp/msgp/read_bytes.go b/vendor/github.com/tinylib/msgp/msgp/read_bytes.go
index 78e466f..f53f84d 100644
--- a/vendor/github.com/tinylib/msgp/msgp/read_bytes.go
+++ b/vendor/github.com/tinylib/msgp/msgp/read_bytes.go
@@ -79,6 +79,9 @@
return b, err
}
rlen := l - len(out)
+ if IsNil(b[:rlen]) {
+ rlen = 0
+ }
if cap(*r) < rlen {
*r = make(Raw, rlen)
} else {
@@ -104,7 +107,11 @@
// next object on the wire.
func (r *Raw) DecodeMsg(f *Reader) error {
*r = (*r)[:0]
- return appendNext(f, (*[]byte)(r))
+ err := appendNext(f, (*[]byte)(r))
+ if IsNil(*r) {
+ *r = (*r)[:0]
+ }
+ return err
}
// Msgsize implements msgp.Sizer
@@ -368,6 +375,15 @@
o = b[2:]
return
+ case muint8:
+ if l < 2 {
+ err = ErrShortBytes
+ return
+ }
+ i = int64(getMuint8(b))
+ o = b[2:]
+ return
+
case mint16:
if l < 3 {
err = ErrShortBytes
@@ -377,6 +393,15 @@
o = b[3:]
return
+ case muint16:
+ if l < 3 {
+ err = ErrShortBytes
+ return
+ }
+ i = int64(getMuint16(b))
+ o = b[3:]
+ return
+
case mint32:
if l < 5 {
err = ErrShortBytes
@@ -386,12 +411,35 @@
o = b[5:]
return
+ case muint32:
+ if l < 5 {
+ err = ErrShortBytes
+ return
+ }
+ i = int64(getMuint32(b))
+ o = b[5:]
+ return
+
case mint64:
if l < 9 {
err = ErrShortBytes
return
}
- i = getMint64(b)
+ i = int64(getMint64(b))
+ o = b[9:]
+ return
+
+ case muint64:
+ if l < 9 {
+ err = ErrShortBytes
+ return
+ }
+ u := getMuint64(b)
+ if u > math.MaxInt64 {
+ err = UintOverflow{Value: u, FailedBitsize: 64}
+ return
+ }
+ i = int64(u)
o = b[9:]
return
@@ -477,6 +525,20 @@
}
switch lead {
+ case mint8:
+ if l < 2 {
+ err = ErrShortBytes
+ return
+ }
+ v := int64(getMint8(b))
+ if v < 0 {
+ err = UintBelowZero{Value: v}
+ return
+ }
+ u = uint64(v)
+ o = b[2:]
+ return
+
case muint8:
if l < 2 {
err = ErrShortBytes
@@ -486,6 +548,20 @@
o = b[2:]
return
+ case mint16:
+ if l < 3 {
+ err = ErrShortBytes
+ return
+ }
+ v := int64(getMint16(b))
+ if v < 0 {
+ err = UintBelowZero{Value: v}
+ return
+ }
+ u = uint64(v)
+ o = b[3:]
+ return
+
case muint16:
if l < 3 {
err = ErrShortBytes
@@ -495,6 +571,20 @@
o = b[3:]
return
+ case mint32:
+ if l < 5 {
+ err = ErrShortBytes
+ return
+ }
+ v := int64(getMint32(b))
+ if v < 0 {
+ err = UintBelowZero{Value: v}
+ return
+ }
+ u = uint64(v)
+ o = b[5:]
+ return
+
case muint32:
if l < 5 {
err = ErrShortBytes
@@ -504,6 +594,20 @@
o = b[5:]
return
+ case mint64:
+ if l < 9 {
+ err = ErrShortBytes
+ return
+ }
+ v := int64(getMint64(b))
+ if v < 0 {
+ err = UintBelowZero{Value: v}
+ return
+ }
+ u = uint64(v)
+ o = b[9:]
+ return
+
case muint64:
if l < 9 {
err = ErrShortBytes
@@ -514,7 +618,11 @@
return
default:
- err = badPrefix(UintType, lead)
+ if isnfixint(lead) {
+ err = UintBelowZero{Value: int64(rnfixint(lead))}
+ } else {
+ err = badPrefix(UintType, lead)
+ }
return
}
}
diff --git a/vendor/github.com/tinylib/msgp/msgp/unsafe.go b/vendor/github.com/tinylib/msgp/msgp/unsafe.go
index 4bcf321..3978b6f 100644
--- a/vendor/github.com/tinylib/msgp/msgp/unsafe.go
+++ b/vendor/github.com/tinylib/msgp/msgp/unsafe.go
@@ -1,4 +1,4 @@
-// +build !appengine
+// +build !purego,!appengine
package msgp
diff --git a/vendor/github.com/tinylib/msgp/msgp/write.go b/vendor/github.com/tinylib/msgp/msgp/write.go
index da9099c..fb1947c 100644
--- a/vendor/github.com/tinylib/msgp/msgp/write.go
+++ b/vendor/github.com/tinylib/msgp/msgp/write.go
@@ -685,7 +685,7 @@
case reflect.Map:
return mw.writeMap(val)
}
- return &ErrUnsupportedType{val.Type()}
+ return &ErrUnsupportedType{T: val.Type()}
}
func (mw *Writer) writeMap(v reflect.Value) (err error) {
