Alteration for version passing

Signed-off-by: Alex Ellis (OpenFaaS Ltd) <alexellis2@gmail.com>
Pass version from main
2025-06-18 12:06:36 +00:00 · 2019-12-31 12:27:21 +00:00 · 2019-12-31 12:22:21 +00:00
2144 changed files with 279259 additions and 296925 deletions
--- a/.gitattributes
+++ b/.gitattributes
@ -1,2 +0,0 @@
-vendor/** linguist-generated=true
-Gopkg.lock linguist-generated=true
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@ -1 +0,0 @@
-@alexellis
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@ -1,63 +0,0 @@
-## Due diligence
-
-<!-- Due dilligence -->
-## My actions before raising this issue
-Before you ask for help or support, make sure that you've [consulted the manual for faasd](https://openfaas.gumroad.com/l/serverless-for-everyone-else). We can't answer questions that are already covered by the manual.
-
-
-<!-- How is this affecting you? What task are you trying to accomplish? -->
-## Why do you need this?
-
-
-<!--- Provide a general summary of the issue in the Title above -->
-## Expected Behaviour
-<!--- If you're describing a bug, tell us what should happen -->
-<!--- If you're suggesting a change/improvement, tell us how it should work -->
-
-
-## Current Behaviour
-<!--- If describing a bug, tell us what happens instead of the expected behavior -->
-<!--- If suggesting a change/improvement, explain the difference from current behavior -->
-
-
-## Are you a GitHub Sponsor (Yes/No?)
-<!--- Given this request for help, how are you supporting the project? -->
-
-Check at: https://github.com/sponsors/openfaas
- [ ] Yes
- [ ] No
-
-## List All Possible Solutions and Workarounds
-<!--- Suggest a fix/reason for the bug, or ideas how to implement  -->
-<!--- the addition or change -->
-<!--- Is there a workaround which could avoid making changes? -->
-
-## Which Solution Do You Recommend?
-<!--- Pick your preferred solution, if you were to implement and maintain this change -->
-
-
-## Steps to Reproduce (for bugs)
-<!--- Provide a link to a live example, or an unambiguous set of steps to -->
-<!--- reproduce this bug. Include code to reproduce, if relevant -->
-1.
-2.
-3.
-4.
-
-## Your Environment
-
-* OS and architecture:
-
-* Versions:
-
-```sh
-go version
-
-containerd -version
-
-uname -a
-
-cat /etc/os-release
-
-faasd version
-```
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@ -1,40 +0,0 @@
-<!--- Provide a general summary of your changes in the Title above -->
-
-## Description
-<!--- Describe your changes in detail -->
-
-## Motivation and Context
-<!--- Why is this change required? What problem does it solve? -->
-<!--- If it fixes an open issue, please link to the issue here. -->
- [ ] I have raised an issue to propose this change **this is required**
-
-
-## How Has This Been Tested?
-<!--- Please describe in detail how you tested your changes. -->
-<!--- Include details of your testing environment, and the tests you ran to -->
-<!--- see how your change affects other areas of the code, etc. -->
-
-
-## Types of changes
-<!--- What types of changes does your code introduce? Put an `x` in all the boxes that apply: -->
- [ ] Bug fix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing functionality to change)
-
-## Checklist:
-
-Commits:
-
- [ ] I've read the [CONTRIBUTION](https://github.com/openfaas/faas/blob/master/CONTRIBUTING.md) guide
- [ ] My commit message has a body and describe how this was tested and why it is required.
- [ ] I have signed-off my commits with `git commit -s` for the Developer Certificate of Origin (DCO)
-
-Code:
-
- [ ] My code follows the code style of this project.
- [ ] I have added tests to cover my changes.
-
-Docs:
-
- [ ] My change requires a change to the documentation.
- [ ] I have updated the documentation accordingly.
--- a/.github/workflows/build.yaml
+++ b/.github/workflows/build.yaml
@ -1,36 +0,0 @@
-name: build
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  build:
-    env:
-      GO111MODULE: off
-    strategy:
-      matrix:
-        go-version: [1.18.x]
-        os: [ubuntu-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@master
-        with:
-          fetch-depth: 1
-      - name: Install Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: ${{ matrix.go-version }}
-
-      - name: test
-        run: make test
-      - name: dist
-        run: make dist
-      - name: prepare-test
-        run: make prepare-test
-      - name: test e2e
-        run: make test-e2e
-
-
--- a/.github/workflows/publish.yaml
+++ b/.github/workflows/publish.yaml
@ -1,30 +0,0 @@
-name: publish
-
-on:
-  push:
-    tags:
-      - '*'
-
-jobs:
-  publish:
-    strategy:
-      matrix:
-        go-version: [ 1.18.x ]
-        os: [ ubuntu-latest ]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@master
-        with:
-          fetch-depth: 1
-      - name: Install Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: ${{ matrix.go-version }}
-      - name: Make publish
-        run: make publish
-      - name: Upload release binaries
-        uses: alexellis/upload-assets@0.2.2
-        env:
-          GITHUB_TOKEN: ${{ github.token }}
-        with:
-          asset_paths: '["./bin/faasd*"]'
--- a/.gitignore
+++ b/.gitignore
@ -5,6 +5,3 @@ hosts

 basic-auth-user
 basic-auth-password
-/bin
-/secrets
-.vscode
--- a/.travis.yml
+++ b/.travis.yml
@ -0,0 +1,20 @@
+sudo: required
+language: go
+go:
+- '1.12'
+script:
+- make dist
+deploy:
+  provider: releases
+  api_key:
+    secure: bccOSB+Mbk5ZJHyJfX82Xg/3/7mxiAYHx7P5m5KS1ncDuRpJBFjDV8Nx2PWYg341b5SMlCwsS3IJ9NkoGvRSKK+3YqeNfTeMabVNdKC2oL1i+4pdxGlbl57QXkzT4smqE8AykZEo4Ujk42rEr3e0gSHT2rXkV+Xt0xnoRVXn2tSRUDwsmwANnaBj6KpH2SjJ/lsfTifxrRB65uwcePaSjkqwR6htFraQtpONC9xYDdek6EoVQmoft/ONZJqi7HR+OcA1yhSt93XU6Vaf3678uLlPX9c/DxgIU9UnXRaOd0UUEiTHaMMWDe/bJSrKmgL7qY05WwbGMsXO/RdswwO1+zwrasrwf86SjdGX/P9AwobTW3eTEiBqw2J77UVbvLzDDoyJ5KrkbHRfPX8aIPO4OG9eHy/e7C3XVx4qv9bJBXQ3qD9YJtei9jmm8F/MCdPWuVYC0hEvHtuhP/xMm4esNUjFM5JUfDucvAuLL34NBYHBDP2XNuV4DkgQQPakfnlvYBd7OqyXCU6pzyWSasXpD1Rz8mD/x8aTUl2Ya4bnXQ8qAa5cnxfPqN2ADRlTw1qS7hl6LsXzNQ6r1mbuh/uFi67ybElIjBTfuMEeJOyYHkkLUHIBpooKrPyr0luAbf0By2D2N/eQQnM/RpixHNfZG/mvXx8ZCrs+wxgvG1Rm7rM=
+  file:
+    - ./bin/faasd
+    - ./bin/faasd-armhf
+    - ./bin/faasd-arm64
+  skip_cleanup: true
+  on:
+    tags: true
+
+env:
+- GO111MODULE=off
--- a/Gopkg.lock
+++ b/Gopkg.lock
@ -0,0 +1,484 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  digest = "1:d5e752c67b445baa5b6cb6f8aa706775c2aa8e41aca95a0c651520ff2c80361a"
+  name = "github.com/Microsoft/go-winio"
+  packages = [
+    ".",
+    "pkg/guid",
+  ]
+  pruneopts = "UT"
+  revision = "6c72808b55902eae4c5943626030429ff20f3b63"
+  version = "v0.4.14"
+
+[[projects]]
+  digest = "1:b28f788c0be42a6d26f07b282c5ff5f814ab7ad5833810ef0bc5f56fb9bedf11"
+  name = "github.com/Microsoft/hcsshim"
+  packages = [
+    ".",
+    "internal/cow",
+    "internal/hcs",
+    "internal/hcserror",
+    "internal/hns",
+    "internal/interop",
+    "internal/log",
+    "internal/logfields",
+    "internal/longpath",
+    "internal/mergemaps",
+    "internal/oc",
+    "internal/safefile",
+    "internal/schema1",
+    "internal/schema2",
+    "internal/timeout",
+    "internal/vmcompute",
+    "internal/wclayer",
+  ]
+  pruneopts = "UT"
+  revision = "9e921883ac929bbe515b39793ece99ce3a9d7706"
+
+[[projects]]
+  digest = "1:74860eb071d52337d67e9ffd6893b29affebd026505aa917ec23131576a91a77"
+  name = "github.com/alexellis/go-execute"
+  packages = ["pkg/v1"]
+  pruneopts = "UT"
+  revision = "961405ea754427780f2151adff607fa740d377f7"
+  version = "0.3.0"
+
+[[projects]]
+  digest = "1:6076d857867a70e87dd1994407deb142f27436f1293b13e75cc053192d14eb0c"
+  name = "github.com/alexellis/k3sup"
+  packages = ["pkg/env"]
+  pruneopts = "UT"
+  revision = "f9a4adddc732742a9ee7962609408fb0999f2d7b"
+  version = "0.7.1"
+
+[[projects]]
+  digest = "1:386ca0ac781cc1b630b3ed21725759770174140164b3faf3810e6ed6366a970b"
+  name = "github.com/containerd/containerd"
+  packages = [
+    ".",
+    "api/services/containers/v1",
+    "api/services/content/v1",
+    "api/services/diff/v1",
+    "api/services/events/v1",
+    "api/services/images/v1",
+    "api/services/introspection/v1",
+    "api/services/leases/v1",
+    "api/services/namespaces/v1",
+    "api/services/snapshots/v1",
+    "api/services/tasks/v1",
+    "api/services/version/v1",
+    "api/types",
+    "api/types/task",
+    "archive",
+    "archive/compression",
+    "cio",
+    "containers",
+    "content",
+    "content/proxy",
+    "defaults",
+    "diff",
+    "errdefs",
+    "events",
+    "events/exchange",
+    "filters",
+    "identifiers",
+    "images",
+    "images/archive",
+    "labels",
+    "leases",
+    "leases/proxy",
+    "log",
+    "mount",
+    "namespaces",
+    "oci",
+    "pkg/dialer",
+    "platforms",
+    "plugin",
+    "reference",
+    "remotes",
+    "remotes/docker",
+    "remotes/docker/schema1",
+    "rootfs",
+    "runtime/linux/runctypes",
+    "runtime/v2/runc/options",
+    "snapshots",
+    "snapshots/proxy",
+    "sys",
+    "version",
+  ]
+  pruneopts = "UT"
+  revision = "ff48f57fc83a8c44cf4ad5d672424a98ba37ded6"
+  version = "v1.3.2"
+
+[[projects]]
+  digest = "1:7e9da25c7a952c63e31ed367a88eede43224b0663b58eb452870787d8ddb6c70"
+  name = "github.com/containerd/continuity"
+  packages = [
+    "fs",
+    "syscallx",
+    "sysx",
+  ]
+  pruneopts = "UT"
+  revision = "f2a389ac0a02ce21c09edd7344677a601970f41c"
+
+[[projects]]
+  digest = "1:1b9a7426259b5333d575785e21e1bd0decf18208f5bfb6424d24a50d5ddf83d0"
+  name = "github.com/containerd/fifo"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "bda0ff6ed73c67bfb5e62bc9c697f146b7fd7f13"
+
+[[projects]]
+  digest = "1:6d66a41dbbc6819902f1589d0550bc01c18032c0a598a7cd656731e6df73861b"
+  name = "github.com/containerd/ttrpc"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "92c8520ef9f86600c650dd540266a007bf03670f"
+
+[[projects]]
+  digest = "1:7b4683388adabc709dbb082c13ba35967f072379c85b4acde997c1ca75af5981"
+  name = "github.com/containerd/typeurl"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "a93fcdb778cd272c6e9b3028b2f42d813e785d40"
+
+[[projects]]
+  digest = "1:e495f9f1fb2bae55daeb76e099292054fe1f734947274b3cfc403ccda595d55a"
+  name = "github.com/docker/distribution"
+  packages = [
+    "digestset",
+    "reference",
+    "registry/api/errcode",
+  ]
+  pruneopts = "UT"
+  revision = "0d3efadf0154c2b8a4e7b6621fff9809655cc580"
+
+[[projects]]
+  digest = "1:0938aba6e09d72d48db029d44dcfa304851f52e2d67cda920436794248e92793"
+  name = "github.com/docker/go-events"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "9461782956ad83b30282bf90e31fa6a70c255ba9"
+
+[[projects]]
+  digest = "1:fa6faf4a2977dc7643de38ae599a95424d82f8ffc184045510737010a82c4ecd"
+  name = "github.com/gogo/googleapis"
+  packages = ["google/rpc"]
+  pruneopts = "UT"
+  revision = "d31c731455cb061f42baff3bda55bad0118b126b"
+  version = "v1.2.0"
+
+[[projects]]
+  digest = "1:4107f4e81e8fd2e80386b4ed56b05e3a1fe26ecc7275fe80bb9c3a80a7344ff4"
+  name = "github.com/gogo/protobuf"
+  packages = [
+    "proto",
+    "sortkeys",
+    "types",
+  ]
+  pruneopts = "UT"
+  revision = "ba06b47c162d49f2af050fb4c75bcbc86a159d5c"
+  version = "v1.2.1"
+
+[[projects]]
+  branch = "master"
+  digest = "1:b7cb6054d3dff43b38ad2e92492f220f57ae6087ee797dca298139776749ace8"
+  name = "github.com/golang/groupcache"
+  packages = ["lru"]
+  pruneopts = "UT"
+  revision = "611e8accdfc92c4187d399e95ce826046d4c8d73"
+
+[[projects]]
+  digest = "1:f5ce1529abc1204444ec73779f44f94e2fa8fcdb7aca3c355b0c95947e4005c6"
+  name = "github.com/golang/protobuf"
+  packages = [
+    "proto",
+    "ptypes",
+    "ptypes/any",
+    "ptypes/duration",
+    "ptypes/timestamp",
+  ]
+  pruneopts = "UT"
+  revision = "6c65a5562fc06764971b7c5d05c76c75e84bdbf7"
+  version = "v1.3.2"
+
+[[projects]]
+  digest = "1:870d441fe217b8e689d7949fef6e43efbc787e50f200cb1e70dbca9204a1d6be"
+  name = "github.com/inconshreveable/mousetrap"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75"
+  version = "v1.0"
+
+[[projects]]
+  digest = "1:31e761d97c76151dde79e9d28964a812c46efc5baee4085b86f68f0c654450de"
+  name = "github.com/konsorten/go-windows-terminal-sequences"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "f55edac94c9bbba5d6182a4be46d86a2c9b5b50e"
+  version = "v1.0.2"
+
+[[projects]]
+  digest = "1:906eb1ca3c8455e447b99a45237b2b9615b665608fd07ad12cce847dd9a1ec43"
+  name = "github.com/morikuni/aec"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "39771216ff4c63d11f5e604076f9c45e8be1067b"
+  version = "v1.0.0"
+
+[[projects]]
+  digest = "1:bc62c2c038cc8ae51b68f6d52570501a763bb71e78736a9f65d60762429864a9"
+  name = "github.com/opencontainers/go-digest"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "c9281466c8b2f606084ac71339773efd177436e7"
+
+[[projects]]
+  digest = "1:70711188c19c53147099d106169d6a81941ed5c2658651432de564a7d60fd288"
+  name = "github.com/opencontainers/image-spec"
+  packages = [
+    "identity",
+    "specs-go",
+    "specs-go/v1",
+  ]
+  pruneopts = "UT"
+  revision = "d60099175f88c47cd379c4738d158884749ed235"
+  version = "v1.0.1"
+
+[[projects]]
+  digest = "1:18d6ebfbabffccba7318a4e26028b0d41f23ff359df3dc07a53b37a9f3a4a994"
+  name = "github.com/opencontainers/runc"
+  packages = [
+    "libcontainer/system",
+    "libcontainer/user",
+  ]
+  pruneopts = "UT"
+  revision = "d736ef14f0288d6993a1845745d6756cfc9ddd5a"
+  version = "v1.0.0-rc9"
+
+[[projects]]
+  digest = "1:7a58202c5cdf3d2c1eb0621fe369315561cea7f036ad10f0f0479ac36bcc95eb"
+  name = "github.com/opencontainers/runtime-spec"
+  packages = ["specs-go"]
+  pruneopts = "UT"
+  revision = "29686dbc5559d93fb1ef402eeda3e35c38d75af4"
+
+[[projects]]
+  digest = "1:cf31692c14422fa27c83a05292eb5cbe0fb2775972e8f1f8446a71549bd8980b"
+  name = "github.com/pkg/errors"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "ba968bfe8b2f7e042a574c888954fccecfa385b4"
+  version = "v0.8.1"
+
+[[projects]]
+  digest = "1:044c51736e2688a3e4f28f72537f8a7b3f9c188fab4477d5334d92dfe2c07ed5"
+  name = "github.com/sethvargo/go-password"
+  packages = ["password"]
+  pruneopts = "UT"
+  revision = "07c3d521e892540e71469bb0312866130714c038"
+  version = "v0.1.3"
+
+[[projects]]
+  digest = "1:fd61cf4ae1953d55df708acb6b91492d538f49c305b364a014049914495db426"
+  name = "github.com/sirupsen/logrus"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "8bdbc7bcc01dcbb8ec23dc8a28e332258d25251f"
+  version = "v1.4.1"
+
+[[projects]]
+  digest = "1:e096613fb7cf34743d49af87d197663cfccd61876e2219853005a57baedfa562"
+  name = "github.com/spf13/cobra"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "f2b07da1e2c38d5f12845a4f607e2e1018cbb1f5"
+  version = "v0.0.5"
+
+[[projects]]
+  digest = "1:524b71991fc7d9246cc7dc2d9e0886ccb97648091c63e30eef619e6862c955dd"
+  name = "github.com/spf13/pflag"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "2e9d26c8c37aae03e3f9d4e90b7116f5accb7cab"
+  version = "v1.0.5"
+
+[[projects]]
+  branch = "master"
+  digest = "1:e14e467ed00ab98665623c5060fa17e3d7079be560ffc33cabafd05d35894f05"
+  name = "github.com/syndtr/gocapability"
+  packages = ["capability"]
+  pruneopts = "UT"
+  revision = "d98352740cb2c55f81556b63d4a1ec64c5a319c2"
+
+[[projects]]
+  digest = "1:2d9d06cb9d46dacfdbb45f8575b39fc0126d083841a29d4fbf8d97708f43107e"
+  name = "github.com/vishvananda/netlink"
+  packages = [
+    ".",
+    "nl",
+  ]
+  pruneopts = "UT"
+  revision = "a2ad57a690f3caf3015351d2d6e1c0b95c349752"
+  version = "v1.0.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:975cb0c04431bf92e60b636a15897c4a3faba9f7dc04da505646630ac91d29d3"
+  name = "github.com/vishvananda/netns"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "0a2b9b5464df8343199164a0321edf3313202f7e"
+
+[[projects]]
+  digest = "1:aed53a5fa03c1270457e331cf8b7e210e3088a2278fec552c5c5d29c1664e161"
+  name = "go.opencensus.io"
+  packages = [
+    ".",
+    "internal",
+    "trace",
+    "trace/internal",
+    "trace/tracestate",
+  ]
+  pruneopts = "UT"
+  revision = "aad2c527c5defcf89b5afab7f37274304195a6b2"
+  version = "v0.22.2"
+
+[[projects]]
+  branch = "master"
+  digest = "1:676f320d34ccfa88bfa6d04bdf388ed7062af175355c805ef57ccda1a3f13432"
+  name = "golang.org/x/net"
+  packages = [
+    "context",
+    "context/ctxhttp",
+    "http/httpguts",
+    "http2",
+    "http2/hpack",
+    "idna",
+    "internal/timeseries",
+    "trace",
+  ]
+  pruneopts = "UT"
+  revision = "c0dbc17a35534bf2e581d7a942408dc936316da4"
+
+[[projects]]
+  digest = "1:d6b0cfc5ae30841c4b116ac589629f56f8add0955a39f11d8c0d06ca67f5b3d5"
+  name = "golang.org/x/sync"
+  packages = [
+    "errgroup",
+    "semaphore",
+  ]
+  pruneopts = "UT"
+  revision = "42b317875d0fa942474b76e1b46a6060d720ae6e"
+
+[[projects]]
+  branch = "master"
+  digest = "1:a76bac71eb452a046b47f82336ba792d8de988688a912f3fd0e8ec8e57fe1bb4"
+  name = "golang.org/x/sys"
+  packages = [
+    "unix",
+    "windows",
+  ]
+  pruneopts = "UT"
+  revision = "af0d71d358abe0ba3594483a5d519f429dbae3e9"
+
+[[projects]]
+  digest = "1:8d8faad6b12a3a4c819a3f9618cb6ee1fa1cfc33253abeeea8b55336721e3405"
+  name = "golang.org/x/text"
+  packages = [
+    "collate",
+    "collate/build",
+    "internal/colltab",
+    "internal/gen",
+    "internal/language",
+    "internal/language/compact",
+    "internal/tag",
+    "internal/triegen",
+    "internal/ucd",
+    "language",
+    "secure/bidirule",
+    "transform",
+    "unicode/bidi",
+    "unicode/cldr",
+    "unicode/norm",
+    "unicode/rangetable",
+  ]
+  pruneopts = "UT"
+  revision = "342b2e1fbaa52c93f31447ad2c6abc048c63e475"
+  version = "v0.3.2"
+
+[[projects]]
+  branch = "master"
+  digest = "1:583a0c80f5e3a9343d33aea4aead1e1afcc0043db66fdf961ddd1fe8cd3a4faf"
+  name = "google.golang.org/genproto"
+  packages = ["googleapis/rpc/status"]
+  pruneopts = "UT"
+  revision = "b31c10ee225f87dbb9f5f878ead9d64f34f5cbbb"
+
+[[projects]]
+  digest = "1:48eafc052e46b4ebbc7882553873cf6198203e528627cefc94dcaf8553addd19"
+  name = "google.golang.org/grpc"
+  packages = [
+    ".",
+    "balancer",
+    "balancer/base",
+    "balancer/roundrobin",
+    "binarylog/grpc_binarylog_v1",
+    "codes",
+    "connectivity",
+    "credentials",
+    "credentials/internal",
+    "encoding",
+    "encoding/proto",
+    "grpclog",
+    "health/grpc_health_v1",
+    "internal",
+    "internal/backoff",
+    "internal/balancerload",
+    "internal/binarylog",
+    "internal/channelz",
+    "internal/envconfig",
+    "internal/grpcrand",
+    "internal/grpcsync",
+    "internal/syscall",
+    "internal/transport",
+    "keepalive",
+    "metadata",
+    "naming",
+    "peer",
+    "resolver",
+    "resolver/dns",
+    "resolver/passthrough",
+    "serviceconfig",
+    "stats",
+    "status",
+    "tap",
+  ]
+  pruneopts = "UT"
+  revision = "6eaf6f47437a6b4e2153a190160ef39a92c7eceb"
+  version = "v1.23.0"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  input-imports = [
+    "github.com/alexellis/go-execute/pkg/v1",
+    "github.com/alexellis/k3sup/pkg/env",
+    "github.com/containerd/containerd",
+    "github.com/containerd/containerd/cio",
+    "github.com/containerd/containerd/containers",
+    "github.com/containerd/containerd/errdefs",
+    "github.com/containerd/containerd/namespaces",
+    "github.com/containerd/containerd/oci",
+    "github.com/morikuni/aec",
+    "github.com/opencontainers/runtime-spec/specs-go",
+    "github.com/sethvargo/go-password/password",
+    "github.com/spf13/cobra",
+    "github.com/vishvananda/netlink",
+    "github.com/vishvananda/netns",
+    "golang.org/x/sys/unix",
+  ]
+  solver-name = "gps-cdcl"
+  solver-version = 1
--- a/Gopkg.toml
+++ b/Gopkg.toml
@ -0,0 +1,27 @@
+[[constraint]]
+  name = "github.com/containerd/containerd"
+  version = "1.3.2"
+
+[[constraint]]
+  name = "github.com/morikuni/aec"
+  version = "1.0.0"
+
+[[constraint]]
+  name = "github.com/spf13/cobra"
+  version = "0.0.5"
+
+[[constraint]]
+  name = "github.com/alexellis/k3sup"
+  version = "0.7.1"
+
+[[constraint]]
+  name = "github.com/alexellis/go-execute"
+  version = "0.3.0"
+
+[prune]
+  go-tests = true
+  unused-packages = true
+
+[[constraint]]
+  name = "github.com/sethvargo/go-password"
+  version = "0.1.3"
--- a/4
+++ b/4
@ -1,8 +1,6 @@
 MIT License

-Copyright (c) 2020 Alex Ellis
-Copyright (c) 2020 OpenFaaS Ltd
-Copyright (c) 2020 OpenFaas Author(s)
+Copyright (c) 2019 Alex Ellis

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
--- a/63
+++ b/63
@ -1,68 +1,15 @@
 Version := $(shell git describe --tags --dirty)
 GitCommit := $(shell git rev-parse HEAD)
 LDFLAGS := "-s -w -X main.Version=$(Version) -X main.GitCommit=$(GitCommit)"
-CONTAINERD_VER := 1.6.4
-CNI_VERSION := v0.9.1
-ARCH := amd64
-
-export GO111MODULE=on

 .PHONY: all
-all: test dist hashgen
-
-.PHONY: publish
-publish: dist hashgen
+all: local

 local:
-	CGO_ENABLED=0 GOOS=linux go build -mod=vendor -o bin/faasd
-
-.PHONY: test
-test:
-	CGO_ENABLED=0 GOOS=linux go test -mod=vendor -ldflags $(LDFLAGS) ./...
+	CGO_ENABLED=0 GOOS=linux go build -o bin/faasd

 .PHONY: dist
 dist:
-	CGO_ENABLED=0 GOOS=linux go build -mod=vendor -ldflags $(LDFLAGS) -a -installsuffix cgo -o bin/faasd
-	CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=7 go build -mod=vendor -ldflags $(LDFLAGS) -a -installsuffix cgo -o bin/faasd-armhf
-	CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -mod=vendor -ldflags $(LDFLAGS) -a -installsuffix cgo -o bin/faasd-arm64
-
-.PHONY: hashgen
-hashgen:
-	for f in bin/faasd*; do shasum -a 256 $$f > $$f.sha256; done
-
-.PHONY: prepare-test
-prepare-test:
-	curl -sLSf https://github.com/containerd/containerd/releases/download/v$(CONTAINERD_VER)/containerd-$(CONTAINERD_VER)-linux-amd64.tar.gz > /tmp/containerd.tar.gz && sudo tar -xvf /tmp/containerd.tar.gz -C /usr/local/bin/ --strip-components=1
-	curl -SLfs https://raw.githubusercontent.com/containerd/containerd/v1.6.4/containerd.service | sudo tee /etc/systemd/system/containerd.service
-	sudo systemctl daemon-reload && sudo systemctl start containerd
-	sudo /sbin/sysctl -w net.ipv4.conf.all.forwarding=1
-	sudo mkdir -p /opt/cni/bin
-	curl -sSL https://github.com/containernetworking/plugins/releases/download/$(CNI_VERSION)/cni-plugins-linux-$(ARCH)-$(CNI_VERSION).tgz | sudo tar -xz -C /opt/cni/bin
-	sudo cp bin/faasd /usr/local/bin/
-	sudo /usr/local/bin/faasd install
-	sudo systemctl status -l containerd --no-pager
-	sudo journalctl -u faasd-provider --no-pager
-	sudo systemctl status -l faasd-provider --no-pager
-	sudo systemctl status -l faasd --no-pager
-	curl -sSLf https://cli.openfaas.com | sudo sh
-	echo "Sleeping for 2m" && sleep 120 && sudo journalctl -u faasd --no-pager
-
-.PHONY: test-e2e
-test-e2e:
-	sudo cat /var/lib/faasd/secrets/basic-auth-password | /usr/local/bin/faas-cli login --password-stdin
-	/usr/local/bin/faas-cli store deploy figlet --env write_timeout=1s --env read_timeout=1s --label testing=true
-	sleep 5
-	/usr/local/bin/faas-cli list -v
-	/usr/local/bin/faas-cli describe figlet | grep testing
-	uname | /usr/local/bin/faas-cli invoke figlet
-	uname | /usr/local/bin/faas-cli invoke figlet --async
-	sleep 10
-	/usr/local/bin/faas-cli list -v
-	/usr/local/bin/faas-cli remove figlet
-	sleep 3
-	/usr/local/bin/faas-cli list
-	sleep 3
-	journalctl -t openfaas-fn:figlet --no-pager
-
-# Removed due to timing issue in CI on GitHub Actions
-#	/usr/local/bin/faas-cli logs figlet --since 15m --follow=false | grep Forking
+	CGO_ENABLED=0 GOOS=linux go build -ldflags $(LDFLAGS) -a -installsuffix cgo -o bin/faasd
+	CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=7 go build -ldflags $(LDFLAGS) -a -installsuffix cgo -o bin/faasd-armhf
+	CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -ldflags $(LDFLAGS) -a -installsuffix cgo -o bin/faasd-arm64
--- a/README.md
+++ b/README.md
@ -1,172 +1,158 @@
-# faasd - a lightweight & portable faas engine
+# faasd - serverless with containerd

-[![Sponsor this](https://img.shields.io/static/v1?label=Sponsor&message=%E2%9D%A4&logo=GitHub&link=https://github.com/sponsors/openfaas)](https://github.com/sponsors/openfaas)
-[![Build Status](https://github.com/openfaas/faasd/workflows/build/badge.svg?branch=master)](https://github.com/openfaas/faasd/actions)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![OpenFaaS](https://img.shields.io/badge/openfaas-serverless-blue.svg)](https://www.openfaas.com)
-![Downloads](https://img.shields.io/github/downloads/openfaas/faasd/total)
+[![Build Status](https://travis-ci.com/alexellis/faasd.svg?branch=master)](https://travis-ci.com/alexellis/faasd)

-faasd is [OpenFaaS](https://github.com/openfaas/) reimagined, but without the cost and complexity of Kubernetes. It runs on a single host with very modest requirements, making it fast and easy to manage. Under the hood it uses [containerd](https://containerd.io/) and [Container Networking Interface (CNI)](https://github.com/containernetworking/cni) along with the same core OpenFaaS components from the main project.
+faasd is a Golang supervisor that bundles OpenFaaS for use with containerd instead of a container orchestrator like Kubernetes or Docker Swarm.

-![faasd logo](docs/media/social.png)
+## About faasd:

-## Use-cases and tutorials
+* faasd is a single Golang binary
+* faasd is multi-arch, so works on `x86_64`, armhf and arm64
+* faasd downloads, starts and supervises the core components to run OpenFaaS

-faasd is just another way to run OpenFaaS, so many things you read in the docs or in blog posts will work the same way.
+## What does faasd deploy?

-Videos and overviews:
+* [faas-containerd](https://github.com/alexellis/faas-containerd/)
+* [Prometheus](https://github.com/prometheus/prometheus)
+* [the OpenFaaS gateway](https://github.com/openfaas/faas/tree/master/gateway)

-* [Exploring of serverless use-cases from commercial and personal users (YouTube)](https://www.youtube.com/watch?v=mzuXVuccaqI)
-* [Meet faasd. Look Ma’ No Kubernetes! (YouTube)](https://www.youtube.com/watch?v=ZnZJXI377ak)
+You can use the standard [faas-cli](https://github.com/openfaas/faas-cli) with faasd along with pre-packaged functions in the Function Store, or build your own with the template store.

-Use-cases and tutorials:
+### faas-containerd supports:

-* [Serverless Node.js that you can run anywhere](https://www.openfaas.com/blog/serverless-nodejs/)
-* [Simple Serverless with Golang Functions and Microservices](https://www.openfaas.com/blog/golang-serverless/)
-* [Build a Flask microservice with OpenFaaS](https://www.openfaas.com/blog/openfaas-flask/)
-* [Get started with Java 11 and Vert.x on Kubernetes with OpenFaaS](https://www.openfaas.com/blog/get-started-with-java-openjdk11/)
-* [Deploy to faasd via GitHub Actions](https://www.openfaas.com/blog/openfaas-functions-with-github-actions/)
-* [Scrape and automate websites with Puppeteer](https://www.openfaas.com/blog/puppeteer-scraping/)
+* `faas list`
+* `faas describe` 
+* `faas deploy --update=true --replace=false`
+* `faas invoke`
+* `faas invoke --async`

-Additional resources:
+Other operations are pending development in the provider.

-* The official handbook - [Serverless For Everyone Else](https://gumroad.com/l/serverless-for-everyone-else)
-* For reference: [OpenFaaS docs](https://docs.openfaas.com)
-* For use-cases and tutorials: [OpenFaaS blog](https://openfaas.com/blog/)
-* For self-paced learning: [OpenFaaS workshop](https://github.com/openfaas/workshop/)
+### Pre-reqs

-### About faasd
+* Linux - ideally Ubuntu, which is used for testing
+* Installation steps as per [faas-containerd](https://github.com/alexellis/faas-containerd) for building and for development
+    * [netns](https://github.com/genuinetools/netns/releases) binary in `$PATH`
+    * [containerd v1.3.2](https://github.com/containerd/containerd)
+* [faas-cli](https://github.com/openfaas/faas-cli) (optional)

-* faasd is a static Golang binary
-* uses the same core components and ecosystem of OpenFaaS
-* uses containerd for its runtime and CNI for networking
-* is multi-arch, so works on Intel `x86_64` and ARM out the box
-* can run almost any other stateful container through its `docker-compose.yaml` file
+## Backlog

-Most importantly, it's easy to manage so you can set it up and leave it alone to run your functions.
+Pending:

-[![demo](https://pbs.twimg.com/media/EPNQz00W4AEwDxM?format=jpg&name=medium)](https://www.youtube.com/watch?v=WX1tZoSXy8E)
+* [ ] Use CNI to create network namespaces and adapters
+* [ ] Monitor and restart any of the core components at runtime if the container stops
+* [ ] Bundle/package/automate installation of containerd - [see bootstrap from k3s](https://github.com/rancher/k3s)
+* [ ] Provide ufw rules / example for blocking access to everything but a reverse proxy to the gateway container

-> Demo of faasd running asynchronous functions
+Done:

-Watch the video: [faasd walk-through with cloud-init and Multipass](https://www.youtube.com/watch?v=WX1tZoSXy8E)
+* [x] Inject / manage IPs between core components for service to service communication - i.e. so Prometheus can scrape the OpenFaaS gateway - done via `/etc/hosts` mount
+* [x] Add queue-worker and NATS
+* [x] Create faasd.service and faas-containerd.service
+* [x] Self-install / create systemd service via `faasd install`
+* [x] Restart containers upon restart of faasd
+* [x] Clear / remove containers and tasks with SIGTERM / SIGINT
+* [x] Determine armhf/arm64 containers to run for gateway
+* [x] Configure `basic_auth` to protect the OpenFaaS gateway and faas-containerd HTTP API

-### What does faasd deploy?
+## Hacking (build from source)

-* faasd - itself, and its [faas-provider](https://github.com/openfaas/faas-provider) for containerd - CRUD for functions and services, implements the OpenFaaS REST API
-* [Prometheus](https://github.com/prometheus/prometheus) - for monitoring of services, metrics, scaling and dashboards
-* [OpenFaaS Gateway](https://github.com/openfaas/faas/tree/master/gateway) - the UI portal, CLI, and other OpenFaaS tooling can talk to this.
-* [OpenFaaS queue-worker for NATS](https://github.com/openfaas/nats-queue-worker) - run your invocations in the background without adding any code. See also: [asynchronous invocations](https://docs.openfaas.com/reference/triggers/#async-nats-streaming)
-* [NATS](https://nats.io) for asynchronous processing and queues
+First run faas-containerd

-faasd relies on industry-standard tools for running containers:
+```sh
+cd $GOPATH/src/github.com/alexellis/faas-containerd

-* [CNI](https://github.com/containernetworking/plugins)
-* [containerd](https://github.com/containerd/containerd)
-* [runc](https://github.com/opencontainers/runc)
+# You'll need to install containerd and its pre-reqs first
+# https://github.com/alexellis/faas-containerd/

-You can use the standard [faas-cli](https://github.com/openfaas/faas-cli) along with pre-packaged functions from *the Function Store*, or build your own using any OpenFaaS template.
-
-### When should you use faasd over OpenFaaS on Kubernetes?
-
-* To deploy microservices and functions that you can update and monitor remotely
-* When you don't have the bandwidth to learn or manage Kubernetes
-* To deploy embedded apps in IoT and edge use-cases
-* To distribute applications to a customer or client
-* You have a cost sensitive project - run faasd on a 1GB VM for 5-10 USD / mo or on your Raspberry Pi
-* When you just need a few functions or microservices, without the cost of a cluster
-
-faasd does not create the same maintenance burden you'll find with maintaining, upgrading, and securing a Kubernetes cluster. You can deploy it and walk away, in the worst case, just deploy a new VM and deploy your functions again.
-
-## Learning faasd
-
-The faasd project is MIT licensed and open source, and you will find some documentation, blog posts and videos for free.
-
-However, "Serverless For Everyone Else" is the official handbook and was written to contribute funds towards the upkeep and maintenance of the project.
-
-### The official handbook and docs for faasd
-
-<a href="https://gumroad.com/l/serverless-for-everyone-else">
-<img src="https://www.alexellis.io/serverless.png" width="40%"></a>
-
-You'll learn how to deploy code in any language, lift and shift Dockerfiles, run requests in queues, write background jobs and to integrate with databases. faasd packages the same code as OpenFaaS, so you get built-in metrics for your HTTP endpoints, a user-friendly CLI, pre-packaged functions and templates from the store and a UI.
-
-Topics include:
-
-* Should you deploy to a VPS or Raspberry Pi?
-* Deploying your server with bash, cloud-init or terraform
-* Using a private container registry
-* Finding functions in the store
-* Building your first function with Node.js
-* Using environment variables for configuration
-* Using secrets from functions, and enabling authentication tokens
-* Customising templates
-* Monitoring your functions with Grafana and Prometheus
-* Scheduling invocations and background jobs
-* Tuning timeouts, parallelism, running tasks in the background
-* Adding TLS to faasd and custom domains for functions
-* Self-hosting on your Raspberry Pi
-* Adding a database for storage with InfluxDB and Postgresql
-* Troubleshooting and logs
-* CI/CD with GitHub Actions and multi-arch
-* Taking things further, community and case-studies
-
-View sample pages, reviews and testimonials on Gumroad:
-
-["Serverless For Everyone Else"](https://gumroad.com/l/serverless-for-everyone-else)
-
-### Deploy faasd
-
-The easiest way to deploy faasd is with cloud-init, we give several examples below, and post IaaS platforms will accept "user-data" pasted into their UI, or via their API.
-
-For trying it out on MacOS or Windows, we recommend using [multipass](https://multipass.run) to run faasd in a VM.
-
-If you don't use cloud-init, or have already created your Linux server you can use the installation script as per below:
-
-```bash
-git clone https://github.com/openfaas/faasd --depth=1
-cd faasd
-
-./hack/install.sh
+sudo ./faas-containerd
 ```

-> This approach also works for Raspberry Pi
+Then run faasd, which brings up the gateway and Prometheus as containers

-It's recommended that you do not install Docker on the same host as faasd, since 1) they may both use different versions of containerd and 2) docker's networking rules can disrupt faasd's networking. When using faasd - make your faasd server a faasd server, and build container image on your laptop or in a CI pipeline.
+```sh
+cd $GOPATH/src/github.com/alexellis/faasd
+go build

-#### Deployment tutorials
+# Install with systemd
+# sudo ./faasd install

-* [Use multipass on Windows, MacOS or Linux](/docs/MULTIPASS.md)
-* [Deploy to DigitalOcean with Terraform and TLS](https://www.openfaas.com/blog/faasd-tls-terraform/)
-* [Deploy to any IaaS with cloud-init](https://blog.alexellis.io/deploy-serverless-faasd-with-cloud-init/)
-* [Deploy faasd to your Raspberry Pi](https://blog.alexellis.io/faasd-for-lightweight-serverless/)
+# Or run interactively
+# sudo ./faasd up
+```

-Terraform scripts:
+### Build and run (binaries)

-* [Provision faasd on DigitalOcean with Terraform](docs/bootstrap/README.md)
-* [Provision faasd with TLS on DigitalOcean with Terraform](docs/bootstrap/digitalocean-terraform/README.md)
+```sh
+# For x86_64
+sudo curl -fSLs "https://github.com/alexellis/faasd/releases/download/0.3.1/faasd" \
+    -o "/usr/local/bin/faasd" \
+    && sudo chmod a+x "/usr/local/bin/faasd"

-### Function and template store
+# armhf
+sudo curl -fSLs "https://github.com/alexellis/faasd/releases/download/0.3.1/faasd-armhf" \
+    -o "/usr/local/bin/faasd" \
+    && sudo chmod a+x "/usr/local/bin/faasd"

-For community functions see `faas-cli store --help`
+# arm64
+sudo curl -fSLs "https://github.com/alexellis/faasd/releases/download/0.3.1/faasd-arm64" \
+    -o "/usr/local/bin/faasd" \
+    && sudo chmod a+x "/usr/local/bin/faasd"
+```

-For templates built by the community see: `faas-cli template store list`, you can also use the `dockerfile` template if you just want to migrate an existing service without the benefits of using a template.
+### At run-time

-### Community support
+Look in `hosts` in the current working folder to get the IP for the gateway or Prometheus

-Commercial users and solo business owners should become OpenFaaS GitHub Sponsors to receive regular email updates on changes, tutorials and new features.
+```sh
+127.0.0.1       localhost
+172.19.0.1      faas-containerd
+172.19.0.2      prometheus

-If you are learning faasd, or want to share your use-case, you can join the OpenFaaS Slack community.
+172.19.0.3      gateway
+172.19.0.4      nats
+172.19.0.5      queue-worker
+```

-* [Become an OpenFaaS GitHub Sponsor](https://github.com/sponsors/openfaas/)
-* [Join Slack](https://slack.openfaas.io/)
+Since faas-containerd uses containerd heavily it is not running as a container, but as a stand-alone process. Its port is available via the bridge interface, i.e. netns0.

-### Backlog, features and known issues
+* Prometheus will run on the Prometheus IP plus port 8080 i.e. http://172.19.0.2:9090/targets

-For completed features, WIP and upcoming roadmap see:
+* faas-containerd runs on 172.19.0.1:8081

-See [ROADMAP.md](docs/ROADMAP.md)
+* Now go to the gateway's IP address as shown above on port 8080, i.e. http://172.19.0.3:8080 - you can also use this address to deploy OpenFaaS Functions via the `faas-cli`. 

-Want to build a patch without setting up a complete development environment? See [docs/PATCHES.md](docs/PATCHES.md)
+* basic-auth
+
+    You will then need to get the basic-auth password, it is written to `$GOPATH/src/github.com/alexellis/faasd/basic-auth-password` if you followed the above instructions.
+The default Basic Auth username is `admin`, which is written to `$GOPATH/src/github.com/alexellis/faasd/basic-auth-user`, if you wish to use a non-standard user then create this file and add your username (no newlines or other characters) 
+
+#### Installation with systemd
+
+* `faasd install` - install faasd and containerd with systemd, run in `$GOPATH/src/github.com/alexellis/faasd`
+* `journalctl -u faasd` - faasd systemd logs
+* `journalctl -u faas-containerd` - faas-containerd systemd logs
+
+### Appendix
+
+Removing containers:
+
+```sh
+echo faas-containerd gateway prometheus | xargs sudo ctr task rm -f
+
+echo faas-containerd gateway prometheus | xargs sudo ctr container rm
+
+echo faas-containerd gateway prometheus | xargs sudo ctr snapshot rm
+```
+
+## Links
+
+https://github.com/renatofq/ctrofb/blob/31968e4b4893f3603e9998f21933c4131523bb5d/cmd/network.go
+
+https://github.com/renatofq/catraia/blob/c4f62c86bddbfadbead38cd2bfe6d920fba26dce/catraia-net/network.go
+
+https://github.com/containernetworking/plugins
+
+https://github.com/containerd/go-cni

-Are you looking to hack on faasd? Follow the [developer instructions](docs/DEV.md) for a manual installation, or use the `hack/install.sh` script and pick up from there.
--- a/cloud-config.txt
+++ b/cloud-config.txt
@ -1,20 +0,0 @@
-#cloud-config
-ssh_authorized_keys:
-## Note: Replace with your own public key
-  - ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC8Q/aUYUr3P1XKVucnO9mlWxOjJm+K01lHJR90MkHC9zbfTqlp8P7C3J26zKAuzHXOeF+VFxETRr6YedQKW9zp5oP7sN+F2gr/pO7GV3VmOqHMV7uKfyUQfq7H1aVzLfCcI7FwN2Zekv3yB7kj35pbsMa1Za58aF6oHRctZU6UWgXXbRxP+B04DoVU7jTstQ4GMoOCaqYhgPHyjEAS3DW0kkPW6HzsvJHkxvVcVlZ/wNJa1Ie/yGpzOzWIN0Ol0t2QT/RSWOhfzO1A2P0XbPuZ04NmriBonO9zR7T1fMNmmtTuK7WazKjQT3inmYRAqU6pe8wfX8WIWNV7OowUjUsv alex@alexr.local
-
-package_update: true
-
-packages:
- - runc
- - git
-
-runcmd:
- curl -sfL https://raw.githubusercontent.com/openfaas/faasd/master/hack/install.sh | bash -s -
- systemctl status -l containerd --no-pager
- journalctl -u faasd-provider --no-pager
- systemctl status -l faasd-provider --no-pager
- systemctl status -l faasd --no-pager
- curl -sSLf https://cli.openfaas.com | sh
- sleep 60 && journalctl -u faasd --no-pager
- cat /var/lib/faasd/secrets/basic-auth-password | /usr/local/bin/faas-cli login --password-stdin
--- a/cmd/collect.go
+++ b/cmd/collect.go
@ -1,60 +0,0 @@
-package cmd
-
-import (
-	"bufio"
-	"context"
-	"fmt"
-	"io"
-	"sync"
-
-	"github.com/containerd/containerd/runtime/v2/logging"
-	"github.com/coreos/go-systemd/journal"
-	"github.com/spf13/cobra"
-)
-
-func CollectCommand() *cobra.Command {
-	return collectCmd
-}
-
-var collectCmd = &cobra.Command{
-	Use:   "collect",
-	Short: "Collect logs to the journal",
-	RunE:  runCollect,
-}
-
-func runCollect(_ *cobra.Command, _ []string) error {
-	logging.Run(logStdio)
-	return nil
-}
-
-// logStdio copied from
-// https://github.com/containerd/containerd/pull/3085
-// https://github.com/stellarproject/orbit
-func logStdio(ctx context.Context, config *logging.Config, ready func() error) error {
-	// construct any log metadata for the container
-	vars := map[string]string{
-		"SYSLOG_IDENTIFIER": fmt.Sprintf("%s:%s", config.Namespace, config.ID),
-	}
-	var wg sync.WaitGroup
-	wg.Add(2)
-	// forward both stdout and stderr to the journal
-	go copy(&wg, config.Stdout, journal.PriInfo, vars)
-	go copy(&wg, config.Stderr, journal.PriErr, vars)
-	// signal that we are ready and setup for the container to be started
-	if err := ready(); err != nil {
-		return err
-	}
-	wg.Wait()
-	return nil
-}
-
-func copy(wg *sync.WaitGroup, r io.Reader, pri journal.Priority, vars map[string]string) {
-	defer wg.Done()
-	s := bufio.NewScanner(r)
-	for s.Scan() {
-		if s.Err() != nil {
-			return
-		}
-		journal.Send(s.Text(), pri, vars)
-	}
-}
--- a/cmd/install.go
+++ b/cmd/install.go
@ -2,12 +2,10 @@ package cmd

 import (
 	"fmt"
-	"io"
 	"os"
 	"path"

-	systemd "github.com/openfaas/faasd/pkg/systemd"
-	"github.com/pkg/errors"
+	systemd "github.com/alexellis/faasd/pkg/systemd"

 	"github.com/spf13/cobra"
 )
@ -18,52 +16,29 @@ var installCmd = &cobra.Command{
 	RunE:  runInstall,
 }

-const workingDirectoryPermission = 0644
-
-const faasdwd = "/var/lib/faasd"
-
-const faasdProviderWd = "/var/lib/faasd-provider"
-
 func runInstall(_ *cobra.Command, _ []string) error {

-	if err := ensureWorkingDir(path.Join(faasdwd, "secrets")); err != nil {
-		return err
-	}
-
-	if err := ensureWorkingDir(faasdProviderWd); err != nil {
-		return err
-	}
-
-	if basicAuthErr := makeBasicAuthFiles(path.Join(faasdwd, "secrets")); basicAuthErr != nil {
-		return errors.Wrap(basicAuthErr, "cannot create basic-auth-* files")
-	}
-
-	if err := cp("docker-compose.yaml", faasdwd); err != nil {
-		return err
-	}
-
-	if err := cp("prometheus.yml", faasdwd); err != nil {
-		return err
-	}
-
-	if err := cp("resolv.conf", faasdwd); err != nil {
-		return err
-	}
-
-	err := binExists("/usr/local/bin/", "faasd")
+	err := binExists("/usr/local/bin/", "faas-containerd")
 	if err != nil {
 		return err
 	}

-	err = systemd.InstallUnit("faasd-provider", map[string]string{
-		"Cwd":             faasdProviderWd,
-		"SecretMountPath": path.Join(faasdwd, "secrets")})
-
+	err = binExists("/usr/local/bin/", "faasd")
 	if err != nil {
 		return err
 	}

-	err = systemd.InstallUnit("faasd", map[string]string{"Cwd": faasdwd})
+	err = binExists("/usr/local/bin/", "netns")
+	if err != nil {
+		return err
+	}
+
+	err = systemd.InstallUnit("faas-containerd")
+	if err != nil {
+		return err
+	}
+
+	err = systemd.InstallUnit("faasd")
 	if err != nil {
 		return err
 	}
@ -73,7 +48,7 @@ func runInstall(_ *cobra.Command, _ []string) error {
 		return err
 	}

-	err = systemd.Enable("faasd-provider")
+	err = systemd.Enable("faas-containerd")
 	if err != nil {
 		return err
 	}
@ -83,7 +58,7 @@ func runInstall(_ *cobra.Command, _ []string) error {
 		return err
 	}

-	err = systemd.Start("faasd-provider")
+	err = systemd.Start("faas-containerd")
 	if err != nil {
 		return err
 	}
@ -93,12 +68,6 @@ func runInstall(_ *cobra.Command, _ []string) error {
 		return err
 	}

-	fmt.Println(`Check status with:
-  sudo journalctl -u faasd --lines 100 -f
-
-Login with:
-  sudo cat /var/lib/faasd/secrets/basic-auth-password | faas-cli login -s`)
-
 	return nil
 }

@ -109,42 +78,3 @@ func binExists(folder, name string) error {
 	}
 	return nil
 }
-func ensureSecretsDir(folder string) error {
-	if _, err := os.Stat(folder); err != nil {
-		err = os.MkdirAll(folder, secretDirPermission)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-func ensureWorkingDir(folder string) error {
-	if _, err := os.Stat(folder); err != nil {
-		err = os.MkdirAll(folder, workingDirectoryPermission)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func cp(source, destFolder string) error {
-	file, err := os.Open(source)
-	if err != nil {
-		return err
-
-	}
-	defer file.Close()
-
-	out, err := os.Create(path.Join(destFolder, source))
-	if err != nil {
-		return err
-	}
-	defer out.Close()
-
-	_, err = io.Copy(out, file)
-
-	return err
-}
--- a/cmd/provider.go
+++ b/cmd/provider.go
@ -1,176 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"os"
-	"path"
-
-	"github.com/containerd/containerd"
-	bootstrap "github.com/openfaas/faas-provider"
-	"github.com/openfaas/faas-provider/logs"
-	"github.com/openfaas/faas-provider/proxy"
-	"github.com/openfaas/faas-provider/types"
-	faasd "github.com/openfaas/faasd/pkg"
-	"github.com/openfaas/faasd/pkg/cninetwork"
-	faasdlogs "github.com/openfaas/faasd/pkg/logs"
-	"github.com/openfaas/faasd/pkg/provider/config"
-	"github.com/openfaas/faasd/pkg/provider/handlers"
-	"github.com/spf13/cobra"
-)
-
-const secretDirPermission = 0755
-
-func makeProviderCmd() *cobra.Command {
-	var command = &cobra.Command{
-		Use:   "provider",
-		Short: "Run the faasd-provider",
-	}
-
-	command.Flags().String("pull-policy", "Always", `Set to "Always" to force a pull of images upon deployment, or "IfNotPresent" to try to use a cached image.`)
-
-	command.RunE = func(_ *cobra.Command, _ []string) error {
-
-		pullPolicy, flagErr := command.Flags().GetString("pull-policy")
-		if flagErr != nil {
-			return flagErr
-		}
-
-		alwaysPull := false
-		if pullPolicy == "Always" {
-			alwaysPull = true
-		}
-
-		config, providerConfig, err := config.ReadFromEnv(types.OsEnv{})
-		if err != nil {
-			return err
-		}
-
-		log.Printf("faasd-provider starting..\tService Timeout: %s\n", config.WriteTimeout.String())
-		printVersion()
-
-		wd, err := os.Getwd()
-		if err != nil {
-			return err
-		}
-
-		writeHostsErr := ioutil.WriteFile(path.Join(wd, "hosts"),
-			[]byte(`127.0.0.1	localhost`), workingDirectoryPermission)
-
-		if writeHostsErr != nil {
-			return fmt.Errorf("cannot write hosts file: %s", writeHostsErr)
-		}
-
-		writeResolvErr := ioutil.WriteFile(path.Join(wd, "resolv.conf"),
-			[]byte(`nameserver 8.8.8.8`), workingDirectoryPermission)
-
-		if writeResolvErr != nil {
-			return fmt.Errorf("cannot write resolv.conf file: %s", writeResolvErr)
-		}
-
-		cni, err := cninetwork.InitNetwork()
-		if err != nil {
-			return err
-		}
-
-		client, err := containerd.New(providerConfig.Sock)
-		if err != nil {
-			return err
-		}
-
-		defer client.Close()
-
-		invokeResolver := handlers.NewInvokeResolver(client)
-
-		baseUserSecretsPath := path.Join(wd, "secrets")
-		if err := moveSecretsToDefaultNamespaceSecrets(
-			baseUserSecretsPath,
-			faasd.DefaultFunctionNamespace); err != nil {
-			return err
-		}
-
-		bootstrapHandlers := types.FaaSHandlers{
-			FunctionProxy:        proxy.NewHandlerFunc(*config, invokeResolver),
-			DeleteHandler:        handlers.MakeDeleteHandler(client, cni),
-			DeployHandler:        handlers.MakeDeployHandler(client, cni, baseUserSecretsPath, alwaysPull),
-			FunctionReader:       handlers.MakeReadHandler(client),
-			ReplicaReader:        handlers.MakeReplicaReaderHandler(client),
-			ReplicaUpdater:       handlers.MakeReplicaUpdateHandler(client, cni),
-			UpdateHandler:        handlers.MakeUpdateHandler(client, cni, baseUserSecretsPath, alwaysPull),
-			HealthHandler:        func(w http.ResponseWriter, r *http.Request) {},
-			InfoHandler:          handlers.MakeInfoHandler(Version, GitCommit),
-			ListNamespaceHandler: handlers.MakeNamespacesLister(client),
-			SecretHandler:        handlers.MakeSecretHandler(client.NamespaceService(), baseUserSecretsPath),
-			LogHandler:           logs.NewLogHandlerFunc(faasdlogs.New(), config.ReadTimeout),
-		}
-
-		log.Printf("Listening on TCP port: %d\n", *config.TCPPort)
-		bootstrap.Serve(&bootstrapHandlers, config)
-		return nil
-	}
-
-	return command
-}
-
-/*
-* Mutiple namespace support was added after release 0.13.0
-* Function will help users to migrate on multiple namespace support of faasd
- */
-func moveSecretsToDefaultNamespaceSecrets(baseSecretPath string, defaultNamespace string) error {
-	newSecretPath := path.Join(baseSecretPath, defaultNamespace)
-
-	err := ensureSecretsDir(newSecretPath)
-	if err != nil {
-		return err
-	}
-
-	files, err := ioutil.ReadDir(baseSecretPath)
-	if err != nil {
-		return err
-	}
-
-	for _, f := range files {
-		if !f.IsDir() {
-
-			newPath := path.Join(newSecretPath, f.Name())
-
-			// A non-nil error means the file wasn't found in the
-			// destination path
-			if _, err := os.Stat(newPath); err != nil {
-				oldPath := path.Join(baseSecretPath, f.Name())
-
-				if err := copyFile(oldPath, newPath); err != nil {
-					return err
-				}
-
-				log.Printf("[Migration] Copied %s to %s", oldPath, newPath)
-			}
-		}
-	}
-
-	return nil
-}
-
-func copyFile(src, dst string) error {
-	inputFile, err := os.Open(src)
-	if err != nil {
-		return fmt.Errorf("opening %s failed %w", src, err)
-	}
-	defer inputFile.Close()
-
-	outputFile, err := os.OpenFile(dst, os.O_CREATE|os.O_WRONLY|os.O_APPEND, secretDirPermission)
-	if err != nil {
-		return fmt.Errorf("opening %s failed %w", dst, err)
-	}
-	defer outputFile.Close()
-
-	// Changed from os.Rename due to issue in #201
-	if _, err := io.Copy(outputFile, inputFile); err != nil {
-		return fmt.Errorf("writing into %s failed %w", outputFile.Name(), err)
-	}
-
-	return nil
-}
--- a/cmd/root.go
+++ b/cmd/root.go
@ -14,12 +14,6 @@ func init() {
 	rootCommand.AddCommand(versionCmd)
 	rootCommand.AddCommand(upCmd)
 	rootCommand.AddCommand(installCmd)
-	rootCommand.AddCommand(makeProviderCmd())
-	rootCommand.AddCommand(collectCmd)
-}
-
-func RootCommand() *cobra.Command {
-	return rootCommand
 }

 var (
@ -46,12 +40,7 @@ var rootCommand = &cobra.Command{
 	Use:   "faasd",
 	Short: "Start faasd",
 	Long: `
-faasd - Serverless For Everyone Else
-
-Learn how to build, secure, and monitor functions with faasd with 
-the eBook:
-
-https://gumroad.com/l/serverless-for-everyone-else
+faasd - serverless without Kubernetes
 `,
 	RunE:         runRootCommand,
 	SilenceUsage: true,
@ -74,11 +63,11 @@ var versionCmd = &cobra.Command{
 func parseBaseCommand(_ *cobra.Command, _ []string) {
 	printLogo()

-	printVersion()
-}
-
-func printVersion() {
-	fmt.Printf("faasd version: %s\tcommit: %s\n", GetVersion(), GitCommit)
+	fmt.Printf(
+		`faasd
+Commit: %s
+Version: %s
+`, GitCommit, GetVersion())
 }

 func printLogo() {
--- a/cmd/up.go
+++ b/cmd/up.go
@ -2,6 +2,7 @@ package cmd

 import (
 	"fmt"
+	"github.com/pkg/errors"
 	"io/ioutil"
 	"log"
 	"os"
@ -11,57 +12,45 @@ import (
 	"syscall"
 	"time"

-	"github.com/pkg/errors"
+	"github.com/alexellis/faasd/pkg"
+	"github.com/alexellis/k3sup/pkg/env"
 	"github.com/sethvargo/go-password/password"
 	"github.com/spf13/cobra"
-	flag "github.com/spf13/pflag"
-
-	units "github.com/docker/go-units"
-	"github.com/openfaas/faasd/pkg"
 )

-// upConfig are the CLI flags used by the `faasd up` command to deploy the faasd service
-type upConfig struct {
-	// composeFilePath is the path to the compose file specifying the faasd service configuration
-	// See https://compose-spec.io/ for more information about the spec,
-	//
-	// currently, this must be the name of a file in workingDir, which is set to the value of
-	// `faasdwd = /var/lib/faasd`
-	composeFilePath string
-
-	// working directory to assume the compose file is in, should be faasdwd.
-	// this is not configurable but may be in the future.
-	workingDir string
-}
-
-func init() {
-	configureUpFlags(upCmd.Flags())
-}
-
 var upCmd = &cobra.Command{
 	Use:   "up",
 	Short: "Start faasd",
 	RunE:  runUp,
 }

-func runUp(cmd *cobra.Command, _ []string) error {
+func runUp(_ *cobra.Command, _ []string) error {

-	printVersion()
+	clientArch, clientOS := env.GetClientArch()

-	cfg, err := parseUpFlags(cmd)
-	if err != nil {
-		return err
+	if clientOS != "Linux" {
+		return fmt.Errorf("You can only use faasd on Linux")
+	}
+	clientSuffix := ""
+	switch clientArch {
+	case "x86_64":
+		clientSuffix = ""
+		break
+	case "armhf":
+	case "armv7l":
+		clientSuffix = "-armhf"
+		break
+	case "arm64":
+	case "aarch64":
+		clientSuffix = "-arm64"
 	}

-	services, err := loadServiceDefinition(cfg)
-	if err != nil {
-		return err
+	authFileErr := errors.Wrap(makeBasicAuthFiles(), "Could not create gateway auth files")
+	if authFileErr != nil {
+		return authFileErr
 	}

-	basicAuthErr := makeBasicAuthFiles(path.Join(cfg.workingDir, "secrets"))
-	if basicAuthErr != nil {
-		return errors.Wrap(basicAuthErr, "cannot create basic-auth-* files")
-	}
+	services := makeServiceDefinitions(clientSuffix)

 	start := time.Now()
 	supervisor, err := pkg.NewSupervisor("/run/containerd/containerd.sock")
@ -69,15 +58,19 @@ func runUp(cmd *cobra.Command, _ []string) error {
 		return err
 	}

-	log.Printf("Supervisor created in: %s\n", units.HumanDuration(time.Since(start)))
+	log.Printf("Supervisor created in: %s\n", time.Since(start).String())

 	start = time.Now()
-	if err := supervisor.Start(services); err != nil {
+
+	err = supervisor.Start(services)
+
+	if err != nil {
 		return err
 	}
+
 	defer supervisor.Close()

-	log.Printf("Supervisor init done in: %s\n", units.HumanDuration(time.Since(start)))
+	log.Printf("Supervisor init done in: %s\n", time.Since(start).String())

 	shutdownTimeout := time.Second * 1
 	timeout := time.Second * 60
@ -96,47 +89,24 @@ func runUp(cmd *cobra.Command, _ []string) error {
 		if err != nil {
 			fmt.Println(err)
 		}
-
-		// TODO: close proxies
 		time.AfterFunc(shutdownTimeout, func() {
 			wg.Done()
 		})
 	}()

-	localResolver := pkg.NewLocalResolver(path.Join(cfg.workingDir, "hosts"))
-	go localResolver.Start()
-
-	proxies := map[uint32]*pkg.Proxy{}
-	for _, svc := range services {
-		for _, port := range svc.Ports {
-
-			listenPort := port.Port
-			if _, ok := proxies[listenPort]; ok {
-				return fmt.Errorf("port %d already allocated", listenPort)
-			}
-
-			hostIP := "0.0.0.0"
-			if len(port.HostIP) > 0 {
-				hostIP = port.HostIP
-			}
-
-			upstream := fmt.Sprintf("%s:%d", svc.Name, port.TargetPort)
-			proxies[listenPort] = pkg.NewProxy(upstream, listenPort, hostIP, timeout, localResolver)
-		}
-	}
-
-	// TODO: track proxies for later cancellation when receiving sigint/term
-	for _, v := range proxies {
-		go v.Start()
-	}
+	go func() {
+		wd, _ := os.Getwd()
+		proxy := pkg.NewProxy(path.Join(wd, "hosts"), timeout)
+		proxy.Start()
+	}()

 	wg.Wait()
 	return nil
 }

-func makeBasicAuthFiles(wd string) error {
-
-	pwdFile := path.Join(wd, "basic-auth-password")
+func makeBasicAuthFiles() error {
+	wd, _ := os.Getwd()
+	pwdFile := wd + "/basic-auth-password"
 	authPassword, err := password.Generate(63, 10, 0, false, true)

 	if err != nil {
@ -148,7 +118,7 @@ func makeBasicAuthFiles(wd string) error {
 		return err
 	}

-	userFile := path.Join(wd, "basic-auth-user")
+	userFile := wd + "/basic-auth-user"
 	err = makeFile(userFile, "admin")
 	if err != nil {
 		return err
@ -157,50 +127,119 @@ func makeBasicAuthFiles(wd string) error {
 	return nil
 }

-// makeFile will create a file with the specified content if it does not exist yet.
-// if the file already exists, the method is a noop.
 func makeFile(filePath, fileContents string) error {
 	_, err := os.Stat(filePath)
 	if err == nil {
-		log.Printf("File exists: %q\n", filePath)
+		log.Printf("File exists: %q, Using data from this file",filePath)
 		return nil
 	} else if os.IsNotExist(err) {
-		log.Printf("Writing to: %q\n", filePath)
-		return ioutil.WriteFile(filePath, []byte(fileContents), workingDirectoryPermission)
+		log.Printf("Writing file: %q", filePath)
+		return ioutil.WriteFile(filePath, []byte(fileContents), 0644)
 	} else {
 		return err
 	}
 }

-// load the docker compose file and then parse it as supervisor Services
-// the logic for loading the compose file comes from the compose reference implementation
-// https://github.com/compose-spec/compose-ref/blob/master/compose-ref.go#L353
-func loadServiceDefinition(cfg upConfig) ([]pkg.Service, error) {
+func makeServiceDefinitions(archSuffix string) []pkg.Service {
+	wd, _ := os.Getwd()

-	serviceConfig, err := pkg.LoadComposeFile(cfg.workingDir, cfg.composeFilePath)
-	if err != nil {
-		return nil, err
+	secretMountDir := "/run/secrets/"
+
+	return []pkg.Service{
+		pkg.Service{
+			Name:   "basic-auth-plugin",
+			Image:  "docker.io/openfaas/basic-auth-plugin:0.18.10" + archSuffix,
+			Env: []string{
+				"port=8080",
+				"secret_mount_path=" + secretMountDir,
+				"user_filename=basic-auth-user",
+				"pass_filename=basic-auth-password",
+			},
+			Mounts: []pkg.Mount{
+				pkg.Mount{
+					Src:path.Join(wd, "/basic-auth-password"),
+					Dest:secretMountDir + "basic-auth-password",
+				},
+				pkg.Mount{
+					Src:  path.Join(wd, "/basic-auth-user"),
+					Dest: secretMountDir + "basic-auth-user",
+				},
+			},
+			Caps: []string{"CAP_NET_RAW"},
+			Args:   nil,
+		},
+		pkg.Service{
+			Name:  "nats",
+			Env:   []string{""},
+			Image: "docker.io/library/nats-streaming:0.11.2",
+			Caps:  []string{},
+			Args:  []string{"/nats-streaming-server", "-m", "8222", "--store=memory", "--cluster_id=faas-cluster"},
+		},
+		pkg.Service{
+			Name:  "prometheus",
+			Env:   []string{},
+			Image: "docker.io/prom/prometheus:v2.14.0",
+			Mounts: []pkg.Mount{
+				pkg.Mount{
+					Src:  path.Join(wd, "prometheus.yml"),
+					Dest: "/etc/prometheus/prometheus.yml",
+				},
+			},
+			Caps: []string{"CAP_NET_RAW"},
+		},
+		pkg.Service{
+			Name: "gateway",
+			Env: []string{
+				"basic_auth=true",
+				"functions_provider_url=http://faas-containerd:8081/",
+				"direct_functions=false",
+				"read_timeout=60s",
+				"write_timeout=60s",
+				"upstream_timeout=65s",
+				"faas_nats_address=nats",
+				"faas_nats_port=4222",
+				"auth_proxy_url=http://basic-auth-plugin:8080/validate",
+				"auth_proxy_pass_body=false",
+				"secret_mount_path=" + secretMountDir,
+			},
+			Image:  "docker.io/openfaas/gateway:0.18.8" + archSuffix,
+			Mounts: []pkg.Mount{
+				pkg.Mount{
+					Src:path.Join(wd, "/basic-auth-password"),
+					Dest:secretMountDir + "basic-auth-password",
+				},
+				pkg.Mount{
+					Src:  path.Join(wd, "/basic-auth-user"),
+					Dest: secretMountDir + "basic-auth-user",
+				},
+			},
+			Caps:   []string{"CAP_NET_RAW"},
+		},
+		pkg.Service{
+			Name: "queue-worker",
+			Env: []string{
+				"faas_nats_address=nats",
+				"faas_nats_port=4222",
+				"gateway_invoke=true",
+				"faas_gateway_address=gateway",
+				"ack_wait=5m5s",
+				"max_inflight=1",
+				"write_debug=false",
+				"basic_auth=true",
+				"secret_mount_path=" + secretMountDir,
+			},
+			Image:  "docker.io/openfaas/queue-worker:0.9.0",
+			Mounts: []pkg.Mount{
+				pkg.Mount{
+					Src:path.Join(wd, "/basic-auth-password"),
+					Dest:secretMountDir + "basic-auth-password",
+				},
+				pkg.Mount{
+					Src:  path.Join(wd, "/basic-auth-user"),
+					Dest: secretMountDir + "basic-auth-user",
+				},
+			},
+			Caps:   []string{"CAP_NET_RAW"},
+		},
 	}
-
-	return pkg.ParseCompose(serviceConfig)
-}
-
-// ConfigureUpFlags will define the flags for the `faasd up` command. The flag struct, configure, and
-// parse are split like this to simplify testability.
-func configureUpFlags(flags *flag.FlagSet) {
-	flags.StringP("file", "f", "docker-compose.yaml", "compose file specifying the faasd service configuration")
-}
-
-// ParseUpFlags will load the flag values into an upFlags object. Errors will be underlying
-// Get errors from the pflag library.
-func parseUpFlags(cmd *cobra.Command) (upConfig, error) {
-	parsed := upConfig{}
-	path, err := cmd.Flags().GetString("file")
-	if err != nil {
-		return parsed, errors.Wrap(err, "can not parse compose file path flag")
-	}
-
-	parsed.composeFilePath = path
-	parsed.workingDir = faasdwd
-	return parsed, err
 }
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@ -1,114 +0,0 @@
-version: "3.7"
-services:
-  basic-auth-plugin:
-    image: ghcr.io/openfaas/basic-auth:0.21.4
-    environment:
-      - port=8080
-      - secret_mount_path=/run/secrets
-      - user_filename=basic-auth-user
-      - pass_filename=basic-auth-password
-    volumes:
-      # we assume cwd == /var/lib/faasd
-      - type: bind
-        source: ./secrets/basic-auth-password
-        target: /run/secrets/basic-auth-password
-      - type: bind
-        source: ./secrets/basic-auth-user
-        target: /run/secrets/basic-auth-user
-    cap_add:
-      - CAP_NET_RAW
-
-  nats:
-    image: docker.io/library/nats-streaming:0.22.0
-# nobody
-    user: "65534"
-    command:
-      - "/nats-streaming-server"
-      - "-m"
-      - "8222"
-      - "--store=file"
-      - "--dir=/nats"
-      - "--cluster_id=faas-cluster"
-    volumes:
-# Data directory
-      - type: bind
-        source: ./nats
-        target: /nats
-    # ports:
-    #    - "127.0.0.1:8222:8222"
-
-  prometheus:
-    image: docker.io/prom/prometheus:v2.14.0
-# nobody
-    user: "65534"
-    volumes:
-# Config directory
-      - type: bind
-        source: ./prometheus.yml
-        target: /etc/prometheus/prometheus.yml
-# Data directory
-      - type: bind
-        source: ./prometheus
-        target: /prometheus
-    cap_add:
-      - CAP_NET_RAW
-    ports:
-       - "127.0.0.1:9090:9090"
-
-  gateway:
-    image: ghcr.io/openfaas/gateway:0.22.0
-    environment:
-      - basic_auth=true
-      - functions_provider_url=http://faasd-provider:8081/
-      - direct_functions=false
-      - read_timeout=60s
-      - write_timeout=60s
-      - upstream_timeout=65s
-      - faas_nats_address=nats
-      - faas_nats_port=4222
-      - auth_proxy_url=http://basic-auth-plugin:8080/validate
-      - auth_proxy_pass_body=false
-      - secret_mount_path=/run/secrets
-      - scale_from_zero=true
-      - function_namespace=openfaas-fn
-    volumes:
-      # we assume cwd == /var/lib/faasd
-      - type: bind
-        source: ./secrets/basic-auth-password
-        target: /run/secrets/basic-auth-password
-      - type: bind
-        source: ./secrets/basic-auth-user
-        target: /run/secrets/basic-auth-user
-    cap_add:
-      - CAP_NET_RAW
-    depends_on:
-      - basic-auth-plugin
-      - nats
-      - prometheus
-    ports:
-       - "8080:8080"
-
-  queue-worker:
-    image: ghcr.io/openfaas/queue-worker:0.12.2
-    environment:
-      - faas_nats_address=nats
-      - faas_nats_port=4222
-      - gateway_invoke=true
-      - faas_gateway_address=gateway
-      - ack_wait=5m5s
-      - max_inflight=1
-      - write_debug=false
-      - basic_auth=true
-      - secret_mount_path=/run/secrets
-    volumes:
-      # we assume cwd == /var/lib/faasd
-      - type: bind
-        source: ./secrets/basic-auth-password
-        target: /run/secrets/basic-auth-password
-      - type: bind
-        source: ./secrets/basic-auth-user
-        target: /run/secrets/basic-auth-user
-    cap_add:
-      - CAP_NET_RAW
-    depends_on:
-      - nats
--- a/docs/DEV.md
+++ b/docs/DEV.md
@ -1,391 +0,0 @@
-## Instructions for building and testing faasd locally
-
-> Note: if you're just wanting to try out faasd, then it's likely that you're on the wrong page. This is a detailed set of instructions for those wanting to contribute or customise faasd. Feel free to go back to the homepage and pick a tutorial instead.
-
-Do you want to help the community test a pull request?
-
-See these instructions instead: [Testing patches](/docs/PATCHES.md)
-
-### Pre-reqs
-
-> It's recommended that you do not install Docker on the same host as faasd, since 1) they may both use different versions of containerd and 2) docker's networking rules can disrupt faasd's networking. When using faasd - make your faasd server a faasd server, and build container image on your laptop or in a CI pipeline.
-
-* Linux
-
-    PC / Cloud - any Linux that containerd works on should be fair game, but faasd is tested with Ubuntu 18.04
-
-    For Raspberry Pi Raspbian Stretch or newer also works fine
-
-    For MacOS users try [multipass.run](https://multipass.run) or [Vagrant](https://www.vagrantup.com/)
-
-    For Windows users, install [Git Bash](https://git-scm.com/downloads) along with multipass or vagrant. You can also use WSL1 or WSL2 which provides a Linux environment.
-
-    You will also need [containerd](https://github.com/containerd/containerd) and the [CNI plugins](https://github.com/containernetworking/plugins)
-
-    [faas-cli](https://github.com/openfaas/faas-cli) is optional, but recommended.
-
-If you're using multipass, then allocate sufficient resources:
-
-```bash
-multipass launch \
-  --mem 4G \
-  -c 2 \
-  -n faasd
-
-# Then access its shell
-multipass shell faasd
-```
-
-### Get runc
-
-```bash
-sudo apt update \
-  && sudo apt install -qy \
-    runc \
-    bridge-utils \
-    make
-```
-
-### Get faas-cli (optional)
-
-Having `faas-cli` on your dev machine is useful for testing and debug.
-
-```bash
-curl -sLS https://cli.openfaas.com | sudo sh
-```
-
-#### Install the CNI plugins:
-
-* For PC run `export ARCH=amd64`
-* For RPi/armhf run `export ARCH=arm`
-* For arm64 run `export ARCH=arm64`
-
-Then run:
-
-```bash
-export ARCH=amd64
-export CNI_VERSION=v0.9.1
-
-sudo mkdir -p /opt/cni/bin
-curl -sSL https://github.com/containernetworking/plugins/releases/download/${CNI_VERSION}/cni-plugins-linux-${ARCH}-${CNI_VERSION}.tgz | sudo tar -xz -C /opt/cni/bin
-
-# Make a config folder for CNI definitions
-sudo mkdir -p /etc/cni/net.d
-
-# Make an initial loopback configuration
-sudo sh -c 'cat >/etc/cni/net.d/99-loopback.conf <<-EOF
-{
-    "cniVersion": "0.3.1",
-    "type": "loopback"
-}
-EOF'
-```
-
-### Get containerd
-
-You have three options - binaries for PC, binaries for armhf, or build from source.
-
-* Install containerd `x86_64` only
-
-```bash
-export VER=1.6.4
-curl -sSL https://github.com/containerd/containerd/releases/download/v$VER/containerd-$VER-linux-amd64.tar.gz > /tmp/containerd.tar.gz \
-  && sudo tar -xvf /tmp/containerd.tar.gz -C /usr/local/bin/ --strip-components=1
-
-containerd -version
-```
-
-* Or get my containerd binaries for Raspberry Pi (armhf)
-
-    Building `containerd` on armhf is extremely slow, so I've provided binaries for you.
-
-    ```bash
-    curl -sSL https://github.com/alexellis/containerd-armhf/releases/download/v1.6.4/containerd.tgz | sudo tar -xvz --strip-components=2 -C /usr/local/bin/
-    ```
-
-* Or clone / build / install [containerd](https://github.com/containerd/containerd) from source:
-
-    ```bash
-    export GOPATH=$HOME/go/
-    mkdir -p $GOPATH/src/github.com/containerd
-    cd $GOPATH/src/github.com/containerd
-    git clone https://github.com/containerd/containerd
-    cd containerd
-    git fetch origin --tags
-    git checkout v1.6.4
-
-    make
-    sudo make install
-
-    containerd --version
-    ```
-
-#### Ensure containerd is running
-
-```bash
-curl -sLS https://raw.githubusercontent.com/containerd/containerd/v1.6.4/containerd.service > /tmp/containerd.service
-
-# Extend the timeouts for low-performance VMs
-echo "[Manager]" | tee -a /tmp/containerd.service
-echo "DefaultTimeoutStartSec=3m" | tee -a /tmp/containerd.service
-
-sudo cp /tmp/containerd.service /lib/systemd/system/
-sudo systemctl enable containerd
-
-sudo systemctl daemon-reload
-sudo systemctl restart containerd
-```
-
-Or run ad-hoc. This step can be useful for exploring why containerd might fail to start.
-
-```bash
-sudo containerd &
-```
-
-#### Enable forwarding
-
-> This is required to allow containers in containerd to access the Internet via your computer's primary network interface.
-
-```bash
-sudo /sbin/sysctl -w net.ipv4.conf.all.forwarding=1
-```
-
-Make the setting permanent:
-
-```bash
-echo "net.ipv4.conf.all.forwarding=1" | sudo tee -a /etc/sysctl.conf
-```
-
-### Hacking (build from source)
-
-#### Get build packages
-
-```bash
-sudo apt update \
-  && sudo apt install -qy \
-    runc \
-    bridge-utils \
-    make
-```
-
-You may find alternative package names for CentOS and other Linux distributions.
-
-#### Install Go 1.13 (x86_64)
-
-```bash
-curl -SLf https://golang.org/dl/go1.16.linux-amd64.tar.gz > /tmp/go.tgz
-sudo rm -rf /usr/local/go/
-sudo mkdir -p /usr/local/go/
-sudo tar -xvf /tmp/go.tgz -C /usr/local/go/ --strip-components=1
-
-export GOPATH=$HOME/go/
-export PATH=$PATH:/usr/local/go/bin/
-
-go version
-```
-
-You should also add the following to `~/.bash_profile`:
-
-```bash
-echo "export GOPATH=\$HOME/go/" | tee -a $HOME/.bash_profile
-echo "export PATH=\$PATH:/usr/local/go/bin/" | tee -a $HOME/.bash_profile
-```
-
-#### Or on Raspberry Pi (armhf)
-
-```bash
-curl -SLsf https://golang.org/dl/go1.16.linux-armv6l.tar.gz > go.tgz
-sudo rm -rf /usr/local/go/
-sudo mkdir -p /usr/local/go/
-sudo tar -xvf go.tgz -C /usr/local/go/ --strip-components=1
-
-export GOPATH=$HOME/go/
-export PATH=$PATH:/usr/local/go/bin/
-
-go version
-```
-
-#### Clone faasd and its systemd unit files
-
-```bash
-mkdir -p $GOPATH/src/github.com/openfaas/
-cd $GOPATH/src/github.com/openfaas/
-git clone https://github.com/openfaas/faasd
-```
-
-#### Build `faasd` from source (optional)
-
-```bash
-cd $GOPATH/src/github.com/openfaas/faasd
-cd faasd
-make local
-
-# Install the binary
-sudo cp bin/faasd /usr/local/bin
-```
-
-#### Or, download and run `faasd` (binaries)
-
-```bash
-# For x86_64
-export SUFFIX=""
-
-# armhf
-export SUFFIX="-armhf"
-
-# arm64
-export SUFFIX="-arm64"
-
-# Then download
-curl -fSLs "https://github.com/openfaas/faasd/releases/download/0.13.0/faasd$SUFFIX" \
-    -o "/tmp/faasd" \
-    && chmod +x "/tmp/faasd" 
-sudo mv /tmp/faasd /usr/local/bin/
-```
-
-#### Install `faasd`
-
-This step installs faasd as a systemd unit file, creates files in `/var/lib/faasd`, and writes out networking configuration for the CNI bridge networking plugin.
-
-```bash
-sudo faasd install
-
-2020/02/17 17:38:06 Writing to: "/var/lib/faasd/secrets/basic-auth-password"
-2020/02/17 17:38:06 Writing to: "/var/lib/faasd/secrets/basic-auth-user"
-Login with:
-  sudo cat /var/lib/faasd/secrets/basic-auth-password | faas-cli login -s
-```
-
-You can now log in either from this machine or a remote machine using the OpenFaaS UI, or CLI.
-
-Check that faasd is ready:
-
-```bash
-sudo journalctl -u faasd
-```
-
-You should see output like:
-
-```bash
-Feb 17 17:46:35 gold-survive faasd[4140]: 2020/02/17 17:46:35 Starting faasd proxy on 8080
-Feb 17 17:46:35 gold-survive faasd[4140]: Gateway: 10.62.0.5:8080
-Feb 17 17:46:35 gold-survive faasd[4140]: 2020/02/17 17:46:35 [proxy] Wait for done
-Feb 17 17:46:35 gold-survive faasd[4140]: 2020/02/17 17:46:35 [proxy] Begin listen on 8080
-```
-
-To get the CLI for the command above run:
-
-```bash
-curl -sSLf https://cli.openfaas.com | sudo sh
-```
-
-#### Make a change to `faasd`
-
-There are two components you can hack on:
-
-For function CRUD you will work on `faasd provider` which is started from `cmd/provider.go`
-
-For faasd itself, you will work on the code from `faasd up`, which is started from `cmd/up.go`
-
-Before working on either, stop the systemd services:
-
-```
-sudo systemctl stop faasd &    # up command
-sudo systemctl stop faasd-provider   # provider command
-```
-
-Here is a workflow you can use for each code change:
-
-Enter the directory of the source code, and build a new binary:
-
-```bash
-cd $GOPATH/src/github.com/openfaas/faasd
-go build
-```
-
-Copy that binary to `/usr/local/bin/`
-
-```bash
-cp faasd /usr/local/bin/
-```
-
-To run `faasd up`, run it from its working directory as root
-
-```bash
-sudo -i
-cd /var/lib/faasd
-
-faasd up
-```
-
-Now to run `faasd provider`, run it from its working directory:
-
-```bash
-sudo -i
-cd /var/lib/faasd-provider
-
-faasd provider
-```
-
-#### At run-time
-
-Look in `hosts` in the current working folder or in `/var/lib/faasd/` to get the IP for the gateway or Prometheus
-
-```bash
-127.0.0.1      localhost
-10.62.0.1      faasd-provider
-
-10.62.0.2      prometheus
-10.62.0.3      gateway
-10.62.0.4      nats
-10.62.0.5      queue-worker
-```
-
-The IP addresses are dynamic and may change on every launch.
-
-Since faasd-provider uses containerd heavily it is not running as a container, but as a stand-alone process. Its port is available via the bridge interface, i.e. `openfaas0`
-
-* Prometheus will run on the Prometheus IP plus port 8080 i.e. http://[prometheus_ip]:9090/targets
-
-* faasd-provider runs on 10.62.0.1:8081, i.e. directly on the host, and accessible via the bridge interface from CNI.
-
-* Now go to the gateway's IP address as shown above on port 8080, i.e. http://[gateway_ip]:8080 - you can also use this address to deploy OpenFaaS Functions via the `faas-cli`. 
-
-* basic-auth
-
-    You will then need to get the basic-auth password, it is written to `/var/lib/faasd/secrets/basic-auth-password` if you followed the above instructions.
-The default Basic Auth username is `admin`, which is written to `/var/lib/faasd/secrets/basic-auth-user`, if you wish to use a non-standard user then create this file and add your username (no newlines or other characters) 
-
-#### Installation with systemd
-
-* `faasd install` - install faasd and containerd with systemd, this must be run from `$GOPATH/src/github.com/openfaas/faasd`
-* `journalctl -u faasd -f` - faasd service logs
-* `journalctl -u faasd-provider -f` - faasd-provider service logs
-
-#### Uninstall
-
-* Stop faasd and faasd-provider
-```
-sudo systemctl stop faasd
-sudo systemctl stop faasd-provider
-sudo systemctl stop containerd
-```
-
-* Remove faasd from machine
-```
-sudo systemctl disable faasd
-sudo systemctl disable faasd-provider
-sudo systemctl disable containerd
-sudo rm -rf /usr/local/bin/faasd
-sudo rm -rf /var/lib/faasd
-sudo rm -rf /usr/lib/systemd/system/faasd-provider.service
-sudo rm -rf /usr/lib/systemd/system/faasd.service
-sudo rm -rf /usr/lib/systemd/system/containerd
-sudo systemctl daemon-reload
-```
-
-* Remove additional dependencies. Be cautious as other software will be dependent on these.
-```
-sudo apt-get remove runc bridge-utils
-sudo rm -rf /opt/cni/bin
-```
--- a/docs/MULTIPASS.md
+++ b/docs/MULTIPASS.md
@ -1,142 +0,0 @@
-# Tutorial - faasd with multipass
-
-## Get up and running with your own faasd installation on your Mac
-
-[multipass from Canonical](https://multipass.run) is like Docker Desktop, but for getting Ubuntu instead of a Docker daemon. It works on MacOS, Linux, and Windows with the same consistent UX. It's not fully open-source, and uses some proprietary add-ons / binaries, but is free to use.
-
-For Linux using Ubuntu, you can install the packages directly, or use `sudo snap install multipass --classic` and follow this tutorial. For Raspberry Pi, [see my tutorial here](https://blog.alexellis.io/faasd-for-lightweight-serverless/).
-
-John McCabe has also tested faasd on Windows with multipass, [see his tweet](https://twitter.com/mccabejohn/status/1221899154672308224).
-
-## Use-case:
-
-Try out [faasd](https://github.com/openfaas/faasd) in a single command using a cloud-config file to get a VM which has:
-
-* port 22 for administration and
-* port 8080 for the OpenFaaS REST API.
-
-![Example](https://pbs.twimg.com/media/EPNQz00W4AEwDxM?format=jpg&name=medium)
-
-The above screenshot is [from my tweet](https://twitter.com/alexellisuk/status/1221408788395298819/), feel free to comment there.
-
-It took me about 2-3 minutes to run through everything after installing multipass.
-
-## Let's start the tutorial
-
-* Get [multipass.run](https://multipass.run)
-
-* Get my cloud-config.txt file
-
-    ```sh
-    curl -sSLO https://raw.githubusercontent.com/openfaas/faasd/master/cloud-config.txt
-    ```
-
-* Boot the VM 
-
-    The `cloud-config.txt` contains an ssh key to allow your local machine to access the VM. However, this must be updated with your local ssh key. 
-    This command will update the key with your local public key value and start the VM.
-
-    ```sh
-    sed "s/ssh-rsa.*/$(cat $HOME/.ssh/id_*.pub)/" cloud-config.txt | multipass launch --name faasd --cloud-init -
-    ```
-
-    This can also be done manually, just replace the 2nd line of the `cloud-config.txt` with the coPntents of your public ssh key, usually either `~/.ssh/id_rsa.pub` or `~/.ssh/id_ed25519.pub`
-
-    ```
-    ssh_authorized_keys:
-      - ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC8Q/aUYUr3P1XKVucnO9mlWxOjJm+K01lHJR90MkHC9zbfTqlp8P7C3J26zKAuzHXOeF+VFxETRr6YedQKW9zp5oP7sN+F2gr/pO7GV3VmOqHMV7uKfyUQfq7H1aVzLfCcI7FwN2Zekv3yB7kj35pbsMa1Za58aF6oHRctZU6UWgXXbRxP+B04DoVU7jTstQ4GMoOCaqYhgPHyjEAS3DW0kkPW6HzsvJHkxvVcVlZ/wNJa1Ie/yGpzOzWIN0Ol0t2QT/RSWOhfzO1A2P0XbPuZ04NmriBonO9zR7T1fMNmmtTuK7WazKjQT3inmYRAqU6pe8wfX8WIWNV7OowUjUsv alex@alexr.local
-    ```
-
-* Get the VM's IP and connect with `ssh`
-
-    ```sh
-    multipass info faasd
-    Name:           faasd
-    State:          Running
-    IPv4:           192.168.64.14
-    Release:        Ubuntu 18.04.3 LTS
-    Image hash:     a720c34066dc (Ubuntu 18.04 LTS)
-    Load:           0.79 0.19 0.06
-    Disk usage:     1.1G out of 4.7G
-    Memory usage:   145.6M out of 985.7M
-    ```
-
-    Set the variable `IP`:
-
-    ```
-    export IP="192.168.64.14"
-    ```
-
-    You can also try to use `jq` to get the IP into a variable:
-
-    ```sh
-    export IP=$(multipass info faasd --format json| jq -r '.info.faasd.ipv4[0]')
-    ```
-
-    Connect to the IP listed:
-
-    ```sh
-    ssh ubuntu@$IP
-    ```
-
-    Log out once you know it works.
-
-* Let's capture the authentication password into a file for use with `faas-cli`
-
-    ```
-    ssh ubuntu@$IP "sudo cat /var/lib/faasd/secrets/basic-auth-password" > basic-auth-password
-    ```
-
-## Try faasd (OpenFaaS)
-
-* Login from your laptop (the host)
-
-    ```
-    export OPENFAAS_URL=http://$IP:8080
-    cat basic-auth-password | faas-cli login -s
-    ```
-
-* Deploy a function and invoke it
-
-    ```
-    faas-cli store deploy figlet --env write_timeout=1s
-    echo "faasd" | faas-cli invoke figlet
-
-    faas-cli describe figlet
-
-    # Run async
-    curl -i -d "faasd-async" $OPENFAAS_URL/async-function/figlet
-
-    # Run async with a callback
-
-    curl -i -d "faasd-async" -H "X-Callback-Url: http://some-request-bin.com/path" $OPENFAAS_URL/async-function/figlet
-    ```
-
-    You can also checkout the other store functions: `faas-cli store list`
-
-* Try the UI
-
-    Head over to the UI from your laptop and remember that your password is in the `basic-auth-password` file. The username is `admin`:
-
-    ```
-    echo http://$IP:8080
-    ```
-
-* Stop/start the instance
-
-    ```sh
-    multipass stop faasd
-    ```
-
-* Delete, if you want to:
-
-    ```
-    multipass delete --purge faasd
-    ```
-
-You now have a faasd appliance on your Mac. You can also use this cloud-init file with public cloud like AWS or DigitalOcean.
-
-* If you want a public IP for your faasd VM, then just head over to [inlets.dev](https://inlets.dev/)
-* Try my more complete walk-through / tutorial with Raspberry Pi, or run the same steps on your multipass VM, including how to develop your own functions and services - https://blog.alexellis.io/faasd-for-lightweight-serverless/
-* You might also like [Building containers without Docker](https://blog.alexellis.io/building-containers-without-docker/)
-* Star/fork [faasd](https://github.com/openfaas/faasd) on GitHub
--- a/docs/PATCHES.md
+++ b/docs/PATCHES.md
@ -1,88 +0,0 @@
-## Instructions for testing a patch for faasd
-
-### Launch a virtual machine
-
-You can use any kind of Linux virtual machine, Ubuntu 20.04 is recommended.
-
-Launch a cloud VM or use [Multipass](https://multipass.run), which is free to use an can be run locally. A Raspberry Pi 3 or 4 could also be used, but will need you to run `make dist` to cross compile a valid binary.
-
-### Copy over your SSH key
-
-Your SSH key will be used, so that you can copy a new faasd binary over to the host.
-
-```bash
-multipass launch \
-  --mem 4G \
-  -c 2 \
-  -n faasd
-
-# Then access its shell
-multipass shell faasd
-
-# Edit .ssh/authorized_keys
-
-# Add .ssh/id_rsa.pub from your host and save the file
-```
-
-### Install faasd on the VM
-
-You start off with the upstream version of faasd on the host, then add the new version over the top later on.
-
-```bash
-cd /tmp/
-git clone https://github.com/openfaas/faasd --depth=1
-cd faasd/hack
-./install.sh
-
-# Run the login command given to you at the end of the script
-```
-
-Get the multipass IP address:
-
-```bash
-export IP=$(multipass info faasd --format json| jq -r '.info.faasd.ipv4[0]')
-```
-
-### Build a new faasd binary with the patch
-
-Check out faasd on your local computer
-
-```bash
-git clone https://github.com/openfaas/faasd
-cd faasd
-
-gh pr checkout #PR_NUMBER_HERE
-
-GOOS=linux go build
-
-# You can also run "make dist" which is slower, but includes
-# a version and binaries for other platforms such as the Raspberry Pi
-```
-
-### Copy it over to the VM
-
-Now build a new faasd binary and copy it to the VM:
-
-```bash
-scp faasd ubuntu@$IP:~/
-```
-
-Now deploy the new version on the VM:
-
-```bash
-killall -9 faasd-linux; killall -9 faasd-linux ; mv ./faasd-linux /usr/local/bin/faasd
-```
-
-### Check it worked and test that patch
-
-Now run a command with `faas-cli` such as:
-
-* `faas-cli list`
-* `faas-cli version`
-
-See the testing instructions on the PR and run through those steps.
-
-Post your results on GitHub to assist the creator of the pull request.
-
-You can see how to get the logs for various components using the [eBook Serverless For Everyone Else](https://gumroad.com/l/serverless-for-everyone-else), or by consulting the [DEV.md](/docs/DEV.md) guide.
-
--- a/docs/README.md
+++ b/docs/README.md
@ -1,7 +0,0 @@
-# Documentation
-
- [Develop faasd](./DEV.md) - Instructions for building and testing faasd locally
- [Testing faasd](./PATCHES.md) - Instructions for testing a patch for faasd
- [Roadmap](./ROADMAP.md) - Overview of features, backlog and known issues
- [Run faasd with multipass](./MULTIPASS.md) - Tutorial on how to run faasd on a local multipass VM
- [Terraform modules](./TERRAFORM.md) - A collection of official and community provided terraform modules for faasd
--- a/docs/ROADMAP.md
+++ b/docs/ROADMAP.md
@ -1,118 +0,0 @@
-# faasd backlog and features
-
-## Supported operations
-
-* `faas login`
-* `faas up`
-* `faas list`
-* `faas describe`
-* `faas deploy --update=true --replace=false`
-* `faas invoke --async`
-* `faas invoke`
-* `faas rm`
-* `faas store list/deploy/inspect`
-* `faas version`
-* `faas namespace`
-* `faas secret`
-* `faas logs`
-* `faas auth` - supported for Basic Authentication and OpenFaaS PRO with OIDC and Single-sign On.
-
-Scale from and to zero is also supported. On a Dell XPS with a small, pre-pulled image unpausing an existing task took 0.19s and starting a task for a killed function took 0.39s. There may be further optimizations to be gained.
-
-## Constraints vs OpenFaaS on Kubernetes
-
-faasd suits certain use-cases as mentioned in the README file, for those who want a solution which can scale out horizontally with minimum effort, Kubernetes or K3s is a valid option.
-
-### One replica per function
-
-Functions only support one replica, so cannot scale horizontally, but can scale vertically.
-
-Workaround: deploy one uniquely named function per replica.
-
-### Scale from zero may give a non-200
-
-When scaling from zero there is no health check implemented, so the request may arrive before your HTTP server is ready to serve a request, and therefore give a non-200 code.
-
-Workaround: Do not scale to zero, or have your client retry HTTP calls.
-
-### No clustering is available
-
-No clustering is available in faasd, however you can still apply fault-tolerance and high availability techniques.
-
-Workaround: deploy multiple faasd instances and use a hardware or software load-balancer. Take regular VM/host snapshots or backups.
-
-### No rolling updates
-
-When running `faas-cli deploy`, your old function is removed before the new one is started. This may cause a small amount of downtime, depending on the timeouts and grace periods you set.
-
-Workaround: deploy uniquely named functions per version, and switch an Ingress or Reverse Proxy record to point at a new version once it is ready.
-
-## Known issues
-
-### Non 200 HTTP status from the gateway upon first use
-
-This issue appears to happen sporadically and only for some users.
-
-If you get a non 200 HTTP code from the gateway, or caddy after installing faasd, check the logs of faasd:
-
-```bash
-sudo journalctl -u faasd
-```
-
-If you see the following error:
-
-```
-unable to dial to 10.62.0.5:8080, error: dial tcp 10.62.0.5:8080: connect: no route to host
-```
-
-Restart the faasd service with:
-
-```bash
-sudo systemctl restart faasd
-```
-
-## Backlog
-
-Should have:
-
-* [ ] Offer a recommendation or implement a strategy for faasd replication/HA
-* [ ] Monitor and restart any of the core components at runtime if the container stops
-* [ ] Asynchronous function deletion instead of synchronous
-* [ ] Asynchronous function start-up instead of synchronous
-
-Nice to Have:
-
-* [ ] Terraform for AWS (in-progress)
-* [ ] Total memory limits - if a node has 1GB of RAM, don't allow more than 1000MB of RAM to be reserved via limits
-* [ ] Offer live rolling-updates, with zero downtime - requires moving to IDs vs. names for function containers
-* [ ] Multiple replicas per function
-
-### Completed
-
-* [x] Docs or examples on how to use the various event connectors (Yes in the eBook)
-* [x] Resolve core services from functions by populating/sharing `/etc/hosts` between `faasd` and `faasd-provider`
-* [x] Provide a cloud-init configuration for faasd bootstrap
-* [x] Configure core services from a docker-compose.yaml file
-* [x] Store and fetch logs from the journal
-* [x] Add support for using container images in third-party public registries
-* [x] Add support for using container images in private third-party registries
-* [x] Provide a cloud-config.txt file for automated deployments of `faasd`
-* [x] Inject / manage IPs between core components for service to service communication - i.e. so Prometheus can scrape the OpenFaaS gateway - done via `/etc/hosts` mount
-* [x] Add queue-worker and NATS
-* [x] Create faasd.service and faasd-provider.service
-* [x] Self-install / create systemd service via `faasd install`
-* [x] Restart containers upon restart of faasd
-* [x] Clear / remove containers and tasks with SIGTERM / SIGINT
-* [x] Determine armhf/arm64 containers to run for gateway
-* [x] Configure `basic_auth` to protect the OpenFaaS gateway and faasd-provider HTTP API
-* [x] Setup custom working directory for faasd `/var/lib/faasd/`
-* [x] Use CNI to create network namespaces and adapters
-* [x] Optionally expose core services from the docker-compose.yaml file, locally or to all adapters.
-* [x] ~~[containerd can't pull image from Github Docker Package Registry](https://github.com/containerd/containerd/issues/3291)~~ ghcr.io support
-* [x] Provide [simple Caddyfile example](https://blog.alexellis.io/https-inlets-local-endpoints/) in the README showing how to expose the faasd proxy on port 80/443 with TLS
-* [x] Annotation support
-* [x] Hard memory limits for functions
-* [x] Terraform for DigitalOcean
-* [x] [Store and retrieve annotations in function spec](https://github.com/openfaas/faasd/pull/86) - in progress
-* [x] An installer for faasd and dependencies - runc, containerd
-
--- a/docs/TERRAFORM.md
+++ b/docs/TERRAFORM.md
@ -1,14 +0,0 @@
-# Terraform Modules for faasd
-
-| Terraform Module | Author | Origin | Status |
-|-----------|--------|--------|--------|
-| [faasd on DigitalOcean](https://github.com/openfaas/faasd/tree/master/docs/bootstrap/digitalocean-terraform) | OpenFaaS | Official | Active |
-| [faasd on DigitalOcean](https://github.com/jsiebens/terraform-digitalocean-faasd) | Johan Siebens | Community | Active |
-| [faasd on Google Cloud Platform](https://github.com/jsiebens/terraform-google-faasd) | Johan Siebens | Community | Active |
-| [faasd on Microsoft Azure ](https://github.com/jsiebens/terraform-azurerm-faasd) | Johan Siebens | Community | Active |
-| [faasd on Equinix Metal](https://github.com/jsiebens/terraform-equinix-faasd) | Johan Siebens | Community | Active |
-| [faasd on Scaleway](https://github.com/jsiebens/terraform-scaleway-faasd) | Johan Siebens | Community | Active |
-| [faasd on Amazon Web Services](https://github.com/jsiebens/terraform-aws-faasd) |Johan Siebens | Community | Active |
-| [faasd on Linode](https://github.com/itTrident/terraform-linode-faasd) | itTrident | Community | Active |
-| [faasd on Vultr](https://github.com/itTrident/terraform-vultr-faasd) | itTrident | Community | Active |
-| [faasd on Exoscale](https://github.com/itTrident/terraform-exoscale-faasd) | itTrident | Community | Active |
--- a/docs/bootstrap/cloud-config.tpl
+++ b/docs/bootstrap/cloud-config.tpl
@ -1,27 +0,0 @@
-#cloud-config
-package_update: true
-
-packages:
- - runc
- - git
-
-runcmd:
- curl -sLSf https://github.com/containerd/containerd/releases/download/v1.6.4/containerd-1.6.4-linux-amd64.tar.gz > /tmp/containerd.tar.gz && tar -xvf /tmp/containerd.tar.gz -C /usr/local/bin/ --strip-components=1
- curl -SLfs https://raw.githubusercontent.com/containerd/containerd/v1.6.4/containerd.service | tee /etc/systemd/system/containerd.service
- systemctl daemon-reload && systemctl start containerd
- /sbin/sysctl -w net.ipv4.conf.all.forwarding=1
- mkdir -p /opt/cni/bin
- curl -sSL https://github.com/containernetworking/plugins/releases/download/v0.9.1/cni-plugins-linux-amd64-v0.9.1.tgz | tar -xz -C /opt/cni/bin
- mkdir -p /go/src/github.com/openfaas/
- mkdir -p /var/lib/faasd/secrets/
- echo ${gw_password} > /var/lib/faasd/secrets/basic-auth-password
- echo admin > /var/lib/faasd/secrets/basic-auth-user
- cd /go/src/github.com/openfaas/ && git clone --depth 1 --branch 0.13.0 https://github.com/openfaas/faasd
- curl -fSLs "https://github.com/openfaas/faasd/releases/download/0.13.0/faasd" --output "/usr/local/bin/faasd" && chmod a+x "/usr/local/bin/faasd"
- cd /go/src/github.com/openfaas/faasd/ && /usr/local/bin/faasd install
- systemctl status -l containerd --no-pager
- journalctl -u faasd-provider --no-pager
- systemctl status -l faasd-provider --no-pager
- systemctl status -l faasd --no-pager
- curl -sSLf https://cli.openfaas.com | sh
- sleep 5 && journalctl -u faasd --no-pager
--- a/docs/bootstrap/digitalocean-terraform/.gitignore
+++ b/docs/bootstrap/digitalocean-terraform/.gitignore
@ -1,3 +0,0 @@
-/.terraform/
-/terraform.tfstate
-/terraform.tfstate.backup
--- a/docs/bootstrap/digitalocean-terraform/.terraform.lock.hcl
+++ b/docs/bootstrap/digitalocean-terraform/.terraform.lock.hcl
@ -1,66 +0,0 @@
-# This file is maintained automatically by "terraform init".
-# Manual edits may be lost in future updates.
-
-provider "registry.terraform.io/digitalocean/digitalocean" {
-  version     = "2.11.0"
-  constraints = "2.11.0"
-  hashes = [
-    "h1:/qAnTOSP5KeZkF7wqLai34SKAs7aefulcUA3I8R7rRg=",
-    "h1:PbXtjUfvxwmkycJ0Y9Dyn66Arrpk5L8/P381SXMx2O0=",
-    "h1:lXLX9tmuxV7azTHd0xB0FAVrxyfBtotIz5LEJp8YUk0=",
-    "zh:2191adc79bdfdb3b733e0619e4f391ae91c1631c5dafda42dab561d943651fa4",
-    "zh:21a4f67e42dcdc10fbd7f8579247594844d09a469a3a54862d565913e4d6121d",
-    "zh:557d98325fafcf2db91ea6d92f65373a48c4e995a1a7aeb57009661fee675250",
-    "zh:68c0238cafc37433627e288fcd2c7e14f4f0afdd50b4f265d8d1f1addab6f19f",
-    "zh:7e6d69720734455eb1c69880f049650276089b7fa09085e130d224abaeec887a",
-    "zh:95bd93a696ec050c1cb5e724498fd12b1d69760d01e97c869be3252025691434",
-    "zh:b1b075049e33aa08c032f41a497351c9894f16287a4449032d8b805bc6dcb596",
-    "zh:ba91aa853372c828f808c09dbab2a5bc9493a7cf93210d1487f9637b2cac8ca4",
-    "zh:bc43d27dfe014266697c2ac259f4311300391aa6aa7c5d23e382fe296df938d5",
-    "zh:d3a04d2c76bfc1f46a117b1af7870a97353319ee8f924a37fe77861519f59525",
-    "zh:d3da997c05a653df6cabb912c6c05ceb6bf77219b699f04daf44fd795c81c6ed",
-    "zh:edd0659021b6634acf0f581d1be1985a81fcd1182e3ccb43de6eac6c43be9ab4",
-    "zh:f588ace57b6c35d509ecaa7136e6a8049d227b0674104a1f958359b84862d8e3",
-    "zh:f894ed195a3b9ebbfa1ba7c5d71be06df3a96d783ff064d22dd693ace34d638e",
-    "zh:fb6b0d4b111fafdcb3bb9a7dbab88e2110a6ce6324de64ecf62933ee8b651ccf",
-  ]
-}
-
-provider "registry.terraform.io/hashicorp/random" {
-  version = "3.1.0"
-  hashes = [
-    "h1:BZMEPucF+pbu9gsPk0G0BHx7YP04+tKdq2MrRDF1EDM=",
-    "h1:EPIax4Ftp2SNdB9pUfoSjxoueDoLc/Ck3EUoeX0Dvsg=",
-    "h1:rKYu5ZUbXwrLG1w81k7H3nce/Ys6yAxXhWcbtk36HjY=",
-    "zh:2bbb3339f0643b5daa07480ef4397bd23a79963cc364cdfbb4e86354cb7725bc",
-    "zh:3cd456047805bf639fbf2c761b1848880ea703a054f76db51852008b11008626",
-    "zh:4f251b0eda5bb5e3dc26ea4400dba200018213654b69b4a5f96abee815b4f5ff",
-    "zh:7011332745ea061e517fe1319bd6c75054a314155cb2c1199a5b01fe1889a7e2",
-    "zh:738ed82858317ccc246691c8b85995bc125ac3b4143043219bd0437adc56c992",
-    "zh:7dbe52fac7bb21227acd7529b487511c91f4107db9cc4414f50d04ffc3cab427",
-    "zh:a3a9251fb15f93e4cfc1789800fc2d7414bbc18944ad4c5c98f466e6477c42bc",
-    "zh:a543ec1a3a8c20635cf374110bd2f87c07374cf2c50617eee2c669b3ceeeaa9f",
-    "zh:d9ab41d556a48bd7059f0810cf020500635bfc696c9fc3adab5ea8915c1d886b",
-    "zh:d9e13427a7d011dbd654e591b0337e6074eef8c3b9bb11b2e39eaaf257044fd7",
-    "zh:f7605bd1437752114baf601bdf6931debe6dc6bfe3006eb7e9bb9080931dca8a",
-  ]
-}
-
-provider "registry.terraform.io/hashicorp/template" {
-  version = "2.2.0"
-  hashes = [
-    "h1:0wlehNaxBX7GJQnPfQwTNvvAf38Jm0Nv7ssKGMaG6Og=",
-    "h1:94qn780bi1qjrbC3uQtjJh3Wkfwd5+tTtJHOb7KTg9w=",
-    "h1:LN84cu+BZpVRvYlCzrbPfCRDaIelSyEx/W9Iwwgbnn4=",
-    "zh:01702196f0a0492ec07917db7aaa595843d8f171dc195f4c988d2ffca2a06386",
-    "zh:09aae3da826ba3d7df69efeb25d146a1de0d03e951d35019a0f80e4f58c89b53",
-    "zh:09ba83c0625b6fe0a954da6fbd0c355ac0b7f07f86c91a2a97849140fea49603",
-    "zh:0e3a6c8e16f17f19010accd0844187d524580d9fdb0731f675ffcf4afba03d16",
-    "zh:45f2c594b6f2f34ea663704cc72048b212fe7d16fb4cfd959365fa997228a776",
-    "zh:77ea3e5a0446784d77114b5e851c970a3dde1e08fa6de38210b8385d7605d451",
-    "zh:8a154388f3708e3df5a69122a23bdfaf760a523788a5081976b3d5616f7d30ae",
-    "zh:992843002f2db5a11e626b3fc23dc0c87ad3729b3b3cff08e32ffb3df97edbde",
-    "zh:ad906f4cebd3ec5e43d5cd6dc8f4c5c9cc3b33d2243c89c5fc18f97f7277b51d",
-    "zh:c979425ddb256511137ecd093e23283234da0154b7fa8b21c2687182d9aea8b2",
-  ]
-}
--- a/docs/bootstrap/digitalocean-terraform/README.md
+++ b/docs/bootstrap/digitalocean-terraform/README.md
@ -1,48 +0,0 @@
-# Bootstrap faasd with TLS support on Digitalocean
-
-1) [Sign up to DigitalOcean](https://www.digitalocean.com/?refcode=2962aa9e56a1&utm_campaign=Referral_Invite&utm_medium=Referral_Program&utm_source=CopyPaste)
-2) [Download Terraform](https://www.terraform.io)
-3) Clone this gist using the URL from the address bar
-4) Run `terraform init`
-5) Configure terraform variables as needed by updating the `main.tfvars` file:
-
-   | Variable     | Description         | Default         |
-   | ------------ | ------------------- | --------------- |
-   | `do_token` | Digitalocean API token | None |
-   | `do_domain` | Public domain used for the faasd gateway | None |
-   | `do_subdomain` | Public subdomain used for the faasd gateway | `faasd` |
-   | `letsencrypt_email` | Email used by when ordering TLS certificate from Letsencrypt | `""` |
-   | `do_create_record` | When set to `true`, a new DNS record will be created. This works only if your domain (`do_domain`) is managed by Digitalocean | `false` |
-   | `do_region` | Digitalocean region for creating the droplet | `fra1` |
-   | `ssh_key_file` | Path to public SSH key file |`~/.ssh/id_rsa.pub` |
-
-> Environment variables can also be used to set terraform variables when running the `terraform apply` command using the format `TF_VAR_name`.
-
-6) Run `terraform apply`
-   1) Add `-var-file=main.tfvars` if you have set the variables in `main.tfvars`.
-   2) OR [use environment variables](https://www.terraform.io/docs/commands/environment-variables.html#tf_var_name) for setting the terraform variables when running the `apply` command
-
-7) View the output for the login command and gateway URL i.e.
-
-```
-droplet_ip = 178.128.39.201
-gateway_url = https://faasd.example.com/
-```
-
-8) View the output for sensitive data via `terraform output` command
-
-```bash
-terraform output login_cmd
-login_cmd = faas-cli login -g http://178.128.39.201:8080/ -p rvIU49CEcFcHmqxj
-
-terraform output password
-password = rvIU49CEcFcHmqxj
-```
-
-
-9) Use your browser to access the OpenFaaS interface
-
-Note that the user-data may take a couple of minutes to come up since it will be pulling in various components and preparing the machine. 
-Also take into consideration the DNS propagation time for the new DNS record.
-
-A single host with 1GB of RAM will be deployed for you, to remove at a later date simply use `terraform destroy`.
--- a/docs/bootstrap/digitalocean-terraform/cloud-config.tpl
+++ b/docs/bootstrap/digitalocean-terraform/cloud-config.tpl
@ -1,9 +0,0 @@
-#! /bin/bash
-
-mkdir -p /var/lib/faasd/secrets/
-echo ${gw_password} > /var/lib/faasd/secrets/basic-auth-password
-
-export FAASD_DOMAIN=${faasd_domain_name}
-export LETSENCRYPT_EMAIL=${letsencrypt_email}
-
-curl -sfL https://raw.githubusercontent.com/openfaas/faasd/master/hack/install.sh | bash -s -
--- a/docs/bootstrap/digitalocean-terraform/main.tf
+++ b/docs/bootstrap/digitalocean-terraform/main.tf
@ -1,97 +0,0 @@
-terraform {
-  required_version = ">= 1.0.4"
-  required_providers {
-    digitalocean = {
-      source  = "digitalocean/digitalocean"
-      version = "2.11.0"
-    }
-  }
-}
-
-variable "do_token" {
-  description = "Digitalocean API token"
-}
-variable "do_domain" {
-  description = "Your public domain"
-}
-variable "do_subdomain" {
-  description = "Your public subdomain"
-  default     = "faasd"
-}
-variable "letsencrypt_email" {
-  description = "Email used to order a certificate from Letsencrypt"
-}
-variable "do_create_record" {
-  default     = false
-  description = "Whether to create a DNS record on Digitalocean"
-}
-variable "do_region" {
-  default     = "fra1"
-  description = "The Digitalocean region where the faasd droplet will be created."
-}
-variable "ssh_key_file" {
-  default     = "~/.ssh/id_rsa.pub"
-  description = "Path to the SSH public key file"
-}
-
-provider "digitalocean" {
-  token = var.do_token
-}
-
-resource "random_password" "password" {
-  length           = 16
-  special          = true
-  override_special = "_-#"
-}
-
-data "template_file" "cloud_init" {
-  template = file("cloud-config.tpl")
-  vars = {
-    gw_password       = random_password.password.result,
-    faasd_domain_name = "${var.do_subdomain}.${var.do_domain}"
-    letsencrypt_email = var.letsencrypt_email
-  }
-}
-
-resource "digitalocean_ssh_key" "faasd_ssh_key" {
-  name       = "ssh-key"
-  public_key = file(var.ssh_key_file)
-}
-
-resource "digitalocean_droplet" "faasd" {
-  region    = var.do_region
-  image     = "ubuntu-18-04-x64"
-  name      = "faasd"
-  size      = "s-1vcpu-1gb"
-  user_data = data.template_file.cloud_init.rendered
-  ssh_keys = [
-    digitalocean_ssh_key.faasd_ssh_key.id
-  ]
-}
-
-resource "digitalocean_record" "faasd" {
-  domain = var.do_domain
-  type   = "A"
-  name   = var.do_subdomain
-  value  = digitalocean_droplet.faasd.ipv4_address
-  # Only creates record if do_create_record is true
-  count = var.do_create_record == true ? 1 : 0
-}
-
-output "droplet_ip" {
-  value = digitalocean_droplet.faasd.ipv4_address
-}
-
-output "gateway_url" {
-  value = "https://${var.do_subdomain}.${var.do_domain}/"
-}
-
-output "password" {
-  value     = random_password.password.result
-  sensitive = true
-}
-
-output "login_cmd" {
-  value     = "faas-cli login -g https://${var.do_subdomain}.${var.do_domain}/ -p ${random_password.password.result}"
-  sensitive = true
-}
--- a/docs/bootstrap/digitalocean-terraform/main.tfvars
+++ b/docs/bootstrap/digitalocean-terraform/main.tfvars
@ -1,4 +0,0 @@
-do_token          = ""
-do_domain         = ""
-do_subdomain      = ""
-letsencrypt_email = ""
--- a/docs/media/logo.pdf
+++ b/docs/media/logo.pdf
--- a/docs/media/social.png
+++ b/docs/media/social.png
--- a/go.mod
+++ b/go.mod
@ -1,80 +0,0 @@
-module github.com/openfaas/faasd
-
-go 1.18
-
-require (
-	github.com/alexellis/go-execute v0.5.0
-	github.com/alexellis/k3sup v0.0.0-20220105194923-e2bb18116d36
-	github.com/compose-spec/compose-go v0.0.0-20200528042322-36d8ce368e05
-	github.com/containerd/containerd v1.6.4
-	github.com/containerd/go-cni v1.1.5
-	github.com/coreos/go-systemd v0.0.0-20191104093116-d3cd4ed1dbcf
-	github.com/docker/cli v0.0.0-20191105005515-99c5edceb48d
-	github.com/docker/distribution v2.8.1+incompatible
-	github.com/docker/docker v17.12.0-ce-rc1.0.20191113042239-ea84732a7725+incompatible // indirect
-	github.com/docker/docker-credential-helpers v0.6.3 // indirect
-	github.com/docker/go-units v0.4.0
-	github.com/gorilla/mux v1.8.0
-	github.com/morikuni/aec v1.0.0
-	github.com/opencontainers/runtime-spec v1.0.3-0.20210326190908-1c3f411f0417
-	github.com/openfaas/faas-provider v0.19.0
-	github.com/openfaas/faas/gateway v0.0.0-20220509091830-4e868f5f9d81
-	github.com/pkg/errors v0.9.1
-	github.com/sethvargo/go-password v0.2.0
-	github.com/spf13/cobra v1.4.0
-	github.com/spf13/pflag v1.0.5
-	github.com/vishvananda/netlink v1.1.1-0.20210330154013-f5de75959ad5
-	github.com/vishvananda/netns v0.0.0-20210104183010-2eb08e3e575f
-	golang.org/x/sys v0.0.0-20220702020025-31831981b65f
-	k8s.io/apimachinery v0.24.0
-)
-
-require (
-	github.com/Microsoft/go-winio v0.5.1 // indirect
-	github.com/Microsoft/hcsshim v0.9.2 // indirect
-	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/cespare/xxhash/v2 v2.1.2 // indirect
-	github.com/containerd/cgroups v1.0.3 // indirect
-	github.com/containerd/continuity v0.2.2 // indirect
-	github.com/containerd/fifo v1.0.0 // indirect
-	github.com/containerd/ttrpc v1.1.0 // indirect
-	github.com/containerd/typeurl v1.0.2 // indirect
-	github.com/containernetworking/cni v1.1.0 // indirect
-	github.com/docker/go-connections v0.4.0 // indirect
-	github.com/docker/go-events v0.0.0-20190806004212-e31b211e4f1c // indirect
-	github.com/gogo/googleapis v1.4.0 // indirect
-	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
-	github.com/golang/protobuf v1.5.2 // indirect
-	github.com/google/uuid v1.2.0 // indirect
-	github.com/imdario/mergo v0.3.12 // indirect
-	github.com/inconshreveable/mousetrap v1.0.0 // indirect
-	github.com/klauspost/compress v1.11.13 // indirect
-	github.com/mattn/go-shellwords v1.0.10 // indirect
-	github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 // indirect
-	github.com/mitchellh/mapstructure v1.4.1 // indirect
-	github.com/moby/locker v1.0.1 // indirect
-	github.com/moby/sys/mountinfo v0.5.0 // indirect
-	github.com/moby/sys/signal v0.6.0 // indirect
-	github.com/opencontainers/go-digest v1.0.0 // indirect
-	github.com/opencontainers/image-spec v1.0.3-0.20211202183452-c5a74bcca799 // indirect
-	github.com/opencontainers/runc v1.1.1 // indirect
-	github.com/opencontainers/selinux v1.10.1 // indirect
-	github.com/prometheus/client_golang v1.12.2 // indirect
-	github.com/prometheus/client_model v0.2.0 // indirect
-	github.com/prometheus/common v0.35.0 // indirect
-	github.com/prometheus/procfs v0.7.3 // indirect
-	github.com/sirupsen/logrus v1.8.1 // indirect
-	github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb // indirect
-	github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect
-	github.com/xeipuuv/gojsonschema v1.2.0 // indirect
-	go.opencensus.io v0.23.0 // indirect
-	golang.org/x/net v0.0.0-20220225172249-27dd8689420f // indirect
-	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c // indirect
-	golang.org/x/text v0.3.7 // indirect
-	google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa // indirect
-	google.golang.org/grpc v1.43.0 // indirect
-	google.golang.org/protobuf v1.28.0 // indirect
-	gopkg.in/inf.v0 v0.9.1 // indirect
-	gopkg.in/yaml.v2 v2.4.0 // indirect
-)
--- a/go.sum
+++ b/go.sum
--- a/hack/build-containerd-arm64.sh
+++ b/hack/build-containerd-arm64.sh
@ -1,37 +0,0 @@
-#!/bin/bash
-
-# See pre-reqs:
-# https://github.com/alexellis/containerd-arm
-
-export ARCH="arm64"
-
-if [ ! -d "/usr/local/go/bin" ]; then
-    echo "Downloading Go.."
-    
-    curl -SLsf https://golang.org/dl/go1.16.6.linux-$ARCH.tar.gz --output /tmp/go.tgz
-    sudo rm -rf /usr/local/go/
-    sudo mkdir -p /usr/local/go/
-    sudo tar -xvf /tmp/go.tgz -C /usr/local/go/ --strip-components=1
-else
-    echo "Go already present, skipping."
-fi
-
-export GOPATH=$HOME/go/
-export PATH=$PATH:/usr/local/go/bin/
-
-go version
-
-echo "Building containerd"
-
-mkdir -p $GOPATH/src/github.com/containerd
-cd $GOPATH/src/github.com/containerd
-git clone https://github.com/containerd/containerd
-
-cd containerd
-git fetch origin --tags
-git checkout v1.6.4
-
-make
-sudo make install
-
-sudo containerd --version
--- a/hack/build-containerd-armhf.sh
+++ b/hack/build-containerd-armhf.sh
@ -1,20 +1,12 @@
 #!/bin/bash

-# See pre-reqs:
-# https://github.com/alexellis/containerd-arm
+export ARCH="armv6l"
+echo "Downloading Go"

-export ARCH="arm64"
-
-if [ ! -d "/usr/local/go/bin" ]; then
-    echo "Downloading Go.."
-    
-    curl -SLsf https://golang.org/dl/go1.16.6.linux-$ARCH.tar.gz --output /tmp/go.tgz
-    sudo rm -rf /usr/local/go/
-    sudo mkdir -p /usr/local/go/
-    sudo tar -xvf /tmp/go.tgz -C /usr/local/go/ --strip-components=1
-else
-    echo "Go already present, skipping."
-fi
+curl -SLsf https://dl.google.com/go/go1.12.14.linux-$ARCH.tar.gz --output /tmp/go.tgz
+sudo rm -rf /usr/local/go/
+sudo mkdir -p /usr/local/go/
+sudo tar -xvf /tmp/go.tgz -C /usr/local/go/ --strip-components=1

 export GOPATH=$HOME/go/
 export PATH=$PATH:/usr/local/go/bin/
@ -29,7 +21,7 @@ git clone https://github.com/containerd/containerd

 cd containerd
 git fetch origin --tags
-git checkout v1.6.4
+git checkout v1.3.2

 make
 sudo make install
--- a/hack/build-containerd.sh
+++ b/hack/build-containerd.sh
@ -1,21 +1,12 @@
 #!/bin/bash

+export ARCH="amd64"
+echo "Downloading Go"

-# See pre-reqs:
-# https://github.com/alexellis/containerd-arm
-
-export ARCH="arm64"
-
-if [ ! -d "/usr/local/go/bin" ]; then
-    echo "Downloading Go.."
-    
-    curl -SLsf https://golang.org/dl/go1.16.6.linux-$ARCH.tar.gz --output /tmp/go.tgz
-    sudo rm -rf /usr/local/go/
-    sudo mkdir -p /usr/local/go/
-    sudo tar -xvf /tmp/go.tgz -C /usr/local/go/ --strip-components=1
-else
-    echo "Go already present, skipping."
-fi
+curl -SLsf https://dl.google.com/go/go1.12.14.linux-$ARCH.tar.gz --output /tmp/go.tgz
+sudo rm -rf /usr/local/go/
+sudo mkdir -p /usr/local/go/
+sudo tar -xvf /tmp/go.tgz -C /usr/local/go/ --strip-components=1

 export GOPATH=$HOME/go/
 export PATH=$PATH:/usr/local/go/bin/
@ -30,7 +21,7 @@ git clone https://github.com/containerd/containerd

 cd containerd
 git fetch origin --tags
-git checkout v1.6.4
+git checkout v1.3.2

 make
 sudo make install
--- a/hack/faas-containerd.service
+++ b/hack/faas-containerd.service
@ -0,0 +1,12 @@
+[Unit]
+Description=faasd-containerd
+
+[Service]
+MemoryLimit=500M
+ExecStart=/usr/local/bin/faas-containerd
+Restart=on-failure
+RestartSec=10s
+WorkingDirectory=/usr/local/bin/
+
+[Install]
+WantedBy=multi-user.target
--- a/hack/faasd-provider.service
+++ b/hack/faasd-provider.service
@ -1,15 +0,0 @@
-[Unit]
-Description=faasd-provider
-
-[Service]
-MemoryLimit=500M
-Environment="secret_mount_path={{.SecretMountPath}}"
-Environment="basic_auth=true"
-Environment="hosts_dir=/var/lib/faasd"
-ExecStart=/usr/local/bin/faasd provider
-Restart=on-failure
-RestartSec=10s
-WorkingDirectory={{.Cwd}}
-
-[Install]
-WantedBy=multi-user.target
--- a/hack/faasd.service
+++ b/hack/faasd.service
@ -1,6 +1,6 @@
 [Unit]
 Description=faasd
-After=faasd-provider.service
+After=faas-containerd.service

 [Service]
 MemoryLimit=500M
--- a/hack/install.sh
+++ b/hack/install.sh
@ -1,177 +0,0 @@
-#!/bin/bash
-
-# Copyright OpenFaaS Author(s) 2022
-
-set -e -x -o pipefail
-
-export OWNER="openfaas"
-export REPO="faasd"
-
-# On CentOS /usr/local/bin is not included in the PATH when using sudo. 
-# Running arkade with sudo on CentOS requires the full path
-# to the arkade binary. 
-export ARKADE=/usr/local/bin/arkade
-
-# When running as a startup script (cloud-init), the HOME variable is not always set.
-# As it is required for arkade to properly download tools, 
-# set the variable to /usr/local so arkade will download binaries to /usr/local/.arkade
-if [ -z "${HOME}" ]; then
-  export HOME=/usr/local
-fi
-
-version=""
-
-echo "Finding latest version from GitHub"
-version=$(curl -sI https://github.com/$OWNER/$REPO/releases/latest | grep -i "location:" | awk -F"/" '{ printf "%s", $NF }' | tr -d '\r')
-echo "$version"
-
-if [ ! $version ]; then
-  echo "Failed while attempting to get latest version"
-  exit 1
-fi
-
-SUDO=sudo
-if [ "$(id -u)" -eq 0 ]; then
-  SUDO=
-fi
-
-verify_system() {
-  if ! [ -d /run/systemd ]; then
-    fatal 'Can not find systemd to use as a process supervisor for faasd'
-  fi
-}
-
-has_yum() {
-  [ -n "$(command -v yum)" ]
-}
-
-has_apt_get() {
-  [ -n "$(command -v apt-get)" ]
-}
-
-has_pacman() {
-  [ -n "$(command -v pacman)" ]
-}
-
-install_required_packages() {
-  if $(has_apt_get); then
-    # Debian bullseye is missing iptables. Added to required packages
-    # to get it working in raspberry pi. No such known issues in
-    # other distros. Hence, adding only to this block.
-    # reference: https://github.com/openfaas/faasd/pull/237
-    $SUDO apt-get update -y
-    $SUDO apt-get install -y curl runc bridge-utils iptables
-  elif $(has_yum); then
-    $SUDO yum check-update -y
-    $SUDO yum install -y curl runc iptables-services
-  elif $(has_pacman); then
-    $SUDO pacman -Syy
-    $SUDO pacman -Sy curl runc bridge-utils
-  else
-    fatal "Could not find apt-get, yum, or pacman. Cannot install dependencies on this OS."
-    exit 1
-  fi
-}
-
-install_arkade(){
-  curl -sLS https://get.arkade.dev | $SUDO sh
-  arkade --help
-}
-
-install_cni_plugins() {
-  cni_version=v0.9.1
-  $SUDO $ARKADE system install cni --version ${cni_version} --path /opt/cni/bin --progress=false
-}
-
-install_containerd() {
-  CONTAINERD_VER=v1.6.4
-  $SUDO systemctl unmask containerd || :
-  $SUDO $ARKADE system install containerd --systemd --version ${CONTAINERD_VER}  --progress=false
-  sleep 5
-}
-
-install_faasd() {
-  arch=$(uname -m)
-  case $arch in
-  x86_64 | amd64)
-    suffix=""
-    ;;
-  aarch64)
-    suffix=-arm64
-    ;;
-  armv7l)
-    suffix=-armhf
-    ;;
-  *)
-    echo "Unsupported architecture $arch"
-    exit 1
-    ;;
-  esac
-
-  $SUDO curl -fSLs "https://github.com/openfaas/faasd/releases/download/${version}/faasd${suffix}" --output "/usr/local/bin/faasd"
-  $SUDO chmod a+x "/usr/local/bin/faasd"
-
-  mkdir -p /tmp/faasd-${version}-installation/hack
-  cd /tmp/faasd-${version}-installation
-  $SUDO curl -fSLs "https://raw.githubusercontent.com/openfaas/faasd/${version}/docker-compose.yaml" --output "docker-compose.yaml"
-  $SUDO curl -fSLs "https://raw.githubusercontent.com/openfaas/faasd/${version}/prometheus.yml" --output "prometheus.yml"
-  $SUDO curl -fSLs "https://raw.githubusercontent.com/openfaas/faasd/${version}/resolv.conf" --output "resolv.conf"
-  $SUDO curl -fSLs "https://raw.githubusercontent.com/openfaas/faasd/${version}/hack/faasd-provider.service" --output "hack/faasd-provider.service"
-  $SUDO curl -fSLs "https://raw.githubusercontent.com/openfaas/faasd/${version}/hack/faasd.service" --output "hack/faasd.service"
-  $SUDO /usr/local/bin/faasd install
-}
-
-install_caddy() {
-  if [ ! -z "${FAASD_DOMAIN}" ]; then
-    CADDY_VER=v2.4.3
-    arkade get --progress=false caddy -v ${CADDY_VER}
-    $SUDO install -m 755 $HOME/.arkade/bin/caddy /usr/local/bin/
-
-    $SUDO curl -fSLs https://raw.githubusercontent.com/caddyserver/dist/master/init/caddy.service --output /etc/systemd/system/caddy.service
-
-    $SUDO mkdir -p /etc/caddy
-    $SUDO mkdir -p /var/lib/caddy
-    
-    if $(id caddy >/dev/null 2>&1); then
-      echo "User caddy already exists."
-    else
-      $SUDO useradd --system --home /var/lib/caddy --shell /bin/false caddy
-    fi
-
-    $SUDO tee /etc/caddy/Caddyfile >/dev/null <<EOF
-{
-  email "${LETSENCRYPT_EMAIL}"
-}
-
-${FAASD_DOMAIN} {
-  reverse_proxy 127.0.0.1:8080
-}
-EOF
-
-    $SUDO chown --recursive caddy:caddy /var/lib/caddy
-    $SUDO chown --recursive caddy:caddy /etc/caddy
-
-    $SUDO systemctl enable caddy
-    $SUDO systemctl start caddy
-  else
-    echo "Skipping caddy installation as FAASD_DOMAIN."
-  fi
-}
-
-install_faas_cli() {
-  arkade get --progress=false faas-cli
-  $SUDO install -m 755 $HOME/.arkade/bin/faas-cli /usr/local/bin/
-}
-
-verify_system
-install_required_packages
-
-$SUDO /sbin/sysctl -w net.ipv4.conf.all.forwarding=1
-echo "net.ipv4.conf.all.forwarding=1" | $SUDO tee -a /etc/sysctl.conf
-
-install_arkade
-install_cni_plugins
-install_containerd
-install_faas_cli
-install_faasd
-install_caddy
--- a/main.go
+++ b/main.go
@ -1,10 +1,9 @@
 package main

 import (
-	"fmt"
 	"os"

-	"github.com/openfaas/faasd/cmd"
+	"github.com/alexellis/faasd/cmd"
 )

 // These values will be injected into these variables at the build time.
@ -16,21 +15,6 @@ var (
 )

 func main() {
-
-	if _, ok := os.LookupEnv("CONTAINER_ID"); ok {
-		collect := cmd.RootCommand()
-		collect.SetArgs([]string{"collect"})
-		collect.SilenceUsage = true
-		collect.SilenceErrors = true
-
-		err := collect.Execute()
-		if err != nil {
-			fmt.Fprintf(os.Stderr, err.Error())
-			os.Exit(1)
-		}
-		os.Exit(0)
-	}
-
 	if err := cmd.Execute(Version, GitCommit); err != nil {
 		os.Exit(1)
 	}
--- a/pkg/cninetwork/cni_network.go
+++ b/pkg/cninetwork/cni_network.go
@ -1,262 +0,0 @@
-package cninetwork
-
-import (
-	"bufio"
-	"context"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"log"
-	"net"
-	"os"
-	"path"
-	"path/filepath"
-	"strings"
-
-	"github.com/containerd/containerd"
-	gocni "github.com/containerd/go-cni"
-	"github.com/pkg/errors"
-)
-
-const (
-	// CNIBinDir describes the directory where the CNI binaries are stored
-	CNIBinDir = "/opt/cni/bin"
-
-	// CNIConfDir describes the directory where the CNI plugin's configuration is stored
-	CNIConfDir = "/etc/cni/net.d"
-
-	// NetNSPathFmt gives the path to the a process network namespace, given the pid
-	NetNSPathFmt = "/proc/%d/ns/net"
-
-	// CNIDataDir is the directory CNI stores allocated IP for containers
-	CNIDataDir = "/var/run/cni"
-
-	// defaultCNIConfFilename is the vanity filename of default CNI configuration file
-	defaultCNIConfFilename = "10-openfaas.conflist"
-
-	// defaultNetworkName names the "docker-bridge"-like CNI plugin-chain installed when no other CNI configuration is present.
-	// This value appears in iptables comments created by CNI.
-	defaultNetworkName = "openfaas-cni-bridge"
-
-	// defaultBridgeName is the default bridge device name used in the defaultCNIConf
-	defaultBridgeName = "openfaas0"
-
-	// defaultSubnet is the default subnet used in the defaultCNIConf -- this value is set to not collide with common container networking subnets:
-	defaultSubnet = "10.62.0.0/16"
-
-	// defaultIfPrefix is the interface name to be created in the container
-	defaultIfPrefix = "eth"
-)
-
-// defaultCNIConf is a CNI configuration that enables network access to containers (docker-bridge style)
-var defaultCNIConf = fmt.Sprintf(`
-{
-    "cniVersion": "0.4.0",
-    "name": "%s",
-    "plugins": [
-      {
-        "type": "bridge",
-        "bridge": "%s",
-        "isGateway": true,
-        "ipMasq": true,
-        "ipam": {
-            "type": "host-local",
-            "subnet": "%s",
-            "dataDir": "%s",
-            "routes": [
-                { "dst": "0.0.0.0/0" }
-            ]
-        }
-      },
-      {
-        "type": "firewall"
-      }
-    ]
-}
-`, defaultNetworkName, defaultBridgeName, defaultSubnet, CNIDataDir)
-
-// InitNetwork writes configlist file and initializes CNI network
-func InitNetwork() (gocni.CNI, error) {
-
-	log.Printf("Writing network config...\n")
-	if !dirExists(CNIConfDir) {
-		if err := os.MkdirAll(CNIConfDir, 0755); err != nil {
-			return nil, fmt.Errorf("cannot create directory: %s", CNIConfDir)
-		}
-	}
-
-	netConfig := path.Join(CNIConfDir, defaultCNIConfFilename)
-	if err := ioutil.WriteFile(netConfig, []byte(defaultCNIConf), 644); err != nil {
-		return nil, fmt.Errorf("cannot write network config: %s", defaultCNIConfFilename)
-	}
-
-	// Initialize CNI library
-	cni, err := gocni.New(
-		gocni.WithPluginConfDir(CNIConfDir),
-		gocni.WithPluginDir([]string{CNIBinDir}),
-		gocni.WithInterfacePrefix(defaultIfPrefix),
-	)
-
-	if err != nil {
-		return nil, fmt.Errorf("error initializing cni: %s", err)
-	}
-
-	// Load the cni configuration
-	if err := cni.Load(gocni.WithLoNetwork, gocni.WithConfListFile(filepath.Join(CNIConfDir, defaultCNIConfFilename))); err != nil {
-		return nil, fmt.Errorf("failed to load cni configuration: %v", err)
-	}
-
-	return cni, nil
-}
-
-// CreateCNINetwork creates a CNI network interface and attaches it to the context
-func CreateCNINetwork(ctx context.Context, cni gocni.CNI, task containerd.Task, labels map[string]string) (*gocni.CNIResult, error) {
-	id := netID(task)
-	netns := netNamespace(task)
-	result, err := cni.Setup(ctx, id, netns, gocni.WithLabels(labels))
-	if err != nil {
-		return nil, errors.Wrapf(err, "Failed to setup network for task %q: %v", id, err)
-	}
-
-	return result, nil
-}
-
-// DeleteCNINetwork deletes a CNI network based on task ID and Pid
-func DeleteCNINetwork(ctx context.Context, cni gocni.CNI, client *containerd.Client, name string) error {
-	container, containerErr := client.LoadContainer(ctx, name)
-	if containerErr == nil {
-		task, err := container.Task(ctx, nil)
-		if err != nil {
-			log.Printf("[Delete] unable to find task for container: %s\n", name)
-			return nil
-		}
-
-		log.Printf("[Delete] removing CNI network for: %s\n", task.ID())
-
-		id := netID(task)
-		netns := netNamespace(task)
-
-		if err := cni.Remove(ctx, id, netns); err != nil {
-			return errors.Wrapf(err, "Failed to remove network for task: %q, %v", id, err)
-		}
-		log.Printf("[Delete] removed: %s from namespace: %s, ID: %s\n", name, netns, id)
-
-		return nil
-	}
-
-	return errors.Wrapf(containerErr, "Unable to find container: %s, error: %s", name, containerErr)
-}
-
-// GetIPAddress returns the IP address from container based on container name and PID
-func GetIPAddress(container string, PID uint32) (string, error) {
-	CNIDir := path.Join(CNIDataDir, defaultNetworkName)
-
-	files, err := ioutil.ReadDir(CNIDir)
-	if err != nil {
-		return "", fmt.Errorf("failed to read CNI dir for container %s: %v", container, err)
-	}
-
-	for _, file := range files {
-		// each fileName is an IP address
-		fileName := file.Name()
-
-		resultsFile := filepath.Join(CNIDir, fileName)
-		found, err := isCNIResultForPID(resultsFile, container, PID)
-		if err != nil {
-			return "", err
-		}
-
-		if found {
-			return fileName, nil
-		}
-	}
-
-	return "", fmt.Errorf("unable to get IP address for container: %s", container)
-}
-
-// isCNIResultForPID confirms if the CNI result file contains the
-// process name, PID and interface name
-//
-// Example:
-//
-// /var/run/cni/openfaas-cni-bridge/10.62.0.2
-//
-// nats-621
-// eth1
-func isCNIResultForPID(fileName, container string, PID uint32) (bool, error) {
-	found := false
-
-	f, err := os.Open(fileName)
-	if err != nil {
-		return false, fmt.Errorf("failed to open CNI IP file for %s: %v", fileName, err)
-	}
-	defer f.Close()
-
-	reader := bufio.NewReader(f)
-	processLine, _ := reader.ReadString('\n')
-	if strings.Contains(processLine, fmt.Sprintf("%s-%d", container, PID)) {
-		ethNameLine, _ := reader.ReadString('\n')
-		if strings.Contains(ethNameLine, defaultIfPrefix) {
-			found = true
-		}
-	}
-
-	return found, nil
-}
-
-// CNIGateway returns the gateway for default subnet
-func CNIGateway() (string, error) {
-	ip, _, err := net.ParseCIDR(defaultSubnet)
-	if err != nil {
-		return "", fmt.Errorf("error formatting gateway for network %s", defaultSubnet)
-	}
-	ip = ip.To4()
-	ip[3] = 1
-	return ip.String(), nil
-}
-
-// netID generates the network IF based on task name and task PID
-func netID(task containerd.Task) string {
-	return fmt.Sprintf("%s-%d", task.ID(), task.Pid())
-}
-
-// netNamespace generates the namespace path based on task PID.
-func netNamespace(task containerd.Task) string {
-	return fmt.Sprintf(NetNSPathFmt, task.Pid())
-}
-
-func dirEmpty(dirname string) (isEmpty bool) {
-	if !dirExists(dirname) {
-		return
-	}
-
-	f, err := os.Open(dirname)
-	if err != nil {
-		return
-	}
-	defer func() { _ = f.Close() }()
-
-	// If the first file is EOF, the directory is empty
-	if _, err = f.Readdir(1); err == io.EOF {
-		isEmpty = true
-	}
-	return isEmpty
-}
-
-func dirExists(dirname string) bool {
-	exists, info := pathExists(dirname)
-	if !exists {
-		return false
-	}
-
-	return info.IsDir()
-}
-
-func pathExists(path string) (bool, os.FileInfo) {
-	info, err := os.Stat(path)
-	if os.IsNotExist(err) {
-		return false, nil
-	}
-
-	return true, info
-}
--- a/pkg/cninetwork/cni_network_test.go
+++ b/pkg/cninetwork/cni_network_test.go
@ -1,63 +0,0 @@
-package cninetwork
-
-import (
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func Test_isCNIResultForPID_Found(t *testing.T) {
-	body := `nats-621
-eth1`
-	fileName := `10.62.0.2`
-	container := "nats"
-	PID := uint32(621)
-	fullPath := filepath.Join(os.TempDir(), fileName)
-
-	err := ioutil.WriteFile(fullPath, []byte(body), 0700)
-	if err != nil {
-		t.Fatalf(err.Error())
-	}
-	defer func() {
-		os.Remove(fullPath)
-	}()
-
-	got, err := isCNIResultForPID(fullPath, container, PID)
-
-	if err != nil {
-		t.Fatalf(err.Error())
-	}
-
-	want := true
-	if got != want {
-		t.Fatalf("want %v, but got %v", want, got)
-	}
-}
-
-func Test_isCNIResultForPID_NoMatch(t *testing.T) {
-	body := `nats-621
-eth1`
-	fileName := `10.62.0.3`
-	container := "gateway"
-	PID := uint32(621)
-	fullPath := filepath.Join(os.TempDir(), fileName)
-
-	err := ioutil.WriteFile(fullPath, []byte(body), 0700)
-	if err != nil {
-		t.Fatalf(err.Error())
-	}
-	defer func() {
-		os.Remove(fullPath)
-	}()
-
-	got, err := isCNIResultForPID(fullPath, container, PID)
-
-	if err != nil {
-		t.Fatalf(err.Error())
-	}
-	want := false
-	if got != want {
-		t.Fatalf("want %v, but got %v", want, got)
-	}
-}
--- a/pkg/constants.go
+++ b/pkg/constants.go
@ -1,16 +0,0 @@
-package pkg
-
-const (
-	// DefaultFunctionNamespace is the default containerd namespace functions are created
-	DefaultFunctionNamespace = "openfaas-fn"
-
-	// NamespaceLabel indicates that a namespace is managed by faasd
-	NamespaceLabel = "openfaas"
-
-	// FaasdNamespace is the containerd namespace services are created
-	FaasdNamespace = "openfaas"
-
-	faasServicesPullAlways = false
-
-	defaultSnapshotter = "overlayfs"
-)
--- a/pkg/depgraph/depgraph.go
+++ b/pkg/depgraph/depgraph.go
@ -1,106 +0,0 @@
-package depgraph
-
-import "log"
-
-// Node represents a node in a Graph with
-// 0 to many edges
-type Node struct {
-	Name  string
-	Edges []*Node
-}
-
-// Graph is a collection of nodes
-type Graph struct {
-	nodes []*Node
-}
-
-func NewDepgraph() *Graph {
-	return &Graph{
-		nodes: []*Node{},
-	}
-}
-
-// Nodes returns the nodes within the graph
-func (g *Graph) Nodes() []*Node {
-	return g.nodes
-}
-
-// Contains returns true if the target Node is found
-// in its list
-func (g *Graph) Contains(target *Node) bool {
-	for _, g := range g.nodes {
-		if g.Name == target.Name {
-			return true
-		}
-	}
-
-	return false
-}
-
-// Add places a Node into the current Graph
-func (g *Graph) Add(target *Node) {
-	g.nodes = append(g.nodes, target)
-}
-
-// Remove deletes a target Node reference from the
-// list of nodes in the graph
-func (g *Graph) Remove(target *Node) {
-	var found *int
-	for i, n := range g.nodes {
-		if n == target {
-			found = &i
-			break
-		}
-	}
-
-	if found != nil {
-		g.nodes = append(g.nodes[:*found], g.nodes[*found+1:]...)
-	}
-}
-
-// Resolve retruns a list of node names in order of their dependencies.
-// A use case may be for determining the correct order to install
-// software packages, or to start services.
-// Based upon the algorithm described by Ferry Boender in the following article
-// https://www.electricmonk.nl/log/2008/08/07/dependency-resolving-algorithm/
-func (g *Graph) Resolve() []string {
-	resolved := &Graph{}
-	unresolved := &Graph{}
-	for _, node := range g.nodes {
-		resolve(node, resolved, unresolved)
-	}
-
-	order := []string{}
-
-	for _, node := range resolved.Nodes() {
-		order = append(order, node.Name)
-	}
-
-	return order
-}
-
-// resolve mutates the resolved graph for a given starting
-// node. The unresolved graph is used to detect a circular graph
-// error and will throw a panic. This can be caught with a resolve
-// in a go routine.
-func resolve(node *Node, resolved, unresolved *Graph) {
-	unresolved.Add(node)
-
-	for _, edge := range node.Edges {
-
-		if !resolved.Contains(edge) && unresolved.Contains(edge) {
-			log.Panicf("edge: %s may be a circular dependency", edge.Name)
-		}
-
-		resolve(edge, resolved, unresolved)
-	}
-
-	for _, r := range resolved.nodes {
-		if r.Name == node.Name {
-			return
-		}
-	}
-
-	resolved.Add(node)
-	unresolved.Remove(node)
-}
--- a/pkg/depgraph/depgraph_test.go
+++ b/pkg/depgraph/depgraph_test.go
@ -1,41 +0,0 @@
-package depgraph
-
-import "testing"
-
-func Test_RemoveMedial(t *testing.T) {
-	g := Graph{nodes: []*Node{}}
-	a := &Node{Name: "A"}
-	b := &Node{Name: "B"}
-	c := &Node{Name: "C"}
-
-	g.nodes = append(g.nodes, a)
-	g.nodes = append(g.nodes, b)
-	g.nodes = append(g.nodes, c)
-
-	g.Remove(b)
-
-	for _, n := range g.nodes {
-		if n.Name == b.Name {
-			t.Fatalf("Found deleted node: %s", n.Name)
-		}
-	}
-}
-
-func Test_RemoveFinal(t *testing.T) {
-	g := Graph{nodes: []*Node{}}
-	a := &Node{Name: "A"}
-	b := &Node{Name: "B"}
-	c := &Node{Name: "C"}
-
-	g.nodes = append(g.nodes, a)
-	g.nodes = append(g.nodes, b)
-	g.nodes = append(g.nodes, c)
-
-	g.Remove(c)
-
-	for _, n := range g.nodes {
-		if n.Name == c.Name {
-			t.Fatalf("Found deleted node: %s", c.Name)
-		}
-	}
-}
--- a/pkg/deployment_order.go
+++ b/pkg/deployment_order.go
@ -1,41 +0,0 @@
-package pkg
-
-import (
-	"log"
-
-	"github.com/openfaas/faasd/pkg/depgraph"
-)
-
-func buildDeploymentOrder(svcs []Service) []string {
-
-	graph := buildServiceGraph(svcs)
-
-	order := graph.Resolve()
-
-	log.Printf("Start-up order:\n")
-	for _, node := range order {
-		log.Printf("- %s\n", node)
-	}
-
-	return order
-}
-
-func buildServiceGraph(svcs []Service) *depgraph.Graph {
-	graph := depgraph.NewDepgraph()
-
-	nodeMap := map[string]*depgraph.Node{}
-	for _, s := range svcs {
-		n := &depgraph.Node{Name: s.Name}
-		nodeMap[s.Name] = n
-		graph.Add(n)
-
-	}
-
-	for _, s := range svcs {
-		for _, d := range s.DependsOn {
-			nodeMap[s.Name].Edges = append(nodeMap[s.Name].Edges, nodeMap[d])
-		}
-	}
-
-	return graph
-}
--- a/pkg/deployment_order_test.go
+++ b/pkg/deployment_order_test.go
@ -1,224 +0,0 @@
-package pkg
-
-import (
-	"log"
-	"testing"
-)
-
-func Test_buildDeploymentOrder_ARequiresB(t *testing.T) {
-	svcs := []Service{
-		{
-			Name:      "A",
-			DependsOn: []string{"B"},
-		},
-		{
-			Name:      "B",
-			DependsOn: []string{},
-		},
-	}
-
-	order := buildDeploymentOrder(svcs)
-
-	if len(order) < len(svcs) {
-		t.Fatalf("length of order too short: %d", len(order))
-	}
-
-	got := order[0]
-	want := "B"
-	if got != want {
-		t.Fatalf("%s should be last to be installed, but was: %s", want, got)
-	}
-}
-
-func Test_buildDeploymentOrder_ARequiresBAndC(t *testing.T) {
-	svcs := []Service{
-		{
-			Name:      "A",
-			DependsOn: []string{"B", "C"},
-		},
-		{
-			Name:      "B",
-			DependsOn: []string{},
-		},
-		{
-			Name:      "C",
-			DependsOn: []string{},
-		},
-	}
-
-	order := buildDeploymentOrder(svcs)
-
-	if len(order) < len(svcs) {
-		t.Fatalf("length of order too short: %d", len(order))
-	}
-
-	a := indexStr(order, "a")
-	b := indexStr(order, "b")
-	c := indexStr(order, "c")
-
-	if a > b {
-		t.Fatalf("a should be after dependencies")
-	}
-	if a > c {
-		t.Fatalf("a should be after dependencies")
-	}
-
-}
-
-func Test_buildDeploymentOrder_ARequiresBRequiresC(t *testing.T) {
-	svcs := []Service{
-		{
-			Name:      "A",
-			DependsOn: []string{"B"},
-		},
-		{
-			Name:      "B",
-			DependsOn: []string{"C"},
-		},
-		{
-			Name:      "C",
-			DependsOn: []string{},
-		},
-	}
-
-	order := buildDeploymentOrder(svcs)
-
-	if len(order) < len(svcs) {
-		t.Fatalf("length of order too short: %d", len(order))
-	}
-
-	got := order[0]
-	want := "C"
-	if got != want {
-		t.Fatalf("%s should be last to be installed, but was: %s", want, got)
-	}
-	got = order[1]
-	want = "B"
-	if got != want {
-		t.Fatalf("%s should be last to be installed, but was: %s", want, got)
-	}
-	got = order[2]
-	want = "A"
-	if got != want {
-		t.Fatalf("%s should be last to be installed, but was: %s", want, got)
-	}
-}
-
-func Test_buildDeploymentOrderCircularARequiresBRequiresA(t *testing.T) {
-	svcs := []Service{
-		{
-			Name:      "A",
-			DependsOn: []string{"B"},
-		},
-		{
-			Name:      "B",
-			DependsOn: []string{"A"},
-		},
-	}
-
-	defer func() { recover() }()
-
-	buildDeploymentOrder(svcs)
-
-	t.Fatalf("did not panic as expected")
-}
-
-func Test_buildDeploymentOrderComposeFile(t *testing.T) {
-	// svcs := []Service{}
-	file, err := LoadComposeFileWithArch("../", "docker-compose.yaml", func() (string, string) {
-		return "x86_64", "Linux"
-	})
-
-	if err != nil {
-		t.Fatalf("unable to load compose file: %s", err)
-	}
-
-	svcs, err := ParseCompose(file)
-	if err != nil {
-		t.Fatalf("unable to parse compose file: %s", err)
-	}
-
-	for _, s := range svcs {
-		log.Printf("Service: %s\n", s.Name)
-		for _, d := range s.DependsOn {
-			log.Printf("Link: %s => %s\n", s.Name, d)
-		}
-	}
-
-	order := buildDeploymentOrder(svcs)
-
-	if len(order) < len(svcs) {
-		t.Fatalf("length of order too short: %d", len(order))
-	}
-
-	queueWorker := indexStr(order, "queue-worker")
-	nats := indexStr(order, "nats")
-	gateway := indexStr(order, "gateway")
-	prometheus := indexStr(order, "prometheus")
-
-	if prometheus > gateway {
-		t.Fatalf("Prometheus order was after gateway, and should be before")
-	}
-	if nats > gateway {
-		t.Fatalf("NATS order was after gateway, and should be before")
-	}
-	if nats > queueWorker {
-		t.Fatalf("NATS order was after queue-worker, and should be before")
-	}
-}
-
-func Test_buildDeploymentOrderOpenFaaS(t *testing.T) {
-	svcs := []Service{
-		{
-			Name:      "queue-worker",
-			DependsOn: []string{"nats"},
-		},
-		{
-			Name:      "prometheus",
-			DependsOn: []string{},
-		},
-		{
-			Name:      "gateway",
-			DependsOn: []string{"prometheus", "nats", "basic-auth-plugin"},
-		},
-		{
-			Name:      "basic-auth-plugin",
-			DependsOn: []string{},
-		},
-		{
-			Name:      "nats",
-			DependsOn: []string{},
-		},
-	}
-
-	order := buildDeploymentOrder(svcs)
-
-	if len(order) < len(svcs) {
-		t.Fatalf("length of order too short: %d", len(order))
-	}
-
-	queueWorker := indexStr(order, "queue-worker")
-	nats := indexStr(order, "nats")
-	gateway := indexStr(order, "gateway")
-	prometheus := indexStr(order, "prometheus")
-
-	if prometheus > gateway {
-		t.Fatalf("Prometheus order was after gateway, and should be before")
-	}
-	if nats > gateway {
-		t.Fatalf("NATS order was after gateway, and should be before")
-	}
-	if nats > queueWorker {
-		t.Fatalf("NATS order was after queue-worker, and should be before")
-	}
-}
-
-func indexStr(st []string, t string) int {
-	for n, s := range st {
-		if s == t {
-			return n
-		}
-
-	}
-	return -1
-}
--- a/pkg/local_resolver.go
+++ b/pkg/local_resolver.go
@ -1,104 +0,0 @@
-package pkg
-
-import (
-	"io/ioutil"
-	"log"
-	"os"
-	"strings"
-	"sync"
-	"time"
-)
-
-// LocalResolver provides hostname to IP look-up for faasd core services
-type LocalResolver struct {
-	Path  string
-	Map   map[string]string
-	Mutex *sync.RWMutex
-}
-
-// NewLocalResolver creates a new resolver for reading from a hosts file
-func NewLocalResolver(path string) Resolver {
-	return &LocalResolver{
-		Path:  path,
-		Mutex: &sync.RWMutex{},
-		Map:   make(map[string]string),
-	}
-}
-
-// Start polling the disk for the hosts file in Path
-func (l *LocalResolver) Start() {
-	var lastStat os.FileInfo
-
-	for {
-		rebuild := false
-		if info, err := os.Stat(l.Path); err == nil {
-			if lastStat == nil {
-				rebuild = true
-			} else {
-				if !lastStat.ModTime().Equal(info.ModTime()) {
-					rebuild = true
-				}
-			}
-			lastStat = info
-		}
-
-		if rebuild {
-			log.Printf("Resolver rebuilding map")
-			l.rebuild()
-		}
-		time.Sleep(time.Second * 3)
-	}
-}
-
-func (l *LocalResolver) rebuild() {
-	l.Mutex.Lock()
-	defer l.Mutex.Unlock()
-
-	fileData, fileErr := ioutil.ReadFile(l.Path)
-	if fileErr != nil {
-		log.Printf("resolver rebuild error: %s", fileErr.Error())
-		return
-	}
-
-	lines := strings.Split(string(fileData), "\n")
-
-	for _, line := range lines {
-		index := strings.Index(line, "\t")
-
-		if len(line) > 0 && index > -1 {
-			ip := line[:index]
-			host := line[index+1:]
-			log.Printf("Resolver: %q=%q", host, ip)
-			l.Map[host] = ip
-		}
-	}
-}
-
-// Get resolves a hostname to an IP, or timesout after the duration has passed
-func (l *LocalResolver) Get(upstream string, got chan<- string, timeout time.Duration) {
-	start := time.Now()
-	for {
-		if val := l.get(upstream); len(val) > 0 {
-			got <- val
-			break
-		}
-
-		if time.Now().After(start.Add(timeout)) {
-			log.Printf("Timed out after %s getting host %q", timeout.String(), upstream)
-			break
-		}
-
-		time.Sleep(time.Millisecond * 250)
-	}
-}
-
-func (l *LocalResolver) get(upstream string) string {
-	l.Mutex.RLock()
-	defer l.Mutex.RUnlock()
-
-	if val, ok := l.Map[upstream]; ok {
-		return val
-	}
-
-	return ""
-}
--- a/pkg/logs/requestor.go
+++ b/pkg/logs/requestor.go
@ -1,183 +0,0 @@
-package logs
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"log"
-	"os/exec"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/openfaas/faas-provider/logs"
-
-	faasd "github.com/openfaas/faasd/pkg"
-)
-
-type requester struct{}
-
-// New returns a new journalctl log Requester
-func New() logs.Requester {
-	return &requester{}
-}
-
-// Query submits a log request to the actual logging system.
-func (r *requester) Query(ctx context.Context, req logs.Request) (<-chan logs.Message, error) {
-	_, err := exec.LookPath("journalctl")
-	if err != nil {
-		return nil, fmt.Errorf("can not find journalctl: %w", err)
-	}
-
-	cmd := buildCmd(ctx, req)
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		return nil, fmt.Errorf("failed to create journalctl pipe: %w", err)
-	}
-
-	stderr, err := cmd.StderrPipe()
-	if err != nil {
-		return nil, fmt.Errorf("failed to create journalctl err pipe: %w", err)
-	}
-
-	err = cmd.Start()
-	if err != nil {
-		return nil, fmt.Errorf("failed to create journalctl: %w", err)
-	}
-
-	// call start and get the stdout prior to streaming so that we can return a meaningful
-	// error for as long as possible. If the cmd starts correctly, we are highly likely to
-	// succeed anyway
-	msgs := make(chan logs.Message)
-	go streamLogs(ctx, cmd, stdout, msgs)
-	go logErrOut(stderr)
-
-	return msgs, nil
-}
-
-// buildCmd reeturns the equivalent of
-//
-// 	journalctl -t <namespace>:<name>  \
-// 		--output=json \
-// 		--since=<timestamp> \
-// 		<--follow> \
-func buildCmd(ctx context.Context, req logs.Request) *exec.Cmd {
-	// // set the cursor position based on req, default to 5m
-	since := time.Now().Add(-5 * time.Minute)
-	if req.Since != nil && req.Since.Before(time.Now()) {
-		since = *req.Since
-	}
-
-	namespace := req.Namespace
-	if namespace == "" {
-		namespace = faasd.DefaultFunctionNamespace
-	}
-
-	// find the description of the fields here
-	// https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html
-	// the available fields can vary greatly, the selected fields were detemined by
-	// trial and error with journalctl in an ubuntu VM  (via multipass)
-	args := []string{
-		"--utc",
-		"--no-pager",
-		"--output=json",
-		"--identifier=" + namespace + ":" + req.Name,
-		fmt.Sprintf("--since=%s", since.UTC().Format("2006-01-02 15:04:05")),
-	}
-
-	if req.Follow {
-		args = append(args, "--follow")
-	}
-
-	if req.Tail > 0 {
-		args = append(args, fmt.Sprintf("--lines=%d", req.Tail))
-	}
-
-	return exec.CommandContext(ctx, "journalctl", args...)
-}
-
-// streamLogs copies log entries from the journalctl `cmd`/`out` to `msgs`
-// the loop is based on the Decoder example in the docs
-// https://golang.org/pkg/encoding/json/#Decoder.Decode
-func streamLogs(ctx context.Context, cmd *exec.Cmd, out io.ReadCloser, msgs chan logs.Message) {
-	log.Println("starting journal stream using ", cmd.String())
-
-	// will ensure `out` is closed and all related resources cleaned up
-	go func() {
-		err := cmd.Wait()
-		log.Println("wait result", err)
-	}()
-
-	defer func() {
-		log.Println("closing journal stream")
-		close(msgs)
-	}()
-
-	dec := json.NewDecoder(out)
-	for dec.More() {
-		if ctx.Err() != nil {
-			log.Println("log stream context cancelled")
-			return
-		}
-
-		// the journalctl outputs all the values as a string, so a struct with json
-		// tags wont help much
-		entry := map[string]string{}
-		err := dec.Decode(&entry)
-		if err != nil {
-			log.Printf("error decoding journalctl output: %s", err)
-			return
-		}
-
-		msg, err := parseEntry(entry)
-		if err != nil {
-			log.Printf("error parsing journalctl output: %s", err)
-			return
-		}
-
-		msgs <- msg
-	}
-}
-
-// parseEntry reads the deserialized json from journalctl into a log.Message
-//
-// The following fields are parsed from the journal
-// - MESSAGE
-// - _PID
-// - SYSLOG_IDENTIFIER
-// - __REALTIME_TIMESTAMP
-func parseEntry(entry map[string]string) (logs.Message, error) {
-	logMsg := logs.Message{
-		Text:     entry["MESSAGE"],
-		Instance: entry["_PID"],
-	}
-
-	identifier := entry["SYSLOG_IDENTIFIER"]
-	parts := strings.Split(identifier, ":")
-	if len(parts) != 2 {
-		return logMsg, fmt.Errorf("invalid SYSLOG_IDENTIFIER")
-	}
-	logMsg.Namespace = parts[0]
-	logMsg.Name = parts[1]
-
-	ts, ok := entry["__REALTIME_TIMESTAMP"]
-	if !ok {
-		return logMsg, fmt.Errorf("missing required field __REALTIME_TIMESTAMP")
-	}
-
-	ms, err := strconv.ParseInt(ts, 10, 64)
-	if err != nil {
-		return logMsg, fmt.Errorf("invalid timestamp: %w", err)
-	}
-	logMsg.Timestamp = time.Unix(0, ms*1000).UTC()
-
-	return logMsg, nil
-}
-
-func logErrOut(out io.ReadCloser) {
-	defer log.Println("stderr closed")
-	defer out.Close()
-
-	io.Copy(log.Writer(), out)
-}
--- a/pkg/logs/requestor_test.go
+++ b/pkg/logs/requestor_test.go
@ -1,73 +0,0 @@
-package logs
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/openfaas/faas-provider/logs"
-)
-
-func Test_parseEntry(t *testing.T) {
-	rawEntry := `{ "__CURSOR" : "s=71c4550142d14ace8e2959e3540cc15c;i=133c;b=44864010f0d94baba7b6bf8019f82a56;m=2945cd3;t=5a00d4eb59180;x=8ed47f7f9b3d798", "__REALTIME_TIMESTAMP" : "1583353899094400", "__MONOTONIC_TIMESTAMP" : "43277523", "_BOOT_ID" : "44864010f0d94baba7b6bf8019f82a56", "SYSLOG_IDENTIFIER" : "openfaas-fn:nodeinfo", "_PID" : "2254", "MESSAGE" : "2020/03/04 20:31:39 POST / - 200 OK - ContentLength: 83", "_SOURCE_REALTIME_TIMESTAMP" : "1583353899094372" }`
-	expectedEntry := logs.Message{
-		Name:      "nodeinfo",
-		Namespace: "openfaas-fn",
-		Text:      "2020/03/04 20:31:39 POST / - 200 OK - ContentLength: 83",
-		Timestamp: time.Unix(0, 1583353899094400*1000).UTC(),
-	}
-
-	value := map[string]string{}
-	json.Unmarshal([]byte(rawEntry), &value)
-
-	entry, err := parseEntry(value)
-	if err != nil {
-		t.Fatalf("unexpected error %s", err)
-	}
-
-	if entry.Name != expectedEntry.Name {
-		t.Fatalf("want Name: %q, got %q", expectedEntry.Name, entry.Name)
-	}
-
-	if entry.Namespace != expectedEntry.Namespace {
-		t.Fatalf("want Namespace: %q, got %q", expectedEntry.Namespace, entry.Namespace)
-	}
-
-	if entry.Timestamp != expectedEntry.Timestamp {
-		t.Fatalf("want Timestamp: %q, got %q", expectedEntry.Timestamp, entry.Timestamp)
-	}
-
-	if entry.Text != expectedEntry.Text {
-		t.Fatalf("want Text: %q, got %q", expectedEntry.Text, entry.Text)
-	}
-}
-
-func Test_buildCmd(t *testing.T) {
-	ctx := context.TODO()
-	now := time.Now()
-	req := logs.Request{
-		Name:      "loggyfunc",
-		Namespace: "spacetwo",
-		Follow:    true,
-		Since:     &now,
-		Tail:      5,
-	}
-
-	expectedArgs := fmt.Sprintf(
-		"--utc --no-pager --output=json --identifier=spacetwo:loggyfunc --since=%s --follow --lines=5",
-		now.UTC().Format("2006-01-02 15:04:05"),
-	)
-
-	cmd := buildCmd(ctx, req).String()
-	wantCmd := "journalctl"
-	if !strings.Contains(cmd, wantCmd) {
-		t.Fatalf("cmd want: %q, got: %q", wantCmd, cmd)
-	}
-
-	if !strings.HasSuffix(cmd, expectedArgs) {
-		t.Fatalf("arg want: %q\ngot: %q", expectedArgs, cmd)
-	}
-}
--- a/pkg/provider/config/read.go
+++ b/pkg/provider/config/read.go
@ -1,35 +0,0 @@
-package config
-
-import (
-	"time"
-
-	types "github.com/openfaas/faas-provider/types"
-)
-
-type ProviderConfig struct {
-	// Sock is the address of the containerd socket
-	Sock string
-}
-
-// ReadFromEnv loads the FaaSConfig and the Containerd specific config form the env variables
-func ReadFromEnv(hasEnv types.HasEnv) (*types.FaaSConfig, *ProviderConfig, error) {
-	config, err := types.ReadConfig{}.Read(hasEnv)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	serviceTimeout := types.ParseIntOrDurationValue(hasEnv.Getenv("service_timeout"), time.Second*60)
-
-	config.EnableHealth = true
-	config.ReadTimeout = serviceTimeout
-	config.WriteTimeout = serviceTimeout
-
-	port := types.ParseIntValue(hasEnv.Getenv("port"), 8081)
-	config.TCPPort = &port
-
-	providerConfig := &ProviderConfig{
-		Sock: types.ParseString(hasEnv.Getenv("sock"), "/run/containerd/containerd.sock"),
-	}
-
-	return config, providerConfig, nil
-}
--- a/pkg/provider/config/read_test.go
+++ b/pkg/provider/config/read_test.go
@ -1,107 +0,0 @@
-package config
-
-import (
-	"strconv"
-	"testing"
-)
-
-type EnvBucket struct {
-	Items map[string]string
-}
-
-func NewEnvBucket() EnvBucket {
-	return EnvBucket{
-		Items: make(map[string]string),
-	}
-}
-
-func (e EnvBucket) Getenv(key string) string {
-	return e.Items[key]
-}
-
-func (e EnvBucket) Setenv(key string, value string) {
-	e.Items[key] = value
-}
-
-func Test_SetSockByEnv(t *testing.T) {
-	defaultSock := "/run/containerd/containerd.sock"
-	expectedSock := "/non/default/value.sock"
-	env := NewEnvBucket()
-	_, config, err := ReadFromEnv(env)
-	if err != nil {
-		t.Fatalf("unexpected error %s", err)
-	}
-	if config.Sock != defaultSock {
-		t.Fatalf("expected %q, got %q", defaultSock, config.Sock)
-	}
-
-	env.Setenv("sock", expectedSock)
-	_, config, err = ReadFromEnv(env)
-	if err != nil {
-		t.Fatalf("unexpected error %s", err)
-	}
-	if config.Sock != expectedSock {
-		t.Fatalf("expected %q, got %q", expectedSock, config.Sock)
-	}
-}
-
-func Test_SetServiceTimeout(t *testing.T) {
-	defaultTimeout := "1m0s"
-
-	env := NewEnvBucket()
-	config, _, err := ReadFromEnv(env)
-	if err != nil {
-		t.Fatalf("unexpected error %s", err)
-	}
-	if config.ReadTimeout.String() != defaultTimeout {
-		t.Fatalf("expected %q, got %q", defaultTimeout, config.ReadTimeout)
-	}
-
-	if config.WriteTimeout.String() != defaultTimeout {
-		t.Fatalf("expected %q, got %q", defaultTimeout, config.WriteTimeout)
-	}
-
-	newTimeout := "30s"
-	env.Setenv("service_timeout", newTimeout)
-	config, _, err = ReadFromEnv(env)
-	if err != nil {
-		t.Fatalf("unexpected error %s", err)
-	}
-	if config.ReadTimeout.String() != newTimeout {
-		t.Fatalf("expected %q, got %q", newTimeout, config.ReadTimeout)
-	}
-
-	if config.WriteTimeout.String() != newTimeout {
-		t.Fatalf("expected %q, got %q", newTimeout, config.WriteTimeout)
-	}
-}
-
-func Test_SetPort(t *testing.T) {
-	defaultPort := 8081
-
-	env := NewEnvBucket()
-	config, _, err := ReadFromEnv(env)
-	if err != nil {
-		t.Fatalf("unexpected error %s", err)
-	}
-	if config.TCPPort == nil {
-		t.Fatal("expected non-nil TCPPort")
-	}
-	if *config.TCPPort != defaultPort {
-		t.Fatalf("expected %d, got %d", defaultPort, config.TCPPort)
-	}
-
-	newPort := 9091
-	newPortStr := strconv.Itoa(newPort)
-	env.Setenv("port", newPortStr)
-	config, _, err = ReadFromEnv(env)
-	if err != nil {
-		t.Fatalf("unexpected error %s", err)
-	}
-	if config.TCPPort == nil {
-		t.Fatal("expected non-nil TCPPort")
-	}
-	if *config.TCPPort != newPort {
-		t.Fatalf("expected %d, got %d", newPort, config.TCPPort)
-	}
-}
--- a/pkg/provider/handlers/delete.go
+++ b/pkg/provider/handlers/delete.go
@ -1,86 +0,0 @@
-package handlers
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net/http"
-
-	"github.com/containerd/containerd"
-	"github.com/containerd/containerd/namespaces"
-	gocni "github.com/containerd/go-cni"
-	"github.com/openfaas/faas/gateway/requests"
-
-	cninetwork "github.com/openfaas/faasd/pkg/cninetwork"
-	"github.com/openfaas/faasd/pkg/service"
-)
-
-func MakeDeleteHandler(client *containerd.Client, cni gocni.CNI) func(w http.ResponseWriter, r *http.Request) {
-
-	return func(w http.ResponseWriter, r *http.Request) {
-
-		if r.Body == nil {
-			http.Error(w, "expected a body", http.StatusBadRequest)
-			return
-		}
-
-		defer r.Body.Close()
-
-		body, _ := ioutil.ReadAll(r.Body)
-		log.Printf("[Delete] request: %s\n", string(body))
-
-		req := requests.DeleteFunctionRequest{}
-		err := json.Unmarshal(body, &req)
-		if err != nil {
-			log.Printf("[Delete] error parsing input: %s\n", err)
-			http.Error(w, err.Error(), http.StatusBadRequest)
-
-			return
-		}
-
-		lookupNamespace := getRequestNamespace(readNamespaceFromQuery(r))
-
-		// Check if namespace exists, and it has the openfaas label
-		valid, err := validNamespace(client.NamespaceService(), lookupNamespace)
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-
-		if !valid {
-			http.Error(w, "namespace not valid", http.StatusBadRequest)
-			return
-		}
-
-		name := req.FunctionName
-
-		function, err := GetFunction(client, name, lookupNamespace)
-		if err != nil {
-			msg := fmt.Sprintf("service %s not found", name)
-			log.Printf("[Delete] %s\n", msg)
-			http.Error(w, msg, http.StatusNotFound)
-			return
-		}
-
-		ctx := namespaces.WithNamespace(context.Background(), lookupNamespace)
-
-		// TODO: this needs to still happen if the task is paused
-		if function.replicas != 0 {
-			err = cninetwork.DeleteCNINetwork(ctx, cni, client, name)
-			if err != nil {
-				log.Printf("[Delete] error removing CNI network for %s, %s\n", name, err)
-			}
-		}
-
-		containerErr := service.Remove(ctx, client, name)
-		if containerErr != nil {
-			log.Printf("[Delete] error removing %s, %s\n", name, containerErr)
-			http.Error(w, containerErr.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		log.Printf("[Delete] deleted %s\n", name)
-	}
-}
--- a/pkg/provider/handlers/deploy.go
+++ b/pkg/provider/handlers/deploy.go
@ -1,317 +0,0 @@
-package handlers
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"os"
-	"path"
-	"time"
-
-	"github.com/containerd/containerd"
-	"github.com/containerd/containerd/cio"
-	"github.com/containerd/containerd/containers"
-	"github.com/containerd/containerd/namespaces"
-	"github.com/containerd/containerd/oci"
-	gocni "github.com/containerd/go-cni"
-	"github.com/docker/distribution/reference"
-	"github.com/opencontainers/runtime-spec/specs-go"
-	"github.com/openfaas/faas-provider/types"
-	cninetwork "github.com/openfaas/faasd/pkg/cninetwork"
-	"github.com/openfaas/faasd/pkg/service"
-	"github.com/pkg/errors"
-	"k8s.io/apimachinery/pkg/api/resource"
-)
-
-const annotationLabelPrefix = "com.openfaas.annotations."
-
-// MakeDeployHandler returns a handler to deploy a function
-func MakeDeployHandler(client *containerd.Client, cni gocni.CNI, secretMountPath string, alwaysPull bool) func(w http.ResponseWriter, r *http.Request) {
-	return func(w http.ResponseWriter, r *http.Request) {
-
-		if r.Body == nil {
-			http.Error(w, "expected a body", http.StatusBadRequest)
-			return
-		}
-
-		defer r.Body.Close()
-
-		body, _ := ioutil.ReadAll(r.Body)
-		log.Printf("[Deploy] request: %s\n", string(body))
-
-		req := types.FunctionDeployment{}
-		err := json.Unmarshal(body, &req)
-		if err != nil {
-			log.Printf("[Deploy] - error parsing input: %s\n", err)
-			http.Error(w, err.Error(), http.StatusBadRequest)
-
-			return
-		}
-
-		namespace := getRequestNamespace(req.Namespace)
-
-		// Check if namespace exists, and it has the openfaas label
-		valid, err := validNamespace(client.NamespaceService(), namespace)
-
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-
-		if !valid {
-			http.Error(w, "namespace not valid", http.StatusBadRequest)
-			return
-		}
-
-		namespaceSecretMountPath := getNamespaceSecretMountPath(secretMountPath, namespace)
-		err = validateSecrets(namespaceSecretMountPath, req.Secrets)
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-
-		name := req.Service
-		ctx := namespaces.WithNamespace(context.Background(), namespace)
-
-		deployErr := deploy(ctx, req, client, cni, namespaceSecretMountPath, alwaysPull)
-		if deployErr != nil {
-			log.Printf("[Deploy] error deploying %s, error: %s\n", name, deployErr)
-			http.Error(w, deployErr.Error(), http.StatusBadRequest)
-			return
-		}
-	}
-}
-
-// prepull is an optimization which means an image can be pulled before a deployment
-// request, since a deployment request first deletes the active function before
-// trying to deploy a new one.
-func prepull(ctx context.Context, req types.FunctionDeployment, client *containerd.Client, alwaysPull bool) (containerd.Image, error) {
-	start := time.Now()
-	r, err := reference.ParseNormalizedNamed(req.Image)
-	if err != nil {
-		return nil, err
-	}
-
-	imgRef := reference.TagNameOnly(r).String()
-
-	snapshotter := ""
-	if val, ok := os.LookupEnv("snapshotter"); ok {
-		snapshotter = val
-	}
-
-	image, err := service.PrepareImage(ctx, client, imgRef, snapshotter, alwaysPull)
-	if err != nil {
-		return nil, errors.Wrapf(err, "unable to pull image %s", imgRef)
-	}
-
-	size, _ := image.Size(ctx)
-	log.Printf("Image for: %s size: %d, took: %fs\n", image.Name(), size, time.Since(start).Seconds())
-
-	return image, nil
-}
-
-func deploy(ctx context.Context, req types.FunctionDeployment, client *containerd.Client, cni gocni.CNI, secretMountPath string, alwaysPull bool) error {
-
-	snapshotter := ""
-	if val, ok := os.LookupEnv("snapshotter"); ok {
-		snapshotter = val
-	}
-
-	image, err := prepull(ctx, req, client, alwaysPull)
-	if err != nil {
-		return err
-	}
-
-	envs := prepareEnv(req.EnvProcess, req.EnvVars)
-	mounts := getOSMounts()
-
-	for _, secret := range req.Secrets {
-		mounts = append(mounts, specs.Mount{
-			Destination: path.Join("/var/openfaas/secrets", secret),
-			Type:        "bind",
-			Source:      path.Join(secretMountPath, secret),
-			Options:     []string{"rbind", "ro"},
-		})
-	}
-
-	name := req.Service
-
-	labels, err := buildLabels(&req)
-	if err != nil {
-		return fmt.Errorf("unable to apply labels to container: %s, error: %w", name, err)
-	}
-
-	var memory *specs.LinuxMemory
-	if req.Limits != nil && len(req.Limits.Memory) > 0 {
-		memory = &specs.LinuxMemory{}
-
-		qty, err := resource.ParseQuantity(req.Limits.Memory)
-		if err != nil {
-			log.Printf("error parsing (%q) as quantity: %s", req.Limits.Memory, err.Error())
-		}
-		v := qty.Value()
-		memory.Limit = &v
-	}
-
-	container, err := client.NewContainer(
-		ctx,
-		name,
-		containerd.WithImage(image),
-		containerd.WithSnapshotter(snapshotter),
-		containerd.WithNewSnapshot(name+"-snapshot", image),
-		containerd.WithNewSpec(oci.WithImageConfig(image),
-			oci.WithHostname(name),
-			oci.WithCapabilities([]string{"CAP_NET_RAW"}),
-			oci.WithMounts(mounts),
-			oci.WithEnv(envs),
-			withMemory(memory)),
-		containerd.WithContainerLabels(labels),
-	)
-
-	if err != nil {
-		return fmt.Errorf("unable to create container: %s, error: %w", name, err)
-	}
-
-	return createTask(ctx, container, cni)
-
-}
-
-func buildLabels(request *types.FunctionDeployment) (map[string]string, error) {
-	// Adapted from faas-swarm/handlers/deploy.go:buildLabels
-	labels := map[string]string{}
-
-	if request.Labels != nil {
-		for k, v := range *request.Labels {
-			labels[k] = v
-		}
-	}
-
-	if request.Annotations != nil {
-		for k, v := range *request.Annotations {
-			key := fmt.Sprintf("%s%s", annotationLabelPrefix, k)
-			if _, ok := labels[key]; !ok {
-				labels[key] = v
-			} else {
-				return nil, errors.New(fmt.Sprintf("Key %s cannot be used as a label due to a conflict with annotation prefix %s", k, annotationLabelPrefix))
-			}
-		}
-	}
-
-	return labels, nil
-}
-
-func createTask(ctx context.Context, container containerd.Container, cni gocni.CNI) error {
-
-	name := container.ID()
-
-	task, taskErr := container.NewTask(ctx, cio.BinaryIO("/usr/local/bin/faasd", nil))
-
-	if taskErr != nil {
-		return fmt.Errorf("unable to start task: %s, error: %w", name, taskErr)
-	}
-
-	log.Printf("Container ID: %s\tTask ID %s:\tTask PID: %d\t\n", name, task.ID(), task.Pid())
-
-	labels := map[string]string{}
-	_, err := cninetwork.CreateCNINetwork(ctx, cni, task, labels)
-
-	if err != nil {
-		return err
-	}
-
-	ip, err := cninetwork.GetIPAddress(name, task.Pid())
-	if err != nil {
-		return err
-	}
-
-	log.Printf("%s has IP: %s.\n", name, ip)
-
-	_, waitErr := task.Wait(ctx)
-	if waitErr != nil {
-		return errors.Wrapf(waitErr, "Unable to wait for task to start: %s", name)
-	}
-
-	if startErr := task.Start(ctx); startErr != nil {
-		return errors.Wrapf(startErr, "Unable to start task: %s", name)
-	}
-	return nil
-}
-
-func prepareEnv(envProcess string, reqEnvVars map[string]string) []string {
-	envs := []string{}
-	fprocessFound := false
-	fprocess := "fprocess=" + envProcess
-	if len(envProcess) > 0 {
-		fprocessFound = true
-	}
-
-	for k, v := range reqEnvVars {
-		if k == "fprocess" {
-			fprocessFound = true
-			fprocess = v
-		} else {
-			envs = append(envs, k+"="+v)
-		}
-	}
-	if fprocessFound {
-		envs = append(envs, fprocess)
-	}
-	return envs
-}
-
-// getOSMounts provides a mount for os-specific files such
-// as the hosts file and resolv.conf
-func getOSMounts() []specs.Mount {
-	// Prior to hosts_dir env-var, this value was set to
-	// os.Getwd()
-	hostsDir := "/var/lib/faasd"
-	if v, ok := os.LookupEnv("hosts_dir"); ok && len(v) > 0 {
-		hostsDir = v
-	}
-
-	mounts := []specs.Mount{}
-	mounts = append(mounts, specs.Mount{
-		Destination: "/etc/resolv.conf",
-		Type:        "bind",
-		Source:      path.Join(hostsDir, "resolv.conf"),
-		Options:     []string{"rbind", "ro"},
-	})
-
-	mounts = append(mounts, specs.Mount{
-		Destination: "/etc/hosts",
-		Type:        "bind",
-		Source:      path.Join(hostsDir, "hosts"),
-		Options:     []string{"rbind", "ro"},
-	})
-	return mounts
-}
-
-func validateSecrets(secretMountPath string, secrets []string) error {
-	for _, secret := range secrets {
-		if _, err := os.Stat(path.Join(secretMountPath, secret)); err != nil {
-			return fmt.Errorf("unable to find secret: %s", secret)
-		}
-	}
-	return nil
-}
-
-func withMemory(mem *specs.LinuxMemory) oci.SpecOpts {
-	return func(ctx context.Context, _ oci.Client, c *containers.Container, s *oci.Spec) error {
-		if mem != nil {
-			if s.Linux == nil {
-				s.Linux = &specs.Linux{}
-			}
-			if s.Linux.Resources == nil {
-				s.Linux.Resources = &specs.LinuxResources{}
-			}
-			if s.Linux.Resources.Memory == nil {
-				s.Linux.Resources.Memory = &specs.LinuxMemory{}
-			}
-			s.Linux.Resources.Memory.Limit = mem.Limit
-		}
-		return nil
-	}
-}
--- a/pkg/provider/handlers/deploy_test.go
+++ b/pkg/provider/handlers/deploy_test.go
@ -1,77 +0,0 @@
-package handlers
-
-import (
-	"fmt"
-	"reflect"
-	"testing"
-
-	"github.com/openfaas/faas-provider/types"
-)
-
-func Test_BuildLabels_WithAnnotations(t *testing.T) {
-	// Test each combination of nil/non-nil annotation + label
-	tables := []struct {
-		name       string
-		label      map[string]string
-		annotation map[string]string
-		result     map[string]string
-	}{
-		{"Empty label and annotations returns empty table map", nil, nil, map[string]string{}},
-		{
-			"Label with empty annotation returns valid map",
-			map[string]string{"L1": "V1"},
-			nil,
-			map[string]string{"L1": "V1"}},
-		{
-			"Annotation with empty label returns valid map",
-			nil,
-			map[string]string{"A1": "V2"},
-			map[string]string{fmt.Sprintf("%sA1", annotationLabelPrefix): "V2"}},
-		{
-			"Label and annotation provided returns valid combined map",
-			map[string]string{"L1": "V1"},
-			map[string]string{"A1": "V2"},
-			map[string]string{
-				"L1": "V1",
-				fmt.Sprintf("%sA1", annotationLabelPrefix): "V2",
-			},
-		},
-	}
-
-	for _, tc := range tables {
-
-		t.Run(tc.name, func(t *testing.T) {
-			request := &types.FunctionDeployment{
-				Labels:      &tc.label,
-				Annotations: &tc.annotation,
-			}
-
-			val, err := buildLabels(request)
-
-			if err != nil {
-				t.Fatalf("want: no error got: %v", err)
-			}
-
-			if !reflect.DeepEqual(val, tc.result) {
-				t.Errorf("Want: %s, got: %s", val, tc.result)
-			}
-		})
-	}
-}
-
-func Test_BuildLabels_WithAnnotationCollision(t *testing.T) {
-	request := &types.FunctionDeployment{
-		Labels: &map[string]string{
-			"function_name": "echo",
-			fmt.Sprintf("%scurrent-time", annotationLabelPrefix): "Wed 25 Jul 06:41:43 BST 2018",
-		},
-		Annotations: &map[string]string{"current-time": "Wed 25 Jul 06:41:43 BST 2018"},
-	}
-
-	val, err := buildLabels(request)
-
-	if err == nil {
-		t.Errorf("Expected an error, got %d values", len(val))
-	}
-
-}
--- a/pkg/provider/handlers/functions.go
+++ b/pkg/provider/handlers/functions.go
@ -1,242 +0,0 @@
-package handlers
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"log"
-	"strings"
-	"time"
-
-	"github.com/opencontainers/runtime-spec/specs-go"
-
-	"github.com/containerd/containerd"
-	"github.com/containerd/containerd/namespaces"
-	"github.com/openfaas/faasd/pkg"
-	faasd "github.com/openfaas/faasd/pkg"
-	"github.com/openfaas/faasd/pkg/cninetwork"
-)
-
-type Function struct {
-	name        string
-	namespace   string
-	image       string
-	pid         uint32
-	replicas    int
-	IP          string
-	labels      map[string]string
-	annotations map[string]string
-	secrets     []string
-	envVars     map[string]string
-	envProcess  string
-	memoryLimit int64
-	createdAt   time.Time
-}
-
-// ListFunctions returns a map of all functions with running tasks on namespace
-func ListFunctions(client *containerd.Client, namespace string) (map[string]*Function, error) {
-
-	// Check if namespace exists, and it has the openfaas label
-	valid, err := validNamespace(client.NamespaceService(), namespace)
-	if err != nil {
-		return nil, err
-	}
-
-	if !valid {
-		return nil, errors.New("namespace not valid")
-	}
-
-	ctx := namespaces.WithNamespace(context.Background(), namespace)
-	functions := make(map[string]*Function)
-
-	containers, err := client.Containers(ctx)
-	if err != nil {
-		return functions, err
-	}
-
-	for _, c := range containers {
-		name := c.ID()
-		f, err := GetFunction(client, name, namespace)
-		if err != nil {
-			log.Printf("error getting function %s: ", name)
-			return functions, err
-		}
-		functions[name] = &f
-	}
-
-	return functions, nil
-}
-
-// GetFunction returns a function that matches name
-func GetFunction(client *containerd.Client, name string, namespace string) (Function, error) {
-	ctx := namespaces.WithNamespace(context.Background(), namespace)
-	fn := Function{}
-
-	c, err := client.LoadContainer(ctx, name)
-	if err != nil {
-		return Function{}, fmt.Errorf("unable to find function: %s, error %w", name, err)
-	}
-
-	image, err := c.Image(ctx)
-	if err != nil {
-		return fn, err
-	}
-
-	containerName := c.ID()
-	allLabels, labelErr := c.Labels(ctx)
-
-	if labelErr != nil {
-		log.Printf("cannot list container %s labels: %s", containerName, labelErr)
-	}
-
-	labels, annotations := buildLabelsAndAnnotations(allLabels)
-
-	spec, err := c.Spec(ctx)
-	if err != nil {
-		return Function{}, fmt.Errorf("unable to load function %s error: %w", name, err)
-	}
-
-	info, err := c.Info(ctx)
-	if err != nil {
-		return Function{}, fmt.Errorf("can't load info for: %s, error %w", name, err)
-	}
-
-	envVars, envProcess := readEnvFromProcessEnv(spec.Process.Env)
-	secrets := readSecretsFromMounts(spec.Mounts)
-
-	fn.name = containerName
-	fn.namespace = namespace
-	fn.image = image.Name()
-	fn.labels = labels
-	fn.annotations = annotations
-	fn.secrets = secrets
-	fn.envVars = envVars
-	fn.envProcess = envProcess
-	fn.createdAt = info.CreatedAt
-	fn.memoryLimit = readMemoryLimitFromSpec(spec)
-
-	replicas := 0
-	task, err := c.Task(ctx, nil)
-	if err == nil {
-		// Task for container exists
-		svc, err := task.Status(ctx)
-		if err != nil {
-			return Function{}, fmt.Errorf("unable to get task status for container: %s %w", name, err)
-		}
-
-		if svc.Status == "running" {
-			replicas = 1
-			fn.pid = task.Pid()
-
-			// Get container IP address
-			ip, err := cninetwork.GetIPAddress(name, task.Pid())
-			if err != nil {
-				return Function{}, err
-			}
-			fn.IP = ip
-		}
-	} else {
-		replicas = 0
-	}
-
-	fn.replicas = replicas
-	return fn, nil
-}
-
-func readEnvFromProcessEnv(env []string) (map[string]string, string) {
-	foundEnv := make(map[string]string)
-	fprocess := ""
-	for _, e := range env {
-		kv := strings.Split(e, "=")
-		if len(kv) == 1 {
-			continue
-		}
-
-		if kv[0] == "PATH" {
-			continue
-		}
-
-		if kv[0] == "fprocess" {
-			fprocess = kv[1]
-			continue
-		}
-
-		foundEnv[kv[0]] = kv[1]
-	}
-
-	return foundEnv, fprocess
-}
-
-func readSecretsFromMounts(mounts []specs.Mount) []string {
-	secrets := []string{}
-	for _, mnt := range mounts {
-		x := strings.Split(mnt.Destination, "/var/openfaas/secrets/")
-		if len(x) > 1 {
-			secrets = append(secrets, x[1])
-		}
-
-	}
-	return secrets
-}
-
-// buildLabelsAndAnnotations returns a separated list with labels first,
-// followed by annotations by checking each key of ctrLabels for a prefix.
-func buildLabelsAndAnnotations(ctrLabels map[string]string) (map[string]string, map[string]string) {
-	labels := make(map[string]string)
-	annotations := make(map[string]string)
-
-	for k, v := range ctrLabels {
-		if strings.HasPrefix(k, annotationLabelPrefix) {
-			annotations[strings.TrimPrefix(k, annotationLabelPrefix)] = v
-		} else {
-			labels[k] = v
-		}
-	}
-
-	return labels, annotations
-}
-
-func ListNamespaces(client *containerd.Client) []string {
-	set := []string{}
-	store := client.NamespaceService()
-	namespaces, err := store.List(context.Background())
-	if err != nil {
-		log.Printf("Error listing namespaces: %s", err.Error())
-		set = append(set, faasd.DefaultFunctionNamespace)
-		return set
-	}
-
-	for _, namespace := range namespaces {
-		labels, err := store.Labels(context.Background(), namespace)
-		if err != nil {
-			log.Printf("Error listing label for namespace %s: %s", namespace, err.Error())
-			continue
-		}
-
-		if _, found := labels[pkg.NamespaceLabel]; found {
-			set = append(set, namespace)
-		}
-
-		if !findNamespace(faasd.DefaultFunctionNamespace, set) {
-			set = append(set, faasd.DefaultFunctionNamespace)
-		}
-	}
-
-	return set
-}
-
-func findNamespace(target string, items []string) bool {
-	for _, n := range items {
-		if n == target {
-			return true
-		}
-	}
-	return false
-}
-
-func readMemoryLimitFromSpec(spec *specs.Spec) int64 {
-	if spec.Linux == nil || spec.Linux.Resources == nil || spec.Linux.Resources.Memory == nil || spec.Linux.Resources.Memory.Limit == nil {
-		return 0
-	}
-	return *spec.Linux.Resources.Memory.Limit
-}
--- a/pkg/provider/handlers/functions_test.go
+++ b/pkg/provider/handlers/functions_test.go
@ -1,133 +0,0 @@
-package handlers
-
-import (
-	"fmt"
-	"reflect"
-	"testing"
-
-	"github.com/opencontainers/runtime-spec/specs-go"
-)
-
-func Test_BuildLabelsAndAnnotationsFromServiceSpec_Annotations(t *testing.T) {
-	container := map[string]string{
-		"qwer": "ty",
-		"dvor": "ak",
-		fmt.Sprintf("%scurrent-time", annotationLabelPrefix): "5 Nov 20:10:20 PST 1955",
-		fmt.Sprintf("%sfuture-time", annotationLabelPrefix):  "21 Oct 20:10:20 PST 2015",
-	}
-
-	labels, annotation := buildLabelsAndAnnotations(container)
-
-	if len(labels) != 2 {
-		t.Errorf("want: %d labels got: %d", 2, len(labels))
-	}
-
-	if len(annotation) != 2 {
-		t.Errorf("want: %d annotation got: %d", 1, len(annotation))
-	}
-
-	if _, ok := annotation["current-time"]; !ok {
-		t.Errorf("want: '%s' entry in annotation map got: key not found", "current-time")
-	}
-}
-
-func Test_SplitMountToSecrets(t *testing.T) {
-	type testCase struct {
-		Name  string
-		Input []specs.Mount
-		Want  []string
-	}
-	tests := []testCase{
-		{Name: "No matching openfaas secrets", Input: []specs.Mount{{Destination: "/foo/"}}, Want: []string{}},
-		{Name: "Nil mounts", Input: nil, Want: []string{}},
-		{Name: "No Mounts", Input: []specs.Mount{{Destination: "/foo/"}}, Want: []string{}},
-		{Name: "One Mounts IS secret", Input: []specs.Mount{{Destination: "/var/openfaas/secrets/secret1"}}, Want: []string{"secret1"}},
-		{Name: "Multiple Mounts 1 secret", Input: []specs.Mount{{Destination: "/var/openfaas/secrets/secret1"}, {Destination: "/some/other/path"}}, Want: []string{"secret1"}},
-		{Name: "Multiple Mounts all secrets", Input: []specs.Mount{{Destination: "/var/openfaas/secrets/secret1"}, {Destination: "/var/openfaas/secrets/secret2"}}, Want: []string{"secret1", "secret2"}},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.Name, func(t *testing.T) {
-			got := readSecretsFromMounts(tc.Input)
-			if !reflect.DeepEqual(got, tc.Want) {
-				t.Fatalf("Want %s, got %s", tc.Want, got)
-			}
-		})
-	}
-}
-
-func Test_ProcessEnvToEnvVars(t *testing.T) {
-	type testCase struct {
-		Name     string
-		Input    []string
-		Want     map[string]string
-		fprocess string
-	}
-	tests := []testCase{
-		{Name: "No matching EnvVars", Input: []string{"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", "fprocess=python index.py"}, Want: make(map[string]string), fprocess: "python index.py"},
-		{Name: "No EnvVars", Input: []string{}, Want: make(map[string]string), fprocess: ""},
-		{Name: "One EnvVar", Input: []string{"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", "fprocess=python index.py", "env=this"}, Want: map[string]string{"env": "this"}, fprocess: "python index.py"},
-		{Name: "Multiple EnvVars", Input: []string{"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", "this=that", "env=var", "fprocess=python index.py"}, Want: map[string]string{"this": "that", "env": "var"}, fprocess: "python index.py"},
-		{Name: "Nil EnvVars", Input: nil, Want: make(map[string]string)},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.Name, func(t *testing.T) {
-			got, fprocess := readEnvFromProcessEnv(tc.Input)
-			if !reflect.DeepEqual(got, tc.Want) {
-				t.Fatalf("Want: %s, got: %s", tc.Want, got)
-			}
-
-			if fprocess != tc.fprocess {
-				t.Fatalf("Want fprocess: %s, got: %s", tc.fprocess, got)
-
-			}
-		})
-	}
-}
-
-func Test_findNamespace(t *testing.T) {
-	type testCase struct {
-		Name            string
-		foundNamespaces []string
-		namespace       string
-		Want            bool
-	}
-	tests := []testCase{
-		{Name: "Namespace Found", namespace: "fn", foundNamespaces: []string{"fn", "openfaas-fn"}, Want: true},
-		{Name: "namespace Not Found", namespace: "fn", foundNamespaces: []string{"openfaas-fn"}, Want: false},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.Name, func(t *testing.T) {
-			got := findNamespace(tc.namespace, tc.foundNamespaces)
-			if got != tc.Want {
-				t.Fatalf("Want %t, got %t", tc.Want, got)
-			}
-		})
-	}
-}
-
-func Test_readMemoryLimitFromSpec(t *testing.T) {
-	type testCase struct {
-		Name string
-		Spec *specs.Spec
-		Want int64
-	}
-	testLimit := int64(64)
-	tests := []testCase{
-		{Name: "specs.Linux not found", Spec: &specs.Spec{Linux: nil}, Want: int64(0)},
-		{Name: "specs.LinuxResource not found", Spec: &specs.Spec{Linux: &specs.Linux{Resources: nil}}, Want: int64(0)},
-		{Name: "specs.LinuxMemory not found", Spec: &specs.Spec{Linux: &specs.Linux{Resources: &specs.LinuxResources{Memory: nil}}}, Want: int64(0)},
-		{Name: "specs.LinuxMemory.Limit not found", Spec: &specs.Spec{Linux: &specs.Linux{Resources: &specs.LinuxResources{Memory: &specs.LinuxMemory{Limit: nil}}}}, Want: int64(0)},
-		{Name: "Memory limit set as Want", Spec: &specs.Spec{Linux: &specs.Linux{Resources: &specs.LinuxResources{Memory: &specs.LinuxMemory{Limit: &testLimit}}}}, Want: int64(64)},
-	}
-	for _, tc := range tests {
-		t.Run(tc.Name, func(t *testing.T) {
-			got := readMemoryLimitFromSpec(tc.Spec)
-			if got != tc.Want {
-				t.Fatalf("Want %d, got %d", tc.Want, got)
-			}
-		})
-	}
-}
--- a/pkg/provider/handlers/info.go
+++ b/pkg/provider/handlers/info.go
@ -1,44 +0,0 @@
-package handlers
-
-import (
-	"encoding/json"
-	"net/http"
-
-	"github.com/openfaas/faas-provider/types"
-)
-
-const (
-	// OrchestrationIdentifier identifier string for provider orchestration
-	OrchestrationIdentifier = "containerd"
-
-	// ProviderName name of the provider
-	ProviderName = "faasd"
-)
-
-//MakeInfoHandler creates handler for /system/info endpoint
-func MakeInfoHandler(version, sha string) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		if r.Body != nil {
-			defer r.Body.Close()
-		}
-
-		infoResponse := types.ProviderInfo{
-			Orchestration: OrchestrationIdentifier,
-			Name:          ProviderName,
-			Version: &types.VersionInfo{
-				Release: version,
-				SHA:     sha,
-			},
-		}
-
-		jsonOut, marshalErr := json.Marshal(infoResponse)
-		if marshalErr != nil {
-			w.WriteHeader(http.StatusInternalServerError)
-			return
-		}
-
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		w.Write(jsonOut)
-	}
-}
--- a/pkg/provider/handlers/info_test.go
+++ b/pkg/provider/handlers/info_test.go
@ -1,39 +0,0 @@
-package handlers
-
-import (
-	"encoding/json"
-	"github.com/openfaas/faas-provider/types"
-	"net/http/httptest"
-	"testing"
-)
-
-func Test_InfoHandler(t *testing.T) {
-	sha := "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
-	version := "0.0.1"
-	handler := MakeInfoHandler(version, sha)
-	w := httptest.NewRecorder()
-	r := httptest.NewRequest("GET", "/", nil)
-	handler(w, r)
-
-	resp := types.ProviderInfo{}
-	err := json.Unmarshal(w.Body.Bytes(), &resp)
-	if err != nil {
-		t.Fatalf("unexpected error unmarshalling the response")
-	}
-
-	if resp.Name != ProviderName {
-		t.Fatalf("expected provider %q, got %q", ProviderName, resp.Name)
-	}
-
-	if resp.Orchestration != OrchestrationIdentifier {
-		t.Fatalf("expected orchestration %q, got %q", OrchestrationIdentifier, resp.Orchestration)
-	}
-
-	if resp.Version.SHA != sha {
-		t.Fatalf("expected orchestration %q, got %q", sha, resp.Version.SHA)
-	}
-
-	if resp.Version.Release != version {
-		t.Fatalf("expected release %q, got %q", version, resp.Version.Release)
-	}
-}
--- a/pkg/provider/handlers/invoke_resolver.go
+++ b/pkg/provider/handlers/invoke_resolver.go
@ -1,56 +0,0 @@
-package handlers
-
-import (
-	"fmt"
-	"log"
-	"net/url"
-	"strings"
-
-	"github.com/containerd/containerd"
-	faasd "github.com/openfaas/faasd/pkg"
-)
-
-const watchdogPort = 8080
-
-type InvokeResolver struct {
-	client *containerd.Client
-}
-
-func NewInvokeResolver(client *containerd.Client) *InvokeResolver {
-	return &InvokeResolver{client: client}
-}
-
-func (i *InvokeResolver) Resolve(functionName string) (url.URL, error) {
-	actualFunctionName := functionName
-	log.Printf("Resolve: %q\n", actualFunctionName)
-
-	namespace := getNamespace(functionName, faasd.DefaultFunctionNamespace)
-
-	if strings.Contains(functionName, ".") {
-		actualFunctionName = strings.TrimSuffix(functionName, "."+namespace)
-	}
-
-	function, err := GetFunction(i.client, actualFunctionName, namespace)
-	if err != nil {
-		return url.URL{}, fmt.Errorf("%s not found", actualFunctionName)
-	}
-
-	serviceIP := function.IP
-
-	urlStr := fmt.Sprintf("http://%s:%d", serviceIP, watchdogPort)
-
-	urlRes, err := url.Parse(urlStr)
-	if err != nil {
-		return url.URL{}, err
-	}
-
-	return *urlRes, nil
-}
-
-func getNamespace(name, defaultNamespace string) string {
-	namespace := defaultNamespace
-	if strings.Contains(name, ".") {
-		namespace = name[strings.LastIndexAny(name, ".")+1:]
-	}
-	return namespace
-}
--- a/pkg/provider/handlers/namespaces.go
+++ b/pkg/provider/handlers/namespaces.go
@ -1,18 +0,0 @@
-package handlers
-
-import (
-	"encoding/json"
-	"net/http"
-
-	"github.com/containerd/containerd"
-)
-
-func MakeNamespacesLister(client *containerd.Client) func(w http.ResponseWriter, r *http.Request) {
-	return func(w http.ResponseWriter, r *http.Request) {
-		list := ListNamespaces(client)
-		body, _ := json.Marshal(list)
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		w.Write(body)
-	}
-}
--- a/pkg/provider/handlers/read.go
+++ b/pkg/provider/handlers/read.go
@ -1,71 +0,0 @@
-package handlers
-
-import (
-	"encoding/json"
-	"log"
-	"net/http"
-
-	"k8s.io/apimachinery/pkg/api/resource"
-
-	"github.com/containerd/containerd"
-	"github.com/openfaas/faas-provider/types"
-)
-
-func MakeReadHandler(client *containerd.Client) func(w http.ResponseWriter, r *http.Request) {
-
-	return func(w http.ResponseWriter, r *http.Request) {
-
-		lookupNamespace := getRequestNamespace(readNamespaceFromQuery(r))
-		// Check if namespace exists, and it has the openfaas label
-		valid, err := validNamespace(client.NamespaceService(), lookupNamespace)
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-
-		if !valid {
-			http.Error(w, "namespace not valid", http.StatusBadRequest)
-			return
-		}
-
-		res := []types.FunctionStatus{}
-		fns, err := ListFunctions(client, lookupNamespace)
-		if err != nil {
-			log.Printf("[Read] error listing functions. Error: %s\n", err)
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-
-		for _, fn := range fns {
-			annotations := &fn.annotations
-			labels := &fn.labels
-			memory := resource.NewQuantity(fn.memoryLimit, resource.BinarySI)
-			status := types.FunctionStatus{
-				Name:        fn.name,
-				Image:       fn.image,
-				Replicas:    uint64(fn.replicas),
-				Namespace:   fn.namespace,
-				Labels:      labels,
-				Annotations: annotations,
-				Secrets:     fn.secrets,
-				EnvVars:     fn.envVars,
-				EnvProcess:  fn.envProcess,
-				CreatedAt:   fn.createdAt,
-			}
-
-			// Do not remove below memory check for 0
-			// Memory limit should not be included in status until set explicitly
-			limit := &types.FunctionResources{Memory: memory.String()}
-			if limit.Memory != "0" {
-				status.Limits = limit
-			}
-
-			res = append(res, status)
-		}
-
-		body, _ := json.Marshal(res)
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		w.Write(body)
-	}
-}
--- a/pkg/provider/handlers/replicas.go
+++ b/pkg/provider/handlers/replicas.go
@ -1,54 +0,0 @@
-package handlers
-
-import (
-	"encoding/json"
-	"net/http"
-
-	"github.com/containerd/containerd"
-	"github.com/gorilla/mux"
-	"github.com/openfaas/faas-provider/types"
-)
-
-func MakeReplicaReaderHandler(client *containerd.Client) func(w http.ResponseWriter, r *http.Request) {
-
-	return func(w http.ResponseWriter, r *http.Request) {
-		vars := mux.Vars(r)
-		functionName := vars["name"]
-		lookupNamespace := getRequestNamespace(readNamespaceFromQuery(r))
-
-		// Check if namespace exists, and it has the openfaas label
-		valid, err := validNamespace(client.NamespaceService(), lookupNamespace)
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-
-		if !valid {
-			http.Error(w, "namespace not valid", http.StatusBadRequest)
-			return
-		}
-
-		if f, err := GetFunction(client, functionName, lookupNamespace); err == nil {
-			found := types.FunctionStatus{
-				Name:              functionName,
-				Image:             f.image,
-				AvailableReplicas: uint64(f.replicas),
-				Replicas:          uint64(f.replicas),
-				Namespace:         f.namespace,
-				Labels:            &f.labels,
-				Annotations:       &f.annotations,
-				Secrets:           f.secrets,
-				EnvVars:           f.envVars,
-				EnvProcess:        f.envProcess,
-				CreatedAt:         f.createdAt,
-			}
-
-			functionBytes, _ := json.Marshal(found)
-			w.Header().Set("Content-Type", "application/json")
-			w.WriteHeader(http.StatusOK)
-			w.Write(functionBytes)
-		} else {
-			w.WriteHeader(http.StatusNotFound)
-		}
-	}
-}
--- a/pkg/provider/handlers/scale.go
+++ b/pkg/provider/handlers/scale.go
@ -1,142 +0,0 @@
-package handlers
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net/http"
-
-	"github.com/containerd/containerd"
-	"github.com/containerd/containerd/namespaces"
-	gocni "github.com/containerd/go-cni"
-
-	"github.com/openfaas/faas-provider/types"
-)
-
-func MakeReplicaUpdateHandler(client *containerd.Client, cni gocni.CNI) func(w http.ResponseWriter, r *http.Request) {
-
-	return func(w http.ResponseWriter, r *http.Request) {
-
-		if r.Body == nil {
-			http.Error(w, "expected a body", http.StatusBadRequest)
-			return
-		}
-
-		defer r.Body.Close()
-
-		body, _ := ioutil.ReadAll(r.Body)
-		log.Printf("[Scale] request: %s\n", string(body))
-
-		req := types.ScaleServiceRequest{}
-		err := json.Unmarshal(body, &req)
-
-		if err != nil {
-			log.Printf("[Scale] error parsing input: %s\n", err)
-			http.Error(w, err.Error(), http.StatusBadRequest)
-
-			return
-		}
-
-		namespace := getRequestNamespace(readNamespaceFromQuery(r))
-
-		// Check if namespace exists, and it has the openfaas label
-		valid, err := validNamespace(client.NamespaceService(), namespace)
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-
-		if !valid {
-			http.Error(w, "namespace not valid", http.StatusBadRequest)
-			return
-		}
-
-		name := req.ServiceName
-
-		if _, err := GetFunction(client, name, namespace); err != nil {
-			msg := fmt.Sprintf("service %s not found", name)
-			log.Printf("[Scale] %s\n", msg)
-			http.Error(w, msg, http.StatusNotFound)
-			return
-		}
-
-		ctx := namespaces.WithNamespace(context.Background(), namespace)
-
-		ctr, ctrErr := client.LoadContainer(ctx, name)
-		if ctrErr != nil {
-			msg := fmt.Sprintf("cannot load service %s, error: %s", name, ctrErr)
-			log.Printf("[Scale] %s\n", msg)
-			http.Error(w, msg, http.StatusNotFound)
-			return
-		}
-
-		var taskExists bool
-		var taskStatus *containerd.Status
-
-		task, taskErr := ctr.Task(ctx, nil)
-		if taskErr != nil {
-			msg := fmt.Sprintf("cannot load task for service %s, error: %s", name, taskErr)
-			log.Printf("[Scale] %s\n", msg)
-			taskExists = false
-		} else {
-			taskExists = true
-			status, statusErr := task.Status(ctx)
-			if statusErr != nil {
-				msg := fmt.Sprintf("cannot load task status for %s, error: %s", name, statusErr)
-				log.Printf("[Scale] %s\n", msg)
-				http.Error(w, msg, http.StatusInternalServerError)
-				return
-			} else {
-				taskStatus = &status
-			}
-		}
-
-		createNewTask := false
-
-		// Scale to zero
-		if req.Replicas == 0 {
-			// If a task is running, pause it
-			if taskExists && taskStatus.Status == containerd.Running {
-				if pauseErr := task.Pause(ctx); pauseErr != nil {
-					wrappedPauseErr := fmt.Errorf("error pausing task %s, error: %s", name, pauseErr)
-					log.Printf("[Scale] %s\n", wrappedPauseErr.Error())
-					http.Error(w, wrappedPauseErr.Error(), http.StatusNotFound)
-					return
-				}
-			}
-		}
-
-		if taskExists {
-			if taskStatus != nil {
-				if taskStatus.Status == containerd.Paused {
-					if resumeErr := task.Resume(ctx); resumeErr != nil {
-						log.Printf("[Scale] error resuming task %s, error: %s\n", name, resumeErr)
-						http.Error(w, resumeErr.Error(), http.StatusBadRequest)
-						return
-					}
-				} else if taskStatus.Status == containerd.Stopped {
-					// Stopped tasks cannot be restarted, must be removed, and created again
-					if _, delErr := task.Delete(ctx); delErr != nil {
-						log.Printf("[Scale] error deleting stopped task %s, error: %s\n", name, delErr)
-						http.Error(w, delErr.Error(), http.StatusBadRequest)
-						return
-					}
-					createNewTask = true
-				}
-			}
-		} else {
-			createNewTask = true
-		}
-
-		if createNewTask {
-			deployErr := createTask(ctx, ctr, cni)
-			if deployErr != nil {
-				log.Printf("[Scale] error deploying %s, error: %s\n", name, deployErr)
-				http.Error(w, deployErr.Error(), http.StatusBadRequest)
-				return
-			}
-		}
-	}
-}
--- a/pkg/provider/handlers/secret.go
+++ b/pkg/provider/handlers/secret.go
@ -1,178 +0,0 @@
-package handlers
-
-import (
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"os"
-	"path"
-	"strings"
-
-	"github.com/openfaas/faas-provider/types"
-	provider "github.com/openfaas/faasd/pkg/provider"
-)
-
-const secretFilePermission = 0644
-const secretDirPermission = 0755
-
-func MakeSecretHandler(store provider.Labeller, mountPath string) func(w http.ResponseWriter, r *http.Request) {
-
-	err := os.MkdirAll(mountPath, secretFilePermission)
-	if err != nil {
-		log.Printf("Creating path: %s, error: %s\n", mountPath, err)
-	}
-
-	return func(w http.ResponseWriter, r *http.Request) {
-		if r.Body != nil {
-			defer r.Body.Close()
-		}
-
-		switch r.Method {
-		case http.MethodGet:
-			listSecrets(store, w, r, mountPath)
-		case http.MethodPost:
-			createSecret(w, r, mountPath)
-		case http.MethodPut:
-			createSecret(w, r, mountPath)
-		case http.MethodDelete:
-			deleteSecret(w, r, mountPath)
-		default:
-			w.WriteHeader(http.StatusBadRequest)
-			return
-		}
-
-	}
-}
-
-func listSecrets(store provider.Labeller, w http.ResponseWriter, r *http.Request, mountPath string) {
-
-	lookupNamespace := getRequestNamespace(readNamespaceFromQuery(r))
-	// Check if namespace exists, and it has the openfaas label
-	valid, err := validNamespace(store, lookupNamespace)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-
-	if !valid {
-		http.Error(w, "namespace not valid", http.StatusBadRequest)
-		return
-	}
-
-	mountPath = getNamespaceSecretMountPath(mountPath, lookupNamespace)
-
-	files, err := os.ReadDir(mountPath)
-	if os.IsNotExist(err) {
-		bytesOut, _ := json.Marshal([]types.Secret{})
-		w.Write(bytesOut)
-		return
-	}
-
-	if err != nil {
-		fmt.Printf("Error Occured: %s \n", err)
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	secrets := []types.Secret{}
-	for _, f := range files {
-		secrets = append(secrets, types.Secret{Name: f.Name(), Namespace: lookupNamespace})
-	}
-
-	bytesOut, _ := json.Marshal(secrets)
-	w.Write(bytesOut)
-}
-
-func createSecret(w http.ResponseWriter, r *http.Request, mountPath string) {
-	secret, err := parseSecret(r)
-	if err != nil {
-		log.Printf("[secret] error %s", err.Error())
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	err = validateSecret(secret)
-	if err != nil {
-		log.Printf("[secret] error %s", err.Error())
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-
-	log.Printf("[secret] is valid: %q", secret.Name)
-	namespace := getRequestNamespace(secret.Namespace)
-	mountPath = getNamespaceSecretMountPath(mountPath, namespace)
-
-	err = os.MkdirAll(mountPath, secretDirPermission)
-	if err != nil {
-		log.Printf("[secret] error %s", err.Error())
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	data := secret.RawValue
-	if len(data) == 0 {
-		data = []byte(secret.Value)
-	}
-
-	err = ioutil.WriteFile(path.Join(mountPath, secret.Name), data, secretFilePermission)
-
-	if err != nil {
-		log.Printf("[secret] error %s", err.Error())
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-}
-
-func deleteSecret(w http.ResponseWriter, r *http.Request, mountPath string) {
-	secret, err := parseSecret(r)
-	if err != nil {
-		log.Printf("[secret] error %s", err.Error())
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	namespace := getRequestNamespace(readNamespaceFromQuery(r))
-	mountPath = getNamespaceSecretMountPath(mountPath, namespace)
-
-	err = os.Remove(path.Join(mountPath, secret.Name))
-
-	if err != nil {
-		log.Printf("[secret] error %s", err.Error())
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-}
-
-func parseSecret(r *http.Request) (types.Secret, error) {
-	secret := types.Secret{}
-	bytesOut, err := ioutil.ReadAll(r.Body)
-	if err != nil {
-		return secret, err
-	}
-
-	err = json.Unmarshal(bytesOut, &secret)
-	if err != nil {
-		return secret, err
-	}
-
-	return secret, err
-}
-
-const traverseErrorSt = "directory traversal found in name"
-
-func isTraversal(name string) bool {
-	return strings.Contains(name, fmt.Sprintf("%s", string(os.PathSeparator))) ||
-		strings.Contains(name, "..")
-}
-
-func validateSecret(secret types.Secret) error {
-	if strings.TrimSpace(secret.Name) == "" {
-		return fmt.Errorf("non-empty name is required")
-	}
-	if isTraversal(secret.Name) {
-		return fmt.Errorf(traverseErrorSt)
-	}
-	return nil
-}
--- a/pkg/provider/handlers/secret_test.go
+++ b/pkg/provider/handlers/secret_test.go
@ -1,252 +0,0 @@
-package handlers
-
-import (
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"reflect"
-	"strings"
-	"testing"
-
-	"github.com/openfaas/faas-provider/types"
-	"github.com/openfaas/faasd/pkg"
-	provider "github.com/openfaas/faasd/pkg/provider"
-)
-
-func Test_parseSecret(t *testing.T) {
-	cases := []struct {
-		name      string
-		payload   string
-		expError  string
-		expSecret types.Secret
-	}{
-		{
-			name:      "no error when name is valid without extention and with no traversal",
-			payload:   `{"name": "authorized_keys", "value": "foo"}`,
-			expSecret: types.Secret{Name: "authorized_keys", Value: "foo"},
-		},
-		{
-			name:      "no error when name is valid and parses RawValue correctly",
-			payload:   `{"name": "authorized_keys", "rawValue": "YmFy"}`,
-			expSecret: types.Secret{Name: "authorized_keys", RawValue: []byte("bar")},
-		},
-		{
-			name:      "no error when name is valid with dot and with no traversal",
-			payload:   `{"name": "authorized.keys", "value": "foo"}`,
-			expSecret: types.Secret{Name: "authorized.keys", Value: "foo"},
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			reader := strings.NewReader(tc.payload)
-			r := httptest.NewRequest(http.MethodPost, "/", reader)
-			secret, err := parseSecret(r)
-			if err != nil && tc.expError == "" {
-				t.Fatalf("unexpected error: %s", err)
-				return
-			}
-
-			if tc.expError != "" {
-				if err == nil {
-					t.Fatalf("expected error: %s, got nil", tc.expError)
-				}
-				if err.Error() != tc.expError {
-					t.Fatalf("expected error: %s, got: %s", tc.expError, err)
-				}
-
-				return
-			}
-
-			if !reflect.DeepEqual(secret, tc.expSecret) {
-				t.Fatalf("expected secret: %+v, got: %+v", tc.expSecret, secret)
-			}
-		})
-	}
-}
-
-func TestSecretCreation(t *testing.T) {
-	mountPath, err := os.MkdirTemp("", "test_secret_creation")
-	if err != nil {
-		t.Fatalf("unexpected error while creating temp directory: %s", err)
-	}
-
-	defer os.RemoveAll(mountPath)
-
-	handler := MakeSecretHandler(nil, mountPath)
-
-	cases := []struct {
-		name       string
-		verb       string
-		payload    string
-		status     int
-		secretPath string
-		secret     string
-		err        string
-	}{
-		{
-			name:    "returns error when the name contains a traversal",
-			verb:    http.MethodPost,
-			payload: `{"name": "/root/.ssh/authorized_keys", "value": "foo"}`,
-			status:  http.StatusBadRequest,
-			err:     "directory traversal found in name\n",
-		},
-		{
-			name:    "returns error when the name contains a traversal",
-			verb:    http.MethodPost,
-			payload: `{"name": "..", "value": "foo"}`,
-			status:  http.StatusBadRequest,
-			err:     "directory traversal found in name\n",
-		},
-		{
-			name:    "empty request returns a validation error",
-			verb:    http.MethodPost,
-			payload: `{}`,
-			status:  http.StatusBadRequest,
-			err:     "non-empty name is required\n",
-		},
-		{
-			name:       "can create secret from string",
-			verb:       http.MethodPost,
-			payload:    `{"name": "foo", "value": "bar"}`,
-			status:     http.StatusOK,
-			secretPath: "/openfaas-fn/foo",
-			secret:     "bar",
-		},
-		{
-			name:       "can create secret from raw value",
-			verb:       http.MethodPost,
-			payload:    `{"name": "foo", "rawValue": "YmFy"}`,
-			status:     http.StatusOK,
-			secretPath: "/openfaas-fn/foo",
-			secret:     "bar",
-		},
-		{
-			name:       "can create secret in non-default namespace from raw value",
-			verb:       http.MethodPost,
-			payload:    `{"name": "pity", "rawValue": "dGhlIGZvbw==", "namespace": "a-team"}`,
-			status:     http.StatusOK,
-			secretPath: "/a-team/pity",
-			secret:     "the foo",
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			req := httptest.NewRequest(tc.verb, "http://example.com/foo", strings.NewReader(tc.payload))
-			w := httptest.NewRecorder()
-
-			handler(w, req)
-
-			resp := w.Result()
-			if resp.StatusCode != tc.status {
-				t.Logf("response body: %s", w.Body.String())
-				t.Fatalf("expected status: %d, got: %d", tc.status, resp.StatusCode)
-			}
-
-			if resp.StatusCode != http.StatusOK && w.Body.String() != tc.err {
-				t.Fatalf("expected error message: %q, got %q", tc.err, w.Body.String())
-
-			}
-
-			if tc.secretPath != "" {
-				data, err := os.ReadFile(filepath.Join(mountPath, tc.secretPath))
-				if err != nil {
-					t.Fatalf("can not read the secret from disk: %s", err)
-				}
-
-				if string(data) != tc.secret {
-					t.Fatalf("expected secret value: %s, got %s", tc.secret, string(data))
-				}
-			}
-		})
-	}
-}
-
-func TestListSecrets(t *testing.T) {
-	mountPath, err := os.MkdirTemp("", "test_secret_creation")
-	if err != nil {
-		t.Fatalf("unexpected error while creating temp directory: %s", err)
-	}
-
-	defer os.RemoveAll(mountPath)
-
-	cases := []struct {
-		name       string
-		verb       string
-		namespace  string
-		labels     map[string]string
-		status     int
-		secretPath string
-		secret     string
-		err        string
-		expected   []types.Secret
-	}{
-		{
-			name:       "Get empty secret list for default namespace having no secret",
-			verb:       http.MethodGet,
-			status:     http.StatusOK,
-			secretPath: "/test-fn/foo",
-			secret:     "bar",
-			expected:   make([]types.Secret, 0),
-		},
-		{
-			name:       "Get empty secret list for non-default namespace having no secret",
-			verb:       http.MethodGet,
-			status:     http.StatusOK,
-			secretPath: "/test-fn/foo",
-			secret:     "bar",
-			expected:   make([]types.Secret, 0),
-			namespace:  "other-ns",
-			labels: map[string]string{
-				pkg.NamespaceLabel: "true",
-			},
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			labelStore := provider.NewFakeLabeller(tc.labels)
-
-			handler := MakeSecretHandler(labelStore, mountPath)
-
-			path := "http://example.com/foo"
-			if len(tc.namespace) > 0 {
-				path = path + fmt.Sprintf("?namespace=%s", tc.namespace)
-			}
-			req := httptest.NewRequest(tc.verb, path, nil)
-			w := httptest.NewRecorder()
-
-			handler(w, req)
-
-			resp := w.Result()
-			if resp.StatusCode != tc.status {
-				t.Fatalf("want status: %d, but got: %d", tc.status, resp.StatusCode)
-			}
-
-			if resp.StatusCode != http.StatusOK && w.Body.String() != tc.err {
-				t.Fatalf("want error message: %q, but got %q", tc.err, w.Body.String())
-			}
-
-			body, err := ioutil.ReadAll(resp.Body)
-			if err != nil {
-				t.Fatalf("can't read response of list %v", err)
-			}
-
-			var res []types.Secret
-			err = json.Unmarshal(body, &res)
-
-			if err != nil {
-				t.Fatalf("unable to unmarshal %q, error: %v", string(body), err)
-			}
-
-			if !reflect.DeepEqual(res, tc.expected) {
-				t.Fatalf("want response: %v, but got: %v", tc.expected, res)
-			}
-		})
-	}
-}
--- a/pkg/provider/handlers/update.go
+++ b/pkg/provider/handlers/update.go
@ -1,101 +0,0 @@
-package handlers
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net/http"
-
-	"github.com/containerd/containerd"
-	"github.com/containerd/containerd/namespaces"
-	gocni "github.com/containerd/go-cni"
-	"github.com/openfaas/faas-provider/types"
-
-	"github.com/openfaas/faasd/pkg/cninetwork"
-	"github.com/openfaas/faasd/pkg/service"
-)
-
-func MakeUpdateHandler(client *containerd.Client, cni gocni.CNI, secretMountPath string, alwaysPull bool) func(w http.ResponseWriter, r *http.Request) {
-
-	return func(w http.ResponseWriter, r *http.Request) {
-
-		if r.Body == nil {
-			http.Error(w, "expected a body", http.StatusBadRequest)
-			return
-		}
-
-		defer r.Body.Close()
-
-		body, _ := ioutil.ReadAll(r.Body)
-		log.Printf("[Update] request: %s\n", string(body))
-
-		req := types.FunctionDeployment{}
-		err := json.Unmarshal(body, &req)
-		if err != nil {
-			log.Printf("[Update] error parsing input: %s\n", err)
-			http.Error(w, err.Error(), http.StatusBadRequest)
-
-			return
-		}
-		name := req.Service
-		namespace := getRequestNamespace(req.Namespace)
-
-		// Check if namespace exists, and it has the openfaas label
-		valid, err := validNamespace(client.NamespaceService(), namespace)
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-
-		if !valid {
-			http.Error(w, "namespace not valid", http.StatusBadRequest)
-			return
-		}
-
-		namespaceSecretMountPath := getNamespaceSecretMountPath(secretMountPath, namespace)
-
-		function, err := GetFunction(client, name, namespace)
-		if err != nil {
-			msg := fmt.Sprintf("service %s not found", name)
-			log.Printf("[Update] %s\n", msg)
-			http.Error(w, msg, http.StatusNotFound)
-			return
-		}
-
-		err = validateSecrets(namespaceSecretMountPath, req.Secrets)
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-		}
-
-		ctx := namespaces.WithNamespace(context.Background(), namespace)
-
-		if _, err := prepull(ctx, req, client, alwaysPull); err != nil {
-			log.Printf("[Update] error with pre-pull: %s, %s\n", name, err)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-		}
-
-		if function.replicas != 0 {
-			err = cninetwork.DeleteCNINetwork(ctx, cni, client, name)
-			if err != nil {
-				log.Printf("[Update] error removing CNI network for %s, %s\n", name, err)
-			}
-		}
-
-		if err := service.Remove(ctx, client, name); err != nil {
-			log.Printf("[Update] error removing %s, %s\n", name, err)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		// The pull has already been done in prepull, so we can force this pull to "false"
-		pull := false
-
-		if err := deploy(ctx, req, client, cni, namespaceSecretMountPath, pull); err != nil {
-			log.Printf("[Update] error deploying %s, error: %s\n", name, err)
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-	}
-}
--- a/pkg/provider/handlers/utils.go
+++ b/pkg/provider/handlers/utils.go
@ -1,47 +0,0 @@
-package handlers
-
-import (
-	"context"
-	"net/http"
-	"path"
-
-	"github.com/openfaas/faasd/pkg"
-	faasd "github.com/openfaas/faasd/pkg"
-	provider "github.com/openfaas/faasd/pkg/provider"
-)
-
-func getRequestNamespace(namespace string) string {
-
-	if len(namespace) > 0 {
-		return namespace
-	}
-	return faasd.DefaultFunctionNamespace
-}
-
-func readNamespaceFromQuery(r *http.Request) string {
-	q := r.URL.Query()
-	return q.Get("namespace")
-}
-
-func getNamespaceSecretMountPath(userSecretPath string, namespace string) string {
-	return path.Join(userSecretPath, namespace)
-}
-
-// validNamespace indicates whether the namespace is eligable to be
-// used for OpenFaaS functions.
-func validNamespace(store provider.Labeller, namespace string) (bool, error) {
-	if namespace == faasd.DefaultFunctionNamespace {
-		return true, nil
-	}
-
-	labels, err := store.Labels(context.Background(), namespace)
-	if err != nil {
-		return false, err
-	}
-
-	if value, found := labels[pkg.NamespaceLabel]; found && value == "true" {
-		return true, nil
-	}
-
-	return false, nil
-}
--- a/pkg/provider/handlers/utils_test.go
+++ b/pkg/provider/handlers/utils_test.go
@ -1,75 +0,0 @@
-package handlers
-
-import (
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	faasd "github.com/openfaas/faasd/pkg"
-)
-
-func Test_getRequestNamespace(t *testing.T) {
-	tables := []struct {
-		name              string
-		requestNamespace  string
-		expectedNamespace string
-	}{
-		{name: "RequestNamespace is not provided", requestNamespace: "", expectedNamespace: faasd.DefaultFunctionNamespace},
-		{name: "RequestNamespace is provided", requestNamespace: "user-namespace", expectedNamespace: "user-namespace"},
-	}
-
-	for _, tc := range tables {
-		t.Run(tc.name, func(t *testing.T) {
-			actualNamespace := getRequestNamespace(tc.requestNamespace)
-			if actualNamespace != tc.expectedNamespace {
-				t.Errorf("Want: %s, got: %s", actualNamespace, tc.expectedNamespace)
-			}
-		})
-	}
-}
-
-func Test_getNamespaceSecretMountPath(t *testing.T) {
-	userSecretPath := "/var/openfaas/secrets"
-	tables := []struct {
-		name               string
-		requestNamespace   string
-		expectedSecretPath string
-	}{
-		{name: "Default Namespace is provided", requestNamespace: faasd.DefaultFunctionNamespace, expectedSecretPath: "/var/openfaas/secrets/" + faasd.DefaultFunctionNamespace},
-		{name: "User Namespace is provided", requestNamespace: "user-namespace", expectedSecretPath: "/var/openfaas/secrets/user-namespace"},
-	}
-
-	for _, tc := range tables {
-		t.Run(tc.name, func(t *testing.T) {
-			actualNamespace := getNamespaceSecretMountPath(userSecretPath, tc.requestNamespace)
-			if actualNamespace != tc.expectedSecretPath {
-				t.Errorf("Want: %s, got: %s", actualNamespace, tc.expectedSecretPath)
-			}
-		})
-	}
-}
-
-func Test_readNamespaceFromQuery(t *testing.T) {
-	tables := []struct {
-		name              string
-		queryNamespace    string
-		expectedNamespace string
-	}{
-		{name: "No Namespace is provided", queryNamespace: "", expectedNamespace: ""},
-		{name: "User Namespace is provided", queryNamespace: "user-namespace", expectedNamespace: "user-namespace"},
-	}
-
-	for _, tc := range tables {
-		t.Run(tc.name, func(t *testing.T) {
-
-			url := fmt.Sprintf("/test?namespace=%s", tc.queryNamespace)
-			r := httptest.NewRequest(http.MethodGet, url, nil)
-
-			actualNamespace := readNamespaceFromQuery(r)
-			if actualNamespace != tc.expectedNamespace {
-				t.Errorf("Want: %s, got: %s", actualNamespace, tc.expectedNamespace)
-			}
-		})
-	}
-}
--- a/pkg/provider/labeller.go
+++ b/pkg/provider/labeller.go
@ -1,25 +0,0 @@
-package provider
-
-import "context"
-
-// Labeller can return labels for a namespace from containerd.
-type Labeller interface {
-	Labels(ctx context.Context, namespace string) (map[string]string, error)
-}
-
-//
-// FakeLabeller can be used to fake labels applied on namespace to mark
-// them valid/invalid for openfaas functions
-type FakeLabeller struct {
-	labels map[string]string
-}
-
-func NewFakeLabeller(labels map[string]string) Labeller {
-	return &FakeLabeller{
-		labels: labels,
-	}
-}
-
-func (s *FakeLabeller) Labels(ctx context.Context, namespace string) (map[string]string, error) {
-	return s.labels, nil
-}
--- a/pkg/proxy.go
+++ b/pkg/proxy.go
@ -3,114 +3,100 @@ package pkg
 import (
 	"fmt"
 	"io"
+	"io/ioutil"
 	"log"
-	"net"
 	"net/http"
-	"strconv"
 	"strings"

 	"time"
 )

-// NewProxy creates a HTTP proxy to expose a host
-func NewProxy(upstream string, listenPort uint32, hostIP string, timeout time.Duration, resolver Resolver) *Proxy {
+func NewProxy(hosts string, timeout time.Duration) *Proxy {

 	return &Proxy{
-		Upstream: upstream,
-		Port:     listenPort,
-		HostIP:   hostIP,
-		Timeout:  timeout,
-		Resolver: resolver,
+		Hosts:   hosts,
+		Timeout: timeout,
 	}
 }

-// Proxy for exposing a private container
 type Proxy struct {
+	Hosts   string
 	Timeout time.Duration
-
-	// Port on which to listen to traffic
-	Port uint32
-
-	// Upstream is where to send traffic when received
-	Upstream string
-
-	// The IP to use to bind locally
-	HostIP string
-
-	Resolver Resolver
 }

-// Start listening and forwarding HTTP to the host
 func (p *Proxy) Start() error {
+	tcp := 8080

 	http.DefaultClient.CheckRedirect = func(req *http.Request, via []*http.Request) error {
 		return http.ErrUseLastResponse
 	}
-	upstreamHost, upstreamPort, err := getUpstream(p.Upstream, p.Port)
-	if err != nil {
-		return err
+
+	time.Sleep(3 * time.Second)
+	log.Printf("Starting faasd proxy on %d\n", tcp)
+	data := struct{ host string }{
+		host: "",
 	}

-	log.Printf("Looking up IP for: %q", upstreamHost)
-	got := make(chan string, 1)
-
-	go p.Resolver.Get(upstreamHost, got, time.Second*5)
-
-	ipAddress := <-got
-	close(got)
-
-	upstreamAddr := fmt.Sprintf("%s:%d", ipAddress, upstreamPort)
-
-	localBind := fmt.Sprintf("%s:%d", p.HostIP, p.Port)
-	log.Printf("Proxy from: %s, to: %s (%s)\n", localBind, p.Upstream, ipAddress)
-
-	l, err := net.Listen("tcp", localBind)
-	if err != nil {
-		log.Printf("Error: %s", err.Error())
-		return err
+	fileData, fileErr := ioutil.ReadFile(p.Hosts)
+	if fileErr != nil {
+		return fileErr
 	}

-	defer l.Close()
-	for {
-		// Wait for a connection.
-		conn, err := l.Accept()
-		if err != nil {
-			acceptErr := fmt.Errorf("Unable to accept on %d, error: %s",
-				p.Port,
-				err.Error())
-			log.Printf("%s", acceptErr.Error())
-			return acceptErr
+	lines := strings.Split(string(fileData), "\n")
+	for _, line := range lines {
+		if strings.Index(line, "gateway") > -1 {
+			data.host = line[:strings.Index(line, "\t")]
 		}
-
-		upstream, err := net.Dial("tcp", upstreamAddr)
-
-		if err != nil {
-			log.Printf("unable to dial to %s, error: %s", upstreamAddr, err.Error())
-			return err
-		}
-
-		go pipe(conn, upstream)
-		go pipe(upstream, conn)
 	}
-}
+	fmt.Printf("Gateway: %s\n", data.host)

-func pipe(from net.Conn, to net.Conn) {
-	defer from.Close()
-	io.Copy(from, to)
-}
+	s := &http.Server{
+		Addr:           fmt.Sprintf(":%d", tcp),
+		ReadTimeout:    p.Timeout,
+		WriteTimeout:   p.Timeout,
+		MaxHeaderBytes: 1 << 20, // Max header of 1MB
+		Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

-func getUpstream(val string, defaultPort uint32) (string, uint32, error) {
-	upstreamHostname := val
-	upstreamPort := defaultPort
+			query := ""
+			if len(r.URL.RawQuery) > 0 {
+				query = "?" + r.URL.RawQuery
+			}

-	if in := strings.Index(val, ":"); in > -1 {
-		upstreamHostname = val[:in]
-		port, err := strconv.ParseInt(val[in+1:], 10, 32)
-		if err != nil {
-			return "", defaultPort, err
-		}
-		upstreamPort = uint32(port)
+			upstream := fmt.Sprintf("http://%s:8080%s%s", data.host, r.URL.Path, query)
+			fmt.Printf("[faasd] proxy: %s\n", upstream)
+
+			if r.Body != nil {
+				defer r.Body.Close()
+			}
+
+			wrapper := ioutil.NopCloser(r.Body)
+			upReq, upErr := http.NewRequest(r.Method, upstream, wrapper)
+
+			if upErr != nil {
+				log.Println(upErr)
+
+				http.Error(w, upErr.Error(), http.StatusInternalServerError)
+				return
+			}
+
+			upRes, upResErr := http.DefaultClient.Do(upReq)
+
+			if upResErr != nil {
+				log.Println(upResErr)
+
+				http.Error(w, upResErr.Error(), http.StatusInternalServerError)
+				return
+			}
+
+			for k, v := range upRes.Header {
+				w.Header().Set(k, v[0])
+			}
+
+			w.WriteHeader(upRes.StatusCode)
+			io.Copy(w, upRes.Body)
+
+		}),
 	}

-	return upstreamHostname, upstreamPort, nil
+	return s.ListenAndServe()
 }
--- a/pkg/proxy_test.go
+++ b/pkg/proxy_test.go
@ -1,86 +0,0 @@
-package pkg
-
-import (
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"sync"
-	"testing"
-	"time"
-)
-
-func Test_Proxy_ToPrivateServer(t *testing.T) {
-
-	wantBodyText := "OK"
-	wantBody := []byte(wantBodyText)
-	upstreamSvr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-
-		if r.Body != nil {
-			defer r.Body.Close()
-		}
-
-		w.WriteHeader(http.StatusOK)
-		w.Write(wantBody)
-
-	}))
-
-	defer upstreamSvr.Close()
-	port := 8080
-	u, _ := url.Parse(upstreamSvr.URL)
-	log.Println("Host", u.Host)
-
-	upstreamAddr := u.Host
-	proxy := NewProxy(upstreamAddr, 8080, "127.0.0.1", time.Second*1, &mockResolver{})
-
-	gwChan := make(chan string, 1)
-	doneCh := make(chan bool)
-
-	go proxy.Start()
-
-	wg := sync.WaitGroup{}
-	wg.Add(1)
-	go func() {
-		gwChan <- u.Host
-		wg.Done()
-	}()
-	wg.Wait()
-
-	req, err := http.NewRequest(http.MethodGet, fmt.Sprintf("http://127.0.0.1:%d", port), nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	for i := 1; i < 11; i++ {
-		res, err := http.DefaultClient.Do(req)
-		if err != nil {
-			t.Logf("Try %d, gave error: %s", i, err)
-
-			time.Sleep(time.Millisecond * 100)
-		} else {
-
-			resBody, _ := ioutil.ReadAll(res.Body)
-			if string(resBody) != string(wantBody) {
-				t.Errorf("want %s, but got %s in body", string(wantBody), string(resBody))
-			}
-			break
-		}
-	}
-
-	go func() {
-		doneCh <- true
-	}()
-}
-
-type mockResolver struct {
-}
-
-func (m *mockResolver) Start() {
-
-}
-
-func (m *mockResolver) Get(upstream string, got chan<- string, timeout time.Duration) {
-	got <- upstream
-}
--- a/pkg/resolver.go
+++ b/pkg/resolver.go
@ -1,12 +0,0 @@
-package pkg
-
-import "time"
-
-// Resolver resolves an upstream IP address for a given upstream host
-type Resolver interface {
-	// Start any polling or connections required to resolve
-	Start()
-
-	// Get an IP address using an asynchronous operation
-	Get(upstream string, got chan<- string, timeout time.Duration)
-}
--- a/pkg/service/service.go
+++ b/pkg/service/service.go
@ -4,57 +4,45 @@ import (
 	"context"
 	"fmt"
 	"log"
-	"os"
-	"path/filepath"
 	"sync"
 	"time"

 	"github.com/containerd/containerd"
 	"github.com/containerd/containerd/errdefs"
-	"github.com/containerd/containerd/remotes"
-	"github.com/containerd/containerd/remotes/docker"
-	"github.com/docker/cli/cli/config"
-	"github.com/docker/cli/cli/config/configfile"
 	"golang.org/x/sys/unix"
 )

-// dockerConfigDir contains "config.json"
-const dockerConfigDir = "/var/lib/faasd/.docker/"
-
 // Remove removes a container
 func Remove(ctx context.Context, client *containerd.Client, name string) error {

 	container, containerErr := client.LoadContainer(ctx, name)

 	if containerErr == nil {
-		taskFound := true
+		found := true
 		t, err := container.Task(ctx, nil)
 		if err != nil {
 			if errdefs.IsNotFound(err) {
-				taskFound = false
+				found = false
 			} else {
-				return fmt.Errorf("unable to get task %w: ", err)
+				return fmt.Errorf("unable to get task %s: ", err)
 			}
 		}

-		if taskFound {
-			status, err := t.Status(ctx)
+		if found {
+			status, _ := t.Status(ctx)
+			fmt.Printf("Status of %s is: %s\n", name, status.Status)
+
+			log.Printf("Need to kill %s\n", name)
+			err := killTask(ctx, t)
 			if err != nil {
-				log.Printf("Unable to get status for: %s, error: %s", name, err.Error())
-			} else {
-				log.Printf("Status of %s is: %s\n", name, status.Status)
-			}
-
-			log.Printf("Need to kill task: %s\n", name)
-			if err = killTask(ctx, t); err != nil {
-				return fmt.Errorf("error killing task %s, %s, %w", container.ID(), name, err)
+				return fmt.Errorf("error killing task %s, %s, %s", container.ID(), name, err)
 			}
 		}

-		if err := container.Delete(ctx, containerd.WithSnapshotCleanup); err != nil {
-			return fmt.Errorf("error deleting container %s, %s, %w", container.ID(), name, err)
+		err = container.Delete(ctx, containerd.WithSnapshotCleanup)
+		if err != nil {
+			return fmt.Errorf("error deleting container %s, %s, %s", container.ID(), name, err)
 		}
-
 	} else {
 		service := client.SnapshotService("")
 		key := name + "snapshot"
@ -65,33 +53,27 @@ func Remove(ctx context.Context, client *containerd.Client, name string) error {
 	return nil
 }

-// Adapted from Stellar - https://github.com/stellar
+// From Stellar
 func killTask(ctx context.Context, task containerd.Task) error {
-
-	killTimeout := 30 * time.Second
-
 	wg := &sync.WaitGroup{}
 	wg.Add(1)
 	var err error
-
 	go func() {
 		defer wg.Done()
 		if task != nil {
 			wait, err := task.Wait(ctx)
 			if err != nil {
-				log.Printf("error waiting on task: %s", err)
+				err = fmt.Errorf("error waiting on task: %s", err)
 				return
 			}
-
 			if err := task.Kill(ctx, unix.SIGTERM, containerd.WithKillAll); err != nil {
 				log.Printf("error killing container task: %s", err)
 			}
-
 			select {
 			case <-wait:
 				task.Delete(ctx)
 				return
-			case <-time.After(killTimeout):
+			case <-time.After(5 * time.Second):
 				if err := task.Kill(ctx, unix.SIGKILL, containerd.WithKillAll); err != nil {
 					log.Printf("error force killing container task: %s", err)
 				}
@ -104,71 +86,20 @@ func killTask(ctx context.Context, task containerd.Task) error {
 	return err
 }

-func getResolver(ctx context.Context, configFile *configfile.ConfigFile) (remotes.Resolver, error) {
-	// credsFunc is based on https://github.com/moby/buildkit/blob/0b130cca040246d2ddf55117eeff34f546417e40/session/auth/authprovider/authprovider.go#L35
-	credFunc := func(host string) (string, string, error) {
-		if host == "registry-1.docker.io" {
-			host = "https://index.docker.io/v1/"
-		}
-		ac, err := configFile.GetAuthConfig(host)
-		if err != nil {
-			return "", "", err
-		}
-		if ac.IdentityToken != "" {
-			return "", ac.IdentityToken, nil
-		}
-		return ac.Username, ac.Password, nil
-	}
+func PrepareImage(ctx context.Context, client *containerd.Client, imageName, snapshotter string) (containerd.Image, error) {

-	authOpts := []docker.AuthorizerOpt{docker.WithAuthCreds(credFunc)}
-	authorizer := docker.NewDockerAuthorizer(authOpts...)
-	opts := docker.ResolverOptions{
-		Hosts: docker.ConfigureDefaultRegistries(docker.WithAuthorizer(authorizer)),
-	}
-	return docker.NewResolver(opts), nil
-}
-
-func PrepareImage(ctx context.Context, client *containerd.Client, imageName, snapshotter string, pullAlways bool) (containerd.Image, error) {
-	var (
-		empty    containerd.Image
-		resolver remotes.Resolver
-	)
-
-	if _, statErr := os.Stat(filepath.Join(dockerConfigDir, config.ConfigFileName)); statErr == nil {
-		configFile, err := config.Load(dockerConfigDir)
-		if err != nil {
-			return nil, err
-		}
-		resolver, err = getResolver(ctx, configFile)
-		if err != nil {
-			return empty, err
-		}
-	} else if !os.IsNotExist(statErr) {
-		return empty, statErr
-	}
-
-	var image containerd.Image
-	if pullAlways {
-		img, err := pullImage(ctx, client, resolver, imageName)
-		if err != nil {
+	var empty containerd.Image
+	image, err := client.GetImage(ctx, imageName)
+	if err != nil {
+		if !errdefs.IsNotFound(err) {
 			return empty, err
 		}

+		img, err := client.Pull(ctx, imageName, containerd.WithPullUnpack)
+		if err != nil {
+			return empty, fmt.Errorf("cannot pull: %s", err)
+		}
 		image = img
-	} else {
-		img, err := client.GetImage(ctx, imageName)
-		if err != nil {
-			if !errdefs.IsNotFound(err) {
-				return empty, err
-			}
-			img, err := pullImage(ctx, client, resolver, imageName)
-			if err != nil {
-				return empty, err
-			}
-			image = img
-		} else {
-			image = img
-		}
 	}

 	unpacked, err := image.IsUnpacked(ctx, snapshotter)
@ -184,23 +115,3 @@ func PrepareImage(ctx context.Context, client *containerd.Client, imageName, sna

 	return image, nil
 }
-
-func pullImage(ctx context.Context, client *containerd.Client, resolver remotes.Resolver, imageName string) (containerd.Image, error) {
-
-	var empty containerd.Image
-
-	rOpts := []containerd.RemoteOpt{
-		containerd.WithPullUnpack,
-	}
-
-	if resolver != nil {
-		rOpts = append(rOpts, containerd.WithResolver(resolver))
-	}
-
-	img, err := client.Pull(ctx, imageName, rOpts...)
-	if err != nil {
-		return empty, fmt.Errorf("cannot pull: %s", err)
-	}
-
-	return img, nil
-}
--- a/pkg/supervisor.go
+++ b/pkg/supervisor.go
@ -6,145 +6,88 @@ import (
 	"io/ioutil"
 	"log"
 	"os"
+	"os/exec"
 	"path"
-	"sort"
-	"strconv"
-	"strings"

-	"github.com/alexellis/k3sup/pkg/env"
-	"github.com/compose-spec/compose-go/loader"
-	compose "github.com/compose-spec/compose-go/types"
+	"github.com/alexellis/faasd/pkg/service"
+	"github.com/alexellis/faasd/pkg/weave"
 	"github.com/containerd/containerd"
 	"github.com/containerd/containerd/cio"
 	"github.com/containerd/containerd/containers"
-	"github.com/containerd/containerd/oci"
-	gocni "github.com/containerd/go-cni"
-	"github.com/docker/distribution/reference"
-	"github.com/openfaas/faasd/pkg/cninetwork"
-	"github.com/openfaas/faasd/pkg/service"
-	"github.com/pkg/errors"

 	"github.com/containerd/containerd/namespaces"
-	units "github.com/docker/go-units"
+	"github.com/containerd/containerd/oci"
 	"github.com/opencontainers/runtime-spec/specs-go"
 )

-const (
-	// workingDirectoryPermission user read/write/execute, group and others: read-only
-	workingDirectoryPermission = 0744
-)
-
-type Service struct {
-	// Image is the container image registry reference, in an OCI format.
-	Image     string
-	Env       []string
-	Name      string
-	Mounts    []Mount
-	Caps      []string
-	Args      []string
-	DependsOn []string
-	Ports     []ServicePort
-
-	// User in the docker-compose.yaml spec can set as follows:
-	// a user-id, username, userid:groupid or user:group
-	User string
-}
-
-type ServicePort struct {
-	TargetPort uint32
-	Port       uint32
-	HostIP     string
-}
-
-type Mount struct {
-	Src  string
-	Dest string
-}
+const defaultSnapshotter = "overlayfs"

 type Supervisor struct {
 	client *containerd.Client
-	cni    gocni.CNI
 }

 func NewSupervisor(sock string) (*Supervisor, error) {
 	client, err := containerd.New(sock)
 	if err != nil {
-		return nil, err
-	}
-
-	cni, err := cninetwork.InitNetwork()
-	if err != nil {
-		return nil, err
+		panic(err)
 	}

 	return &Supervisor{
 		client: client,
-		cni:    cni,
 	}, nil
 }

+func (s *Supervisor) Close() {
+	defer s.client.Close()
+}
+
+func (s *Supervisor) Remove(svcs []Service) error {
+	ctx := namespaces.WithNamespace(context.Background(), "default")
+
+	for _, svc := range svcs {
+		err := service.Remove(ctx, s.client, svc.Name)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 func (s *Supervisor) Start(svcs []Service) error {
-	ctx := namespaces.WithNamespace(context.Background(), FaasdNamespace)
+	ctx := namespaces.WithNamespace(context.Background(), "default")

 	wd, _ := os.Getwd()

-	gw, err := cninetwork.CNIGateway()
-	if err != nil {
-		return err
-	}
-	hosts := fmt.Sprintf(`
-127.0.0.1	localhost
-%s	faasd-provider`, gw)
-
 	writeHostsErr := ioutil.WriteFile(path.Join(wd, "hosts"),
-		[]byte(hosts), workingDirectoryPermission)
+		[]byte(`127.0.0.1	localhost
+172.19.0.1	faas-containerd`), 0644)

 	if writeHostsErr != nil {
 		return fmt.Errorf("cannot write hosts file: %s", writeHostsErr)
 	}
+	// os.Chown("hosts", 101, 101)

 	images := map[string]containerd.Image{}

 	for _, svc := range svcs {
-		fmt.Printf("Preparing %s with image: %s\n", svc.Name, svc.Image)
+		fmt.Printf("Preparing: %s with image: %s\n", svc.Name, svc.Image)

-		r, err := reference.ParseNormalizedNamed(svc.Image)
-		if err != nil {
-			return err
-		}
-
-		imgRef := reference.TagNameOnly(r).String()
-
-		img, err := service.PrepareImage(ctx, s.client, imgRef, defaultSnapshotter, faasServicesPullAlways)
+		img, err := service.PrepareImage(ctx, s.client, svc.Image, defaultSnapshotter)
 		if err != nil {
 			return err
 		}
 		images[svc.Name] = img
 		size, _ := img.Size(ctx)
-		fmt.Printf("Prepare done for: %s, %s\n", svc.Image, units.HumanSize(float64(size)))
+		fmt.Printf("Prepare done for: %s, %d bytes\n", svc.Image, size)
 	}

 	for _, svc := range svcs {
-		fmt.Printf("Removing old container for: %s\n", svc.Name)
+		fmt.Printf("Reconciling: %s\n", svc.Name)
+
 		containerErr := service.Remove(ctx, s.client, svc.Name)
 		if containerErr != nil {
 			return containerErr
 		}
-	}
-
-	order := buildDeploymentOrder(svcs)
-
-	for _, key := range order {
-
-		var svc *Service
-		for _, s := range svcs {
-			if s.Name == key {
-				svc = &s
-				break
-			}
-		}
-
-		fmt.Printf("Starting: %s\n", svc.Name)

 		image := images[svc.Name]

@ -157,29 +100,8 @@ func (s *Supervisor) Start(svcs []Service) error {
 					Type:        "bind",
 					Options:     []string{"rbind", "rw"},
 				})
-
-				// Only create directories, not files.
-				// Some files don't have a suffix, such as secrets.
-				if len(path.Ext(mnt.Src)) == 0 &&
-					!strings.HasPrefix(mnt.Src, "/var/lib/faasd/secrets/") {
-					// src is already prefixed with wd from an earlier step
-					src := mnt.Src
-					fmt.Printf("Creating local directory: %s\n", src)
-					if err := os.MkdirAll(src, workingDirectoryPermission); err != nil {
-						if !errors.Is(os.ErrExist, err) {
-							fmt.Printf("Unable to create: %s, %s\n", src, err)
-						}
-					}
-					if len(svc.User) > 0 {
-						uid, err := strconv.Atoi(svc.User)
-						if err == nil {
-							if err := os.Chown(src, uid, -1); err != nil {
-								fmt.Printf("Unable to chown: %s to %d, error: %s\n", src, uid, err)
-							}
-						}
-					}
-				}
 			}
+
 		}

 		mounts = append(mounts, specs.Mount{
@ -196,75 +118,76 @@ func (s *Supervisor) Start(svcs []Service) error {
 			Options:     []string{"rbind", "ro"},
 		})

-		if len(svc.User) > 0 {
-			log.Printf("Running %s with user: %q", svc.Name, svc.User)
+		hook := func(_ context.Context, _ oci.Client, _ *containers.Container, s *specs.Spec) error {
+			if s.Hooks == nil {
+				s.Hooks = &specs.Hooks{}
+			}
+			netnsPath, err := exec.LookPath("netns")
+			if err != nil {
+				return err
+			}
+
+			s.Hooks.Prestart = []specs.Hook{
+				{
+					Path: netnsPath,
+					Args: []string{
+						"netns",
+					},
+					Env: os.Environ(),
+				},
+			}
+			return nil
 		}

-		newContainer, err := s.client.NewContainer(
+		newContainer, containerCreateErr := s.client.NewContainer(
 			ctx,
 			svc.Name,
 			containerd.WithImage(image),
 			containerd.WithNewSnapshot(svc.Name+"-snapshot", image),
 			containerd.WithNewSpec(oci.WithImageConfig(image),
-				oci.WithHostname(svc.Name),
-				withUserOrDefault(svc.User),
 				oci.WithCapabilities(svc.Caps),
 				oci.WithMounts(mounts),
 				withOCIArgs(svc.Args),
+				hook,
 				oci.WithEnv(svc.Env)),
 		)

+		if containerCreateErr != nil {
+			log.Println(containerCreateErr)
+			return containerCreateErr
+		}
+
+		log.Printf("Created container %s\n", newContainer.ID())
+
+		task, err := newContainer.NewTask(ctx, cio.NewCreator(cio.WithStdio))
 		if err != nil {
-			log.Printf("Error creating container: %s\n", err)
+			log.Println(err)
 			return err
 		}

-		log.Printf("Created container: %s\n", newContainer.ID())
+		ip := getIP(newContainer.ID(), task.Pid())

-		task, err := newContainer.NewTask(ctx, cio.BinaryIO("/usr/local/bin/faasd", nil))
-		if err != nil {
-			log.Printf("Error creating task: %s\n", err)
-			return err
-		}
-
-		labels := map[string]string{}
-		_, err = cninetwork.CreateCNINetwork(ctx, s.cni, task, labels)
-		if err != nil {
-			log.Printf("Error creating CNI for %s: %s", svc.Name, err)
-			return err
-		}
-
-		ip, err := cninetwork.GetIPAddress(svc.Name, task.Pid())
-		if err != nil {
-			log.Printf("Error getting IP for %s: %s", svc.Name, err)
-			return err
-		}
-
-		log.Printf("%s has IP: %s\n", newContainer.ID(), ip)
-
-		hosts, err := ioutil.ReadFile("hosts")
-		if err != nil {
-			log.Printf("Unable to read hosts file: %s\n", err.Error())
-		}
+		hosts, _ := ioutil.ReadFile("hosts")

 		hosts = []byte(string(hosts) + fmt.Sprintf(`
 %s	%s
 `, ip, svc.Name))
+		writeErr := ioutil.WriteFile("hosts", hosts, 0644)

-		if err := ioutil.WriteFile("hosts", hosts, workingDirectoryPermission); err != nil {
-			log.Printf("Error writing file: %s %s\n", "hosts", err)
+		if writeErr != nil {
+			log.Println("Error writing hosts file")
 		}
+		// os.Chown("hosts", 101, 101)

-		if _, err := task.Wait(ctx); err != nil {
-			log.Printf("Task wait error: %s\n", err)
+		exitStatusC, err := task.Wait(ctx)
+		if err != nil {
+			log.Println(err)
 			return err
 		}
+		log.Println("Exited: ", exitStatusC)

-		log.Printf("Task: %s\tContainer: %s\n", task.ID(), newContainer.ID())
-		// log.Println("Exited: ", exitStatusC)
-
-		if err = task.Start(ctx); err != nil {
-			log.Printf("Task start error: %s\n", err)
+		if err := task.Start(ctx); err != nil {
+			log.Println("Task err: ", err)
 			return err
 		}
 	}
@ -272,36 +195,37 @@ func (s *Supervisor) Start(svcs []Service) error {
 	return nil
 }

-func (s *Supervisor) Close() {
-	defer s.client.Close()
+func getIP(containerID string, taskPID uint32) string {
+	// https://github.com/weaveworks/weave/blob/master/net/netdev.go
+
+	peerIDs, err := weave.ConnectedToBridgeVethPeerIds("netns0")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	addrs, addrsErr := weave.GetNetDevsByVethPeerIds(int(taskPID), peerIDs)
+	if addrsErr != nil {
+		log.Fatal(addrsErr)
+	}
+	if len(addrs) > 0 {
+		return addrs[0].CIDRs[0].IP.String()
+	}
+
+	return ""
 }

-func (s *Supervisor) Remove(svcs []Service) error {
-	ctx := namespaces.WithNamespace(context.Background(), FaasdNamespace)
-
-	for _, svc := range svcs {
-		err := cninetwork.DeleteCNINetwork(ctx, s.cni, s.client, svc.Name)
-		if err != nil {
-			log.Printf("[Delete] error removing CNI network for %s, %s\n", svc.Name, err)
-			return err
-		}
-
-		err = service.Remove(ctx, s.client, svc.Name)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
+type Service struct {
+	Image  string
+	Env    []string
+	Name   string
+	Mounts []Mount
+	Caps   []string
+	Args   []string
 }

-func withUserOrDefault(userstr string) oci.SpecOpts {
-	if len(userstr) > 0 {
-		return oci.WithUser(userstr)
-	}
-
-	return func(_ context.Context, _ oci.Client, _ *containers.Container, s *oci.Spec) error {
-		return nil
-	}
+type Mount struct {
+	Src  string
+	Dest string
 }

 func withOCIArgs(args []string) oci.SpecOpts {
@ -310,140 +234,8 @@ func withOCIArgs(args []string) oci.SpecOpts {
 	}

 	return func(_ context.Context, _ oci.Client, _ *containers.Container, s *oci.Spec) error {
+
 		return nil
 	}
-}
-
-// ParseCompose converts a docker-compose Config into a service list that we can
-// pass to the supervisor client Start.
-//
-// The only anticipated error is a failure if the value mounts are not of type 	`bind`.
-func ParseCompose(config *compose.Config) ([]Service, error) {
-	services := make([]Service, len(config.Services))
-	for idx, s := range config.Services {
-		// environment is a map[string]*string
-		// but we want a []string
-
-		var env []string
-
-		envKeys := sortedEnvKeys(s.Environment)
-		for _, name := range envKeys {
-			value := s.Environment[name]
-			if value == nil {
-				env = append(env, fmt.Sprintf(`%s=""`, name))
-			} else {
-				env = append(env, fmt.Sprintf(`%s=%s`, name, *value))
-			}
-		}
-
-		var mounts []Mount
-		for _, v := range s.Volumes {
-			if v.Type != "bind" {
-				return nil, errors.Errorf("unsupported volume mount type '%s' when parsing service '%s'", v.Type, s.Name)
-			}
-			mounts = append(mounts, Mount{
-				Src:  v.Source,
-				Dest: v.Target,
-			})
-		}
-
-		services[idx] = Service{
-			Name:  s.Name,
-			Image: s.Image,
-			// ShellCommand is just an alias of string slice
-			Args:      []string(s.Command),
-			Caps:      s.CapAdd,
-			Env:       env,
-			Mounts:    mounts,
-			DependsOn: s.DependsOn,
-			User:      s.User,
-			Ports:     convertPorts(s.Ports),
-		}
-	}
-
-	return services, nil
-}
-
-func convertPorts(ports []compose.ServicePortConfig) []ServicePort {
-	servicePorts := []ServicePort{}
-	for _, p := range ports {
-		servicePorts = append(servicePorts, ServicePort{
-			Port:       p.Published,
-			TargetPort: p.Target,
-			HostIP:     p.HostIP,
-		})
-	}
-
-	return servicePorts
-}
-
-// LoadComposeFile is a helper method for loading a docker-compose file
-func LoadComposeFile(wd string, file string) (*compose.Config, error) {
-	return LoadComposeFileWithArch(wd, file, env.GetClientArch)
-}
-
-// LoadComposeFileWithArch is a helper method for loading a docker-compose file
-func LoadComposeFileWithArch(wd string, file string, archGetter ArchGetter) (*compose.Config, error) {
-
-	file = path.Join(wd, file)
-	b, err := ioutil.ReadFile(file)
-	if err != nil {
-		return nil, err
-	}
-
-	config, err := loader.ParseYAML(b)
-	if err != nil {
-		return nil, err
-	}
-
-	archSuffix, err := GetArchSuffix(archGetter)
-	if err != nil {
-		return nil, err
-	}
-
-	var files []compose.ConfigFile
-	files = append(files, compose.ConfigFile{Filename: file, Config: config})
-
-	return loader.Load(compose.ConfigDetails{
-		WorkingDir:  wd,
-		ConfigFiles: files,
-		Environment: map[string]string{
-			"ARCH_SUFFIX": archSuffix,
-		},
-	})
-}
-
-func sortedEnvKeys(env map[string]*string) (keys []string) {
-	for k := range env {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-	return keys
-}
-
-// ArchGetter provides client CPU architecture and
-// client OS
-type ArchGetter func() (string, string)
-
-// GetArchSuffix provides client CPU architecture and
-// client OS from ArchGetter
-func GetArchSuffix(getClientArch ArchGetter) (suffix string, err error) {
-	clientArch, clientOS := getClientArch()
-
-	if clientOS != "Linux" {
-		return "", fmt.Errorf("you can only use faasd with Linux")
-	}
-
-	switch clientArch {
-	case "x86_64":
-		// no suffix needed
-		return "", nil
-	case "armhf", "armv7l":
-		return "-armhf", nil
-	case "arm64", "aarch64":
-		return "-arm64", nil
-	default:
-		// unknown, so use the default without suffix for now
-		return "", nil
-	}
+
 }
--- a/pkg/supervisor_test.go
+++ b/pkg/supervisor_test.go
@ -1,262 +0,0 @@
-package pkg
-
-import (
-	"path"
-	"reflect"
-	"testing"
-)
-
-func Test_ParseCompose(t *testing.T) {
-
-	wd := "testdata"
-
-	want := map[string]Service{
-		"basic-auth-plugin": {
-			Name:  "basic-auth-plugin",
-			Image: "docker.io/openfaas/basic-auth-plugin:0.18.17",
-			Env: []string{
-				"pass_filename=basic-auth-password",
-				"port=8080",
-				"secret_mount_path=/run/secrets",
-				"user_filename=basic-auth-user",
-			},
-			Mounts: []Mount{
-				{
-					Src:  path.Join(wd, "secrets", "basic-auth-password"),
-					Dest: path.Join("/run/secrets", "basic-auth-password"),
-				},
-				{
-					Src:  path.Join(wd, "secrets", "basic-auth-user"),
-					Dest: path.Join("/run/secrets", "basic-auth-user"),
-				},
-			},
-			Caps: []string{"CAP_NET_RAW"},
-		},
-		"nats": {
-			Name:  "nats",
-			Image: "docker.io/library/nats-streaming:0.11.2",
-			Args:  []string{"/nats-streaming-server", "-m", "8222", "--store=memory", "--cluster_id=faas-cluster"},
-		},
-		"prometheus": {
-			Name:  "prometheus",
-			Image: "docker.io/prom/prometheus:v2.14.0",
-			Mounts: []Mount{
-				{
-					Src:  path.Join(wd, "prometheus.yml"),
-					Dest: "/etc/prometheus/prometheus.yml",
-				},
-			},
-			Caps: []string{"CAP_NET_RAW"},
-		},
-		"gateway": {
-			Name: "gateway",
-			Env: []string{
-				"auth_proxy_pass_body=false",
-				"auth_proxy_url=http://basic-auth-plugin:8080/validate",
-				"basic_auth=true",
-				"direct_functions=false",
-				"faas_nats_address=nats",
-				"faas_nats_port=4222",
-				"functions_provider_url=http://faasd-provider:8081/",
-				"read_timeout=60s",
-				"scale_from_zero=true",
-				"secret_mount_path=/run/secrets",
-				"upstream_timeout=65s",
-				"write_timeout=60s",
-			},
-			Image: "docker.io/openfaas/gateway:0.18.17",
-			Mounts: []Mount{
-				{
-					Src:  path.Join(wd, "secrets", "basic-auth-password"),
-					Dest: path.Join("/run/secrets", "basic-auth-password"),
-				},
-				{
-					Src:  path.Join(wd, "secrets", "basic-auth-user"),
-					Dest: path.Join("/run/secrets", "basic-auth-user"),
-				},
-			},
-			Caps:      []string{"CAP_NET_RAW"},
-			DependsOn: []string{"nats"},
-		},
-		"queue-worker": {
-			Name: "queue-worker",
-			Env: []string{
-				"ack_wait=5m5s",
-				"basic_auth=true",
-				"faas_gateway_address=gateway",
-				"faas_nats_address=nats",
-				"faas_nats_port=4222",
-				"gateway_invoke=true",
-				"max_inflight=1",
-				"secret_mount_path=/run/secrets",
-				"write_debug=false",
-			},
-			Image: "docker.io/openfaas/queue-worker:0.11.2",
-			Mounts: []Mount{
-				{
-					Src:  path.Join(wd, "secrets", "basic-auth-password"),
-					Dest: path.Join("/run/secrets", "basic-auth-password"),
-				},
-				{
-					Src:  path.Join(wd, "secrets", "basic-auth-user"),
-					Dest: path.Join("/run/secrets", "basic-auth-user"),
-				},
-			},
-			Caps: []string{"CAP_NET_RAW"},
-		},
-	}
-
-	compose, err := LoadComposeFileWithArch(wd, "docker-compose.yaml", func() (string, string) { return "x86_64", "Linux" })
-	if err != nil {
-		t.Fatalf("can't read docker-compose file: %s", err)
-	}
-
-	services, err := ParseCompose(compose)
-	if err != nil {
-		t.Fatalf("can't parse compose services: %s", err)
-	}
-
-	if len(services) != len(want) {
-		t.Fatalf("want: %d services, got: %d", len(want), len(services))
-	}
-
-	for _, service := range services {
-		exp, ok := want[service.Name]
-
-		if service.Name == "gateway" {
-			if len(service.DependsOn) == 0 {
-				t.Fatalf("gateway should have at least one depends_on entry")
-			}
-		}
-
-		if !ok {
-			t.Fatalf("incorrect service: %s", service.Name)
-		}
-
-		if service.Name != exp.Name {
-			t.Fatalf("incorrect service Name:\n\twant: %s,\n\tgot: %s", exp.Name, service.Name)
-		}
-
-		if service.Image != exp.Image {
-			t.Fatalf("incorrect service Image:\n\twant: %s,\n\tgot: %s", exp.Image, service.Image)
-		}
-
-		equalStringSlice(t, exp.Env, service.Env)
-		equalStringSlice(t, exp.Caps, service.Caps)
-		equalStringSlice(t, exp.Args, service.Args)
-
-		if !reflect.DeepEqual(exp.Mounts, service.Mounts) {
-			t.Fatalf("incorrect service Mounts:\n\twant: %+v,\n\tgot: %+v", exp.Mounts, service.Mounts)
-		}
-	}
-}
-
-func equalStringSlice(t *testing.T, want, found []string) {
-	t.Helper()
-	if (want == nil) != (found == nil) {
-		t.Fatalf("unexpected nil slice: want %+v, got %+v", want, found)
-	}
-
-	if len(want) != len(found) {
-		t.Fatalf("unequal slice length: want %+v, got %+v", want, found)
-	}
-
-	for i := range want {
-		if want[i] != found[i] {
-			t.Fatalf("unexpected value at postition %d: want %s, got %s", i, want[i], found[i])
-		}
-	}
-}
-
-func equalMountSlice(t *testing.T, want, found []Mount) {
-	t.Helper()
-	if (want == nil) != (found == nil) {
-		t.Fatalf("unexpected nil slice: want %+v, got %+v", want, found)
-	}
-
-	if len(want) != len(found) {
-		t.Fatalf("unequal slice length: want %+v, got %+v", want, found)
-	}
-
-	for i := range want {
-		if !reflect.DeepEqual(want[i], found[i]) {
-			t.Fatalf("unexpected value at postition %d: want %s, got %s", i, want[i], found[i])
-		}
-	}
-}
-
-func Test_GetArchSuffix(t *testing.T) {
-	cases := []struct {
-		name      string
-		want      string
-		foundArch string
-		foundOS   string
-		err       string
-	}{
-		{
-			name:    "error if os is not linux",
-			foundOS: "mac",
-			err:     "you can only use faasd with Linux",
-		},
-		{
-			name:      "x86 has no suffix",
-			foundOS:   "Linux",
-			foundArch: "x86_64",
-			want:      "",
-		},
-		{
-			name:      "unknown arch has no suffix",
-			foundOS:   "Linux",
-			foundArch: "anything_else",
-			want:      "",
-		},
-		{
-			name:      "armhf has armhf suffix",
-			foundOS:   "Linux",
-			foundArch: "armhf",
-			want:      "-armhf",
-		},
-		{
-			name:      "armv7l has armhf suffix",
-			foundOS:   "Linux",
-			foundArch: "armv7l",
-			want:      "-armhf",
-		},
-		{
-			name:      "arm64 has arm64 suffix",
-			foundOS:   "Linux",
-			foundArch: "arm64",
-			want:      "-arm64",
-		},
-		{
-			name:      "aarch64 has arm64 suffix",
-			foundOS:   "Linux",
-			foundArch: "aarch64",
-			want:      "-arm64",
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-
-			suffix, err := GetArchSuffix(testArchGetter(tc.foundArch, tc.foundOS))
-			if tc.err != "" && err == nil {
-				t.Fatalf("want error %s but got nil", tc.err)
-			} else if tc.err != "" && err.Error() != tc.err {
-				t.Fatalf("want error %s, got %s", tc.err, err.Error())
-			} else if tc.err == "" && err != nil {
-				t.Fatalf("unexpected error %s", err.Error())
-			}
-
-			if suffix != tc.want {
-				t.Fatalf("want suffix %s, got %s", tc.want, suffix)
-			}
-		})
-	}
-}
-
-func testArchGetter(arch, os string) ArchGetter {
-	return func() (string, string) {
-		return arch, os
-	}
-}
--- a/pkg/systemd/systemd.go
+++ b/pkg/systemd/systemd.go
@ -64,11 +64,7 @@ func DaemonReload() error {
 	return nil
 }

-func InstallUnit(name string, tokens map[string]string) error {
-	if len(tokens["Cwd"]) == 0 {
-		return fmt.Errorf("key Cwd expected in tokens parameter")
-	}
-
+func InstallUnit(name string) error {
 	tmplName := "./hack/" + name + ".service"
 	tmpl, err := template.ParseFiles(tmplName)

@ -76,9 +72,15 @@ func InstallUnit(name string, tokens map[string]string) error {
 		return fmt.Errorf("error loading template %s, error %s", tmplName, err)
 	}

+	wd, _ := os.Getwd()
 	var tpl bytes.Buffer
+	userData := struct {
+		Cwd string
+	}{
+		Cwd: wd,
+	}

-	err = tmpl.Execute(&tpl, tokens)
+	err = tmpl.Execute(&tpl, userData)
 	if err != nil {
 		return err
 	}
--- a/pkg/testdata/docker-compose.yaml
+++ b/pkg/testdata/docker-compose.yaml
@ -1,98 +0,0 @@
-version: "3.7"
-services:
-  basic-auth-plugin:
-    image: "docker.io/openfaas/basic-auth-plugin:0.18.17${ARCH_SUFFIX}"
-    environment:
-      - port=8080
-      - secret_mount_path=/run/secrets
-      - user_filename=basic-auth-user
-      - pass_filename=basic-auth-password
-    volumes:
-      # we assume cwd == /var/lib/faasd
-      - type: bind
-        source: ./secrets/basic-auth-password
-        target: /run/secrets/basic-auth-password
-      - type: bind
-        source: ./secrets/basic-auth-user
-        target: /run/secrets/basic-auth-user
-    cap_add:
-      - CAP_NET_RAW
-
-  nats:
-    image: docker.io/library/nats-streaming:0.11.2
-    command:
-      - "/nats-streaming-server"
-      - "-m"
-      - "8222"
-      - "--store=memory"
-      - "--cluster_id=faas-cluster"
-    ports:
-       - "127.0.0.1:8222:8222"
-
-  prometheus:
-    image: docker.io/prom/prometheus:v2.14.0
-    volumes:
-      - type: bind
-        source: ./prometheus.yml
-        target: /etc/prometheus/prometheus.yml
-    cap_add:
-      - CAP_NET_RAW
-    ports:
-       - "127.0.0.1:9090:9090"
-
-  gateway:
-    image: "docker.io/openfaas/gateway:0.18.17${ARCH_SUFFIX}"
-    environment:
-      - basic_auth=true
-      - functions_provider_url=http://faasd-provider:8081/
-      - direct_functions=false
-      - read_timeout=60s
-      - write_timeout=60s
-      - upstream_timeout=65s
-      - faas_nats_address=nats
-      - faas_nats_port=4222
-      - auth_proxy_url=http://basic-auth-plugin:8080/validate
-      - auth_proxy_pass_body=false
-      - secret_mount_path=/run/secrets
-      - scale_from_zero=true
-    volumes:
-      # we assume cwd == /var/lib/faasd
-      - type: bind
-        source: ./secrets/basic-auth-password
-        target: /run/secrets/basic-auth-password
-      - type: bind
-        source: ./secrets/basic-auth-user
-        target: /run/secrets/basic-auth-user
-    cap_add:
-      - CAP_NET_RAW
-    depends_on:
-      - basic-auth-plugin
-      - nats
-      - prometheus
-    ports:
-       - "8080:8080"
-
-  queue-worker:
-    image: docker.io/openfaas/queue-worker:0.11.2
-    environment:
-      - faas_nats_address=nats
-      - faas_nats_port=4222
-      - gateway_invoke=true
-      - faas_gateway_address=gateway
-      - ack_wait=5m5s
-      - max_inflight=1
-      - write_debug=false
-      - basic_auth=true
-      - secret_mount_path=/run/secrets
-    volumes:
-      # we assume cwd == /var/lib/faasd
-      - type: bind
-        source: ./secrets/basic-auth-password
-        target: /run/secrets/basic-auth-password
-      - type: bind
-        source: ./secrets/basic-auth-user
-        target: /run/secrets/basic-auth-user
-    cap_add:
-      - CAP_NET_RAW
-    depends_on:
-      - nats
--- a/pkg/cninetwork/netns.go
+++ b/pkg/cninetwork/netns.go
@ -3,7 +3,7 @@
 // Copyright Weaveworks
 // github.com/weaveworks/weave/net

-package cninetwork
+package weave

 import (
 	"errors"
--- a/pkg/weave/weave.go
+++ b/pkg/weave/weave.go
@ -0,0 +1,131 @@
+// Copyright Weaveworks
+// github.com/weaveworks/weave/net
+
+package weave
+
+import (
+	"fmt"
+	"net"
+	"os"
+
+	"github.com/vishvananda/netlink"
+	"github.com/vishvananda/netns"
+)
+
+type Dev struct {
+	Name  string           `json:"Name,omitempty"`
+	MAC   net.HardwareAddr `json:"MAC,omitempty"`
+	CIDRs []*net.IPNet     `json:"CIDRs,omitempty"`
+}
+
+func linkToNetDev(link netlink.Link) (Dev, error) {
+	addrs, err := netlink.AddrList(link, netlink.FAMILY_V4)
+	if err != nil {
+		return Dev{}, err
+	}
+
+	netDev := Dev{Name: link.Attrs().Name, MAC: link.Attrs().HardwareAddr}
+	for _, addr := range addrs {
+		netDev.CIDRs = append(netDev.CIDRs, addr.IPNet)
+	}
+	return netDev, nil
+}
+
+// ConnectedToBridgeVethPeerIds returns peer indexes of veth links connected to
+// the given bridge. The peer index is used to query from a container netns
+// whether the container is connected to the bridge.
+func ConnectedToBridgeVethPeerIds(bridgeName string) ([]int, error) {
+	var ids []int
+
+	br, err := netlink.LinkByName(bridgeName)
+	if err != nil {
+		return nil, err
+	}
+	links, err := netlink.LinkList()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, link := range links {
+		if _, isveth := link.(*netlink.Veth); isveth && link.Attrs().MasterIndex == br.Attrs().Index {
+			peerID := link.Attrs().ParentIndex
+			if peerID == 0 {
+				// perhaps running on an older kernel where ParentIndex doesn't work.
+				// as fall-back, assume the peers are consecutive
+				peerID = link.Attrs().Index - 1
+			}
+			ids = append(ids, peerID)
+		}
+	}
+
+	return ids, nil
+}
+
+// Lookup the weave interface of a container
+func GetWeaveNetDevs(processID int) ([]Dev, error) {
+	peerIDs, err := ConnectedToBridgeVethPeerIds("weave")
+	if err != nil {
+		return nil, err
+	}
+
+	return GetNetDevsByVethPeerIds(processID, peerIDs)
+}
+
+func GetNetDevsByVethPeerIds(processID int, peerIDs []int) ([]Dev, error) {
+	// Bail out if this container is running in the root namespace
+	netnsRoot, err := netns.GetFromPid(1)
+	if err != nil {
+		return nil, fmt.Errorf("unable to open root namespace: %s", err)
+	}
+	defer netnsRoot.Close()
+	netnsContainer, err := netns.GetFromPid(processID)
+	if err != nil {
+		// Unable to find a namespace for this process - just return nothing
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("unable to open process %d namespace: %s", processID, err)
+	}
+	defer netnsContainer.Close()
+	if netnsRoot.Equal(netnsContainer) {
+		return nil, nil
+	}
+
+	// convert list of peerIDs into a map for faster lookup
+	indexes := make(map[int]struct{})
+	for _, id := range peerIDs {
+		indexes[id] = struct{}{}
+	}
+
+	var netdevs []Dev
+	err = WithNetNS(netnsContainer, func() error {
+		links, err := netlink.LinkList()
+		if err != nil {
+			return err
+		}
+
+		for _, link := range links {
+			if _, found := indexes[link.Attrs().Index]; found {
+				netdev, err := linkToNetDev(link)
+				if err != nil {
+					return err
+				}
+				netdevs = append(netdevs, netdev)
+			}
+		}
+		return nil
+	})
+
+	return netdevs, err
+}
+
+// Get the weave bridge interface.
+// NB: Should be called from the root network namespace.
+func GetBridgeNetDev(bridgeName string) (Dev, error) {
+	link, err := netlink.LinkByName(bridgeName)
+	if err != nil {
+		return Dev{}, err
+	}
+
+	return linkToNetDev(link)
+}
--- a/prometheus.yml
+++ b/prometheus.yml
@ -26,7 +26,3 @@ scrape_configs:
  - job_name: 'gateway'
    static_configs:
    - targets: ['gateway:8082']
-
-  - job_name: 'provider'
-    static_configs:
-    - targets: ['faasd-provider:8081']
--- a/vendor/github.com/Microsoft/go-winio/CODEOWNERS
+++ b/vendor/github.com/Microsoft/go-winio/CODEOWNERS
@ -1 +0,0 @@
-  * @microsoft/containerplat
--- a/vendor/github.com/Microsoft/go-winio/README.md
+++ b/vendor/github.com/Microsoft/go-winio/README.md
@ -1,4 +1,4 @@
-# go-winio [![Build Status](https://github.com/microsoft/go-winio/actions/workflows/ci.yml/badge.svg)](https://github.com/microsoft/go-winio/actions/workflows/ci.yml)
+# go-winio

 This repository contains utilities for efficiently performing Win32 IO operations in
 Go. Currently, this is focused on accessing named pipes and other file handles, and
@ -11,27 +11,12 @@ package.

 Please see the LICENSE file for licensing information.

-## Contributing
+This project has adopted the [Microsoft Open Source Code of
+Conduct](https://opensource.microsoft.com/codeofconduct/). For more information
+see the [Code of Conduct
+FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact
+[opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional
+questions or comments.

-This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA)
-declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.microsoft.com.
-
-When you submit a pull request, a CLA-bot will automatically determine whether you need to provide a CLA and decorate the PR
-appropriately (e.g., label, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.
-
-We also require that contributors sign their commits using git commit -s or git commit --signoff to certify they either authored the work themselves
-or otherwise have permission to use it in this project. Please see https://developercertificate.org/ for more info, as well as to make sure that you can
-attest to the rules listed. Our CI uses the DCO Github app to ensure that all commits in a given PR are signed-off.
-
-
-## Code of Conduct
-
-This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
-For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or
-contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
-
-
-
-## Special Thanks
 Thanks to natefinch for the inspiration for this library. See https://github.com/natefinch/npipe
 for another named pipe implementation.
--- a/vendor/github.com/Microsoft/go-winio/archive/tar/LICENSE
+++ b/vendor/github.com/Microsoft/go-winio/archive/tar/LICENSE
@ -1,5 +1,4 @@
 Copyright (c) 2012 The Go Authors. All rights reserved.
-Copyright (c) 2019 Klaus Post. All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
--- a/vendor/github.com/Microsoft/go-winio/backuptar/noop.go
+++ b/vendor/github.com/Microsoft/go-winio/backuptar/noop.go
@ -1,4 +0,0 @@
-// +build !windows
-// This file only exists to allow go get on non-Windows platforms.
-
-package backuptar
--- a/vendor/github.com/Microsoft/go-winio/backuptar/tar.go
+++ b/vendor/github.com/Microsoft/go-winio/backuptar/tar.go
@ -1,480 +0,0 @@
-// +build windows
-
-package backuptar
-
-import (
-	"archive/tar"
-	"encoding/base64"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"syscall"
-	"time"
-
-	"github.com/Microsoft/go-winio"
-	"golang.org/x/sys/windows"
-)
-
-const (
-	c_ISUID  = 04000   // Set uid
-	c_ISGID  = 02000   // Set gid
-	c_ISVTX  = 01000   // Save text (sticky bit)
-	c_ISDIR  = 040000  // Directory
-	c_ISFIFO = 010000  // FIFO
-	c_ISREG  = 0100000 // Regular file
-	c_ISLNK  = 0120000 // Symbolic link
-	c_ISBLK  = 060000  // Block special file
-	c_ISCHR  = 020000  // Character special file
-	c_ISSOCK = 0140000 // Socket
-)
-
-const (
-	hdrFileAttributes        = "MSWINDOWS.fileattr"
-	hdrSecurityDescriptor    = "MSWINDOWS.sd"
-	hdrRawSecurityDescriptor = "MSWINDOWS.rawsd"
-	hdrMountPoint            = "MSWINDOWS.mountpoint"
-	hdrEaPrefix              = "MSWINDOWS.xattr."
-
-	hdrCreationTime = "LIBARCHIVE.creationtime"
-)
-
-// zeroReader is an io.Reader that always returns 0s.
-type zeroReader struct{}
-
-func (zr zeroReader) Read(b []byte) (int, error) {
-	for i := range b {
-		b[i] = 0
-	}
-	return len(b), nil
-}
-
-func copySparse(t *tar.Writer, br *winio.BackupStreamReader) error {
-	curOffset := int64(0)
-	for {
-		bhdr, err := br.Next()
-		if err == io.EOF {
-			err = io.ErrUnexpectedEOF
-		}
-		if err != nil {
-			return err
-		}
-		if bhdr.Id != winio.BackupSparseBlock {
-			return fmt.Errorf("unexpected stream %d", bhdr.Id)
-		}
-
-		// We can't seek backwards, since we have already written that data to the tar.Writer.
-		if bhdr.Offset < curOffset {
-			return fmt.Errorf("cannot seek back from %d to %d", curOffset, bhdr.Offset)
-		}
-		// archive/tar does not support writing sparse files
-		// so just write zeroes to catch up to the current offset.
-		if _, err := io.CopyN(t, zeroReader{}, bhdr.Offset-curOffset); err != nil {
-			return fmt.Errorf("seek to offset %d: %s", bhdr.Offset, err)
-		}
-		if bhdr.Size == 0 {
-			// A sparse block with size = 0 is used to mark the end of the sparse blocks.
-			break
-		}
-		n, err := io.Copy(t, br)
-		if err != nil {
-			return err
-		}
-		if n != bhdr.Size {
-			return fmt.Errorf("copied %d bytes instead of %d at offset %d", n, bhdr.Size, bhdr.Offset)
-		}
-		curOffset = bhdr.Offset + n
-	}
-	return nil
-}
-
-// BasicInfoHeader creates a tar header from basic file information.
-func BasicInfoHeader(name string, size int64, fileInfo *winio.FileBasicInfo) *tar.Header {
-	hdr := &tar.Header{
-		Format:     tar.FormatPAX,
-		Name:       filepath.ToSlash(name),
-		Size:       size,
-		Typeflag:   tar.TypeReg,
-		ModTime:    time.Unix(0, fileInfo.LastWriteTime.Nanoseconds()),
-		ChangeTime: time.Unix(0, fileInfo.ChangeTime.Nanoseconds()),
-		AccessTime: time.Unix(0, fileInfo.LastAccessTime.Nanoseconds()),
-		PAXRecords: make(map[string]string),
-	}
-	hdr.PAXRecords[hdrFileAttributes] = fmt.Sprintf("%d", fileInfo.FileAttributes)
-	hdr.PAXRecords[hdrCreationTime] = formatPAXTime(time.Unix(0, fileInfo.CreationTime.Nanoseconds()))
-
-	if (fileInfo.FileAttributes & syscall.FILE_ATTRIBUTE_DIRECTORY) != 0 {
-		hdr.Mode |= c_ISDIR
-		hdr.Size = 0
-		hdr.Typeflag = tar.TypeDir
-	}
-	return hdr
-}
-
-// WriteTarFileFromBackupStream writes a file to a tar writer using data from a Win32 backup stream.
-//
-// This encodes Win32 metadata as tar pax vendor extensions starting with MSWINDOWS.
-//
-// The additional Win32 metadata is:
-//
-// MSWINDOWS.fileattr: The Win32 file attributes, as a decimal value
-//
-// MSWINDOWS.rawsd: The Win32 security descriptor, in raw binary format
-//
-// MSWINDOWS.mountpoint: If present, this is a mount point and not a symlink, even though the type is '2' (symlink)
-func WriteTarFileFromBackupStream(t *tar.Writer, r io.Reader, name string, size int64, fileInfo *winio.FileBasicInfo) error {
-	name = filepath.ToSlash(name)
-	hdr := BasicInfoHeader(name, size, fileInfo)
-
-	// If r can be seeked, then this function is two-pass: pass 1 collects the
-	// tar header data, and pass 2 copies the data stream. If r cannot be
-	// seeked, then some header data (in particular EAs) will be silently lost.
-	var (
-		restartPos int64
-		err        error
-	)
-	sr, readTwice := r.(io.Seeker)
-	if readTwice {
-		if restartPos, err = sr.Seek(0, io.SeekCurrent); err != nil {
-			readTwice = false
-		}
-	}
-
-	br := winio.NewBackupStreamReader(r)
-	var dataHdr *winio.BackupHeader
-	for dataHdr == nil {
-		bhdr, err := br.Next()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return err
-		}
-		switch bhdr.Id {
-		case winio.BackupData:
-			hdr.Mode |= c_ISREG
-			if !readTwice {
-				dataHdr = bhdr
-			}
-		case winio.BackupSecurity:
-			sd, err := ioutil.ReadAll(br)
-			if err != nil {
-				return err
-			}
-			hdr.PAXRecords[hdrRawSecurityDescriptor] = base64.StdEncoding.EncodeToString(sd)
-
-		case winio.BackupReparseData:
-			hdr.Mode |= c_ISLNK
-			hdr.Typeflag = tar.TypeSymlink
-			reparseBuffer, err := ioutil.ReadAll(br)
-			rp, err := winio.DecodeReparsePoint(reparseBuffer)
-			if err != nil {
-				return err
-			}
-			if rp.IsMountPoint {
-				hdr.PAXRecords[hdrMountPoint] = "1"
-			}
-			hdr.Linkname = rp.Target
-
-		case winio.BackupEaData:
-			eab, err := ioutil.ReadAll(br)
-			if err != nil {
-				return err
-			}
-			eas, err := winio.DecodeExtendedAttributes(eab)
-			if err != nil {
-				return err
-			}
-			for _, ea := range eas {
-				// Use base64 encoding for the binary value. Note that there
-				// is no way to encode the EA's flags, since their use doesn't
-				// make any sense for persisted EAs.
-				hdr.PAXRecords[hdrEaPrefix+ea.Name] = base64.StdEncoding.EncodeToString(ea.Value)
-			}
-
-		case winio.BackupAlternateData, winio.BackupLink, winio.BackupPropertyData, winio.BackupObjectId, winio.BackupTxfsData:
-			// ignore these streams
-		default:
-			return fmt.Errorf("%s: unknown stream ID %d", name, bhdr.Id)
-		}
-	}
-
-	err = t.WriteHeader(hdr)
-	if err != nil {
-		return err
-	}
-
-	if readTwice {
-		// Get back to the data stream.
-		if _, err = sr.Seek(restartPos, io.SeekStart); err != nil {
-			return err
-		}
-		for dataHdr == nil {
-			bhdr, err := br.Next()
-			if err == io.EOF {
-				break
-			}
-			if err != nil {
-				return err
-			}
-			if bhdr.Id == winio.BackupData {
-				dataHdr = bhdr
-			}
-		}
-	}
-
-	// The logic for copying file contents is fairly complicated due to the need for handling sparse files,
-	// and the weird ways they are represented by BackupRead. A normal file will always either have a data stream
-	// with size and content, or no data stream at all (if empty). However, for a sparse file, the content can also
-	// be represented using a series of sparse block streams following the data stream. Additionally, the way sparse
-	// files are handled by BackupRead has changed in the OS recently. The specifics of the representation are described
-	// in the list at the bottom of this block comment.
-	//
-	// Sparse files can be represented in four different ways, based on the specifics of the file.
-	// - Size = 0:
-	//     Previously: BackupRead yields no data stream and no sparse block streams.
-	//     Recently: BackupRead yields a data stream with size = 0. There are no following sparse block streams.
-	// - Size > 0, no allocated ranges:
-	//     BackupRead yields a data stream with size = 0. Following is a single sparse block stream with
-	//     size = 0 and offset = <file size>.
-	// - Size > 0, one allocated range:
-	//     BackupRead yields a data stream with size = <file size> containing the file contents. There are no
-	//     sparse block streams. This is the case if you take a normal file with contents and simply set the
-	//     sparse flag on it.
-	// - Size > 0, multiple allocated ranges:
-	//     BackupRead yields a data stream with size = 0. Following are sparse block streams for each allocated
-	//     range of the file containing the range contents. Finally there is a sparse block stream with
-	//     size = 0 and offset = <file size>.
-
-	if dataHdr != nil {
-		// A data stream was found. Copy the data.
-		// We assume that we will either have a data stream size > 0 XOR have sparse block streams.
-		if dataHdr.Size > 0 || (dataHdr.Attributes&winio.StreamSparseAttributes) == 0 {
-			if size != dataHdr.Size {
-				return fmt.Errorf("%s: mismatch between file size %d and header size %d", name, size, dataHdr.Size)
-			}
-			if _, err = io.Copy(t, br); err != nil {
-				return fmt.Errorf("%s: copying contents from data stream: %s", name, err)
-			}
-		} else if size > 0 {
-			// As of a recent OS change, BackupRead now returns a data stream for empty sparse files.
-			// These files have no sparse block streams, so skip the copySparse call if file size = 0.
-			if err = copySparse(t, br); err != nil {
-				return fmt.Errorf("%s: copying contents from sparse block stream: %s", name, err)
-			}
-		}
-	}
-
-	// Look for streams after the data stream. The only ones we handle are alternate data streams.
-	// Other streams may have metadata that could be serialized, but the tar header has already
-	// been written. In practice, this means that we don't get EA or TXF metadata.
-	for {
-		bhdr, err := br.Next()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return err
-		}
-		switch bhdr.Id {
-		case winio.BackupAlternateData:
-			altName := bhdr.Name
-			if strings.HasSuffix(altName, ":$DATA") {
-				altName = altName[:len(altName)-len(":$DATA")]
-			}
-			if (bhdr.Attributes & winio.StreamSparseAttributes) == 0 {
-				hdr = &tar.Header{
-					Format:     hdr.Format,
-					Name:       name + altName,
-					Mode:       hdr.Mode,
-					Typeflag:   tar.TypeReg,
-					Size:       bhdr.Size,
-					ModTime:    hdr.ModTime,
-					AccessTime: hdr.AccessTime,
-					ChangeTime: hdr.ChangeTime,
-				}
-				err = t.WriteHeader(hdr)
-				if err != nil {
-					return err
-				}
-				_, err = io.Copy(t, br)
-				if err != nil {
-					return err
-				}
-
-			} else {
-				// Unsupported for now, since the size of the alternate stream is not present
-				// in the backup stream until after the data has been read.
-				return fmt.Errorf("%s: tar of sparse alternate data streams is unsupported", name)
-			}
-		case winio.BackupEaData, winio.BackupLink, winio.BackupPropertyData, winio.BackupObjectId, winio.BackupTxfsData:
-			// ignore these streams
-		default:
-			return fmt.Errorf("%s: unknown stream ID %d after data", name, bhdr.Id)
-		}
-	}
-	return nil
-}
-
-// FileInfoFromHeader retrieves basic Win32 file information from a tar header, using the additional metadata written by
-// WriteTarFileFromBackupStream.
-func FileInfoFromHeader(hdr *tar.Header) (name string, size int64, fileInfo *winio.FileBasicInfo, err error) {
-	name = hdr.Name
-	if hdr.Typeflag == tar.TypeReg || hdr.Typeflag == tar.TypeRegA {
-		size = hdr.Size
-	}
-	fileInfo = &winio.FileBasicInfo{
-		LastAccessTime: windows.NsecToFiletime(hdr.AccessTime.UnixNano()),
-		LastWriteTime:  windows.NsecToFiletime(hdr.ModTime.UnixNano()),
-		ChangeTime:     windows.NsecToFiletime(hdr.ChangeTime.UnixNano()),
-		// Default to ModTime, we'll pull hdrCreationTime below if present
-		CreationTime: windows.NsecToFiletime(hdr.ModTime.UnixNano()),
-	}
-	if attrStr, ok := hdr.PAXRecords[hdrFileAttributes]; ok {
-		attr, err := strconv.ParseUint(attrStr, 10, 32)
-		if err != nil {
-			return "", 0, nil, err
-		}
-		fileInfo.FileAttributes = uint32(attr)
-	} else {
-		if hdr.Typeflag == tar.TypeDir {
-			fileInfo.FileAttributes |= syscall.FILE_ATTRIBUTE_DIRECTORY
-		}
-	}
-	if creationTimeStr, ok := hdr.PAXRecords[hdrCreationTime]; ok {
-		creationTime, err := parsePAXTime(creationTimeStr)
-		if err != nil {
-			return "", 0, nil, err
-		}
-		fileInfo.CreationTime = windows.NsecToFiletime(creationTime.UnixNano())
-	}
-	return
-}
-
-// WriteBackupStreamFromTarFile writes a Win32 backup stream from the current tar file. Since this function may process multiple
-// tar file entries in order to collect all the alternate data streams for the file, it returns the next
-// tar file that was not processed, or io.EOF is there are no more.
-func WriteBackupStreamFromTarFile(w io.Writer, t *tar.Reader, hdr *tar.Header) (*tar.Header, error) {
-	bw := winio.NewBackupStreamWriter(w)
-	var sd []byte
-	var err error
-	// Maintaining old SDDL-based behavior for backward compatibility.  All new tar headers written
-	// by this library will have raw binary for the security descriptor.
-	if sddl, ok := hdr.PAXRecords[hdrSecurityDescriptor]; ok {
-		sd, err = winio.SddlToSecurityDescriptor(sddl)
-		if err != nil {
-			return nil, err
-		}
-	}
-	if sdraw, ok := hdr.PAXRecords[hdrRawSecurityDescriptor]; ok {
-		sd, err = base64.StdEncoding.DecodeString(sdraw)
-		if err != nil {
-			return nil, err
-		}
-	}
-	if len(sd) != 0 {
-		bhdr := winio.BackupHeader{
-			Id:   winio.BackupSecurity,
-			Size: int64(len(sd)),
-		}
-		err := bw.WriteHeader(&bhdr)
-		if err != nil {
-			return nil, err
-		}
-		_, err = bw.Write(sd)
-		if err != nil {
-			return nil, err
-		}
-	}
-	var eas []winio.ExtendedAttribute
-	for k, v := range hdr.PAXRecords {
-		if !strings.HasPrefix(k, hdrEaPrefix) {
-			continue
-		}
-		data, err := base64.StdEncoding.DecodeString(v)
-		if err != nil {
-			return nil, err
-		}
-		eas = append(eas, winio.ExtendedAttribute{
-			Name:  k[len(hdrEaPrefix):],
-			Value: data,
-		})
-	}
-	if len(eas) != 0 {
-		eadata, err := winio.EncodeExtendedAttributes(eas)
-		if err != nil {
-			return nil, err
-		}
-		bhdr := winio.BackupHeader{
-			Id:   winio.BackupEaData,
-			Size: int64(len(eadata)),
-		}
-		err = bw.WriteHeader(&bhdr)
-		if err != nil {
-			return nil, err
-		}
-		_, err = bw.Write(eadata)
-		if err != nil {
-			return nil, err
-		}
-	}
-	if hdr.Typeflag == tar.TypeSymlink {
-		_, isMountPoint := hdr.PAXRecords[hdrMountPoint]
-		rp := winio.ReparsePoint{
-			Target:       filepath.FromSlash(hdr.Linkname),
-			IsMountPoint: isMountPoint,
-		}
-		reparse := winio.EncodeReparsePoint(&rp)
-		bhdr := winio.BackupHeader{
-			Id:   winio.BackupReparseData,
-			Size: int64(len(reparse)),
-		}
-		err := bw.WriteHeader(&bhdr)
-		if err != nil {
-			return nil, err
-		}
-		_, err = bw.Write(reparse)
-		if err != nil {
-			return nil, err
-		}
-	}
-	if hdr.Typeflag == tar.TypeReg || hdr.Typeflag == tar.TypeRegA {
-		bhdr := winio.BackupHeader{
-			Id:   winio.BackupData,
-			Size: hdr.Size,
-		}
-		err := bw.WriteHeader(&bhdr)
-		if err != nil {
-			return nil, err
-		}
-		_, err = io.Copy(bw, t)
-		if err != nil {
-			return nil, err
-		}
-	}
-	// Copy all the alternate data streams and return the next non-ADS header.
-	for {
-		ahdr, err := t.Next()
-		if err != nil {
-			return nil, err
-		}
-		if ahdr.Typeflag != tar.TypeReg || !strings.HasPrefix(ahdr.Name, hdr.Name+":") {
-			return ahdr, nil
-		}
-		bhdr := winio.BackupHeader{
-			Id:   winio.BackupAlternateData,
-			Size: ahdr.Size,
-			Name: ahdr.Name[len(hdr.Name):] + ":$DATA",
-		}
-		err = bw.WriteHeader(&bhdr)
-		if err != nil {
-			return nil, err
-		}
-		_, err = io.Copy(bw, t)
-		if err != nil {
-			return nil, err
-		}
-	}
-}
--- a/vendor/github.com/Microsoft/go-winio/fileinfo.go
+++ b/vendor/github.com/Microsoft/go-winio/fileinfo.go
@ -5,14 +5,21 @@ package winio
 import (
 	"os"
 	"runtime"
+	"syscall"
 	"unsafe"
+)

-	"golang.org/x/sys/windows"
+//sys getFileInformationByHandleEx(h syscall.Handle, class uint32, buffer *byte, size uint32) (err error) = GetFileInformationByHandleEx
+//sys setFileInformationByHandle(h syscall.Handle, class uint32, buffer *byte, size uint32) (err error) = SetFileInformationByHandle
+
+const (
+	fileBasicInfo = 0
+	fileIDInfo    = 0x12
 )

 // FileBasicInfo contains file access time and file attributes information.
 type FileBasicInfo struct {
-	CreationTime, LastAccessTime, LastWriteTime, ChangeTime windows.Filetime
+	CreationTime, LastAccessTime, LastWriteTime, ChangeTime syscall.Filetime
 	FileAttributes                                          uint32
 	pad                                                     uint32 // padding
 }
@ -20,7 +27,7 @@ type FileBasicInfo struct {
 // GetFileBasicInfo retrieves times and attributes for a file.
 func GetFileBasicInfo(f *os.File) (*FileBasicInfo, error) {
 	bi := &FileBasicInfo{}
-	if err := windows.GetFileInformationByHandleEx(windows.Handle(f.Fd()), windows.FileBasicInfo, (*byte)(unsafe.Pointer(bi)), uint32(unsafe.Sizeof(*bi))); err != nil {
+	if err := getFileInformationByHandleEx(syscall.Handle(f.Fd()), fileBasicInfo, (*byte)(unsafe.Pointer(bi)), uint32(unsafe.Sizeof(*bi))); err != nil {
 		return nil, &os.PathError{Op: "GetFileInformationByHandleEx", Path: f.Name(), Err: err}
 	}
 	runtime.KeepAlive(f)
@ -29,32 +36,13 @@ func GetFileBasicInfo(f *os.File) (*FileBasicInfo, error) {

 // SetFileBasicInfo sets times and attributes for a file.
 func SetFileBasicInfo(f *os.File, bi *FileBasicInfo) error {
-	if err := windows.SetFileInformationByHandle(windows.Handle(f.Fd()), windows.FileBasicInfo, (*byte)(unsafe.Pointer(bi)), uint32(unsafe.Sizeof(*bi))); err != nil {
+	if err := setFileInformationByHandle(syscall.Handle(f.Fd()), fileBasicInfo, (*byte)(unsafe.Pointer(bi)), uint32(unsafe.Sizeof(*bi))); err != nil {
 		return &os.PathError{Op: "SetFileInformationByHandle", Path: f.Name(), Err: err}
 	}
 	runtime.KeepAlive(f)
 	return nil
 }

-// FileStandardInfo contains extended information for the file.
-// FILE_STANDARD_INFO in WinBase.h
-// https://docs.microsoft.com/en-us/windows/win32/api/winbase/ns-winbase-file_standard_info
-type FileStandardInfo struct {
-	AllocationSize, EndOfFile int64
-	NumberOfLinks             uint32
-	DeletePending, Directory  bool
-}
-
-// GetFileStandardInfo retrieves ended information for the file.
-func GetFileStandardInfo(f *os.File) (*FileStandardInfo, error) {
-	si := &FileStandardInfo{}
-	if err := windows.GetFileInformationByHandleEx(windows.Handle(f.Fd()), windows.FileStandardInfo, (*byte)(unsafe.Pointer(si)), uint32(unsafe.Sizeof(*si))); err != nil {
-		return nil, &os.PathError{Op: "GetFileInformationByHandleEx", Path: f.Name(), Err: err}
-	}
-	runtime.KeepAlive(f)
-	return si, nil
-}
-
 // FileIDInfo contains the volume serial number and file ID for a file. This pair should be
 // unique on a system.
 type FileIDInfo struct {
@ -65,7 +53,7 @@ type FileIDInfo struct {
 // GetFileID retrieves the unique (volume, file ID) pair for a file.
 func GetFileID(f *os.File) (*FileIDInfo, error) {
 	fileID := &FileIDInfo{}
-	if err := windows.GetFileInformationByHandleEx(windows.Handle(f.Fd()), windows.FileIdInfo, (*byte)(unsafe.Pointer(fileID)), uint32(unsafe.Sizeof(*fileID))); err != nil {
+	if err := getFileInformationByHandleEx(syscall.Handle(f.Fd()), fileIDInfo, (*byte)(unsafe.Pointer(fileID)), uint32(unsafe.Sizeof(*fileID))); err != nil {
 		return nil, &os.PathError{Op: "GetFileInformationByHandleEx", Path: f.Name(), Err: err}
 	}
 	runtime.KeepAlive(f)
--- a/vendor/github.com/Microsoft/go-winio/go.mod
+++ b/vendor/github.com/Microsoft/go-winio/go.mod
@ -0,0 +1,9 @@
+module github.com/Microsoft/go-winio
+
+go 1.12
+
+require (
+	github.com/pkg/errors v0.8.1
+	github.com/sirupsen/logrus v1.4.1
+	golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b
+)
--- a/vendor/github.com/Microsoft/go-winio/go.sum
+++ b/vendor/github.com/Microsoft/go-winio/go.sum
@ -0,0 +1,16 @@
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/sirupsen/logrus v1.4.1 h1:GL2rEmy6nsikmW0r8opw9JIRScdMF5hA8cOYLH7In1k=
+github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q=
+github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b h1:ag/x1USPSsqHud38I9BAC88qdNLDHHtQ4mlgQIZPPNA=
+golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
--- a/vendor/github.com/Microsoft/go-winio/hvsock.go
+++ b/vendor/github.com/Microsoft/go-winio/hvsock.go
@ -1,5 +1,3 @@
-// +build windows
-
 package winio

 import (
--- a/vendor/github.com/Microsoft/go-winio/pipe.go
+++ b/vendor/github.com/Microsoft/go-winio/pipe.go
@ -182,14 +182,13 @@ func (s pipeAddress) String() string {
 }

 // tryDialPipe attempts to dial the pipe at `path` until `ctx` cancellation or timeout.
-func tryDialPipe(ctx context.Context, path *string, access uint32) (syscall.Handle, error) {
+func tryDialPipe(ctx context.Context, path *string) (syscall.Handle, error) {
 	for {
-
 		select {
 		case <-ctx.Done():
 			return syscall.Handle(0), ctx.Err()
 		default:
-			h, err := createFile(*path, access, 0, nil, syscall.OPEN_EXISTING, syscall.FILE_FLAG_OVERLAPPED|cSECURITY_SQOS_PRESENT|cSECURITY_ANONYMOUS, 0)
+			h, err := createFile(*path, syscall.GENERIC_READ|syscall.GENERIC_WRITE, 0, nil, syscall.OPEN_EXISTING, syscall.FILE_FLAG_OVERLAPPED|cSECURITY_SQOS_PRESENT|cSECURITY_ANONYMOUS, 0)
 			if err == nil {
 				return h, nil
 			}
@ -198,7 +197,7 @@ func tryDialPipe(ctx context.Context, path *string, access uint32) (syscall.Hand
 			}
 			// Wait 10 msec and try again. This is a rather simplistic
 			// view, as we always try each 10 milliseconds.
-			time.Sleep(10 * time.Millisecond)
+			time.Sleep(time.Millisecond * 10)
 		}
 	}
 }
@ -211,7 +210,7 @@ func DialPipe(path string, timeout *time.Duration) (net.Conn, error) {
 	if timeout != nil {
 		absTimeout = time.Now().Add(*timeout)
 	} else {
-		absTimeout = time.Now().Add(2 * time.Second)
+		absTimeout = time.Now().Add(time.Second * 2)
 	}
 	ctx, _ := context.WithDeadline(context.Background(), absTimeout)
 	conn, err := DialPipeContext(ctx, path)
@ -224,15 +223,9 @@ func DialPipe(path string, timeout *time.Duration) (net.Conn, error) {
 // DialPipeContext attempts to connect to a named pipe by `path` until `ctx`
 // cancellation or timeout.
 func DialPipeContext(ctx context.Context, path string) (net.Conn, error) {
-	return DialPipeAccess(ctx, path, syscall.GENERIC_READ|syscall.GENERIC_WRITE)
-}
-
-// DialPipeAccess attempts to connect to a named pipe by `path` with `access` until `ctx`
-// cancellation or timeout.
-func DialPipeAccess(ctx context.Context, path string, access uint32) (net.Conn, error) {
 	var err error
 	var h syscall.Handle
-	h, err = tryDialPipe(ctx, &path, access)
+	h, err = tryDialPipe(ctx, &path)
 	if err != nil {
 		return nil, err
 	}
@ -429,10 +422,10 @@ type PipeConfig struct {
 	// when the pipe is in message mode.
 	MessageMode bool

-	// InputBufferSize specifies the size of the input buffer, in bytes.
+	// InputBufferSize specifies the size the input buffer, in bytes.
 	InputBufferSize int32

-	// OutputBufferSize specifies the size of the output buffer, in bytes.
+	// OutputBufferSize specifies the size the input buffer, in bytes.
 	OutputBufferSize int32
 }

--- a/vendor/github.com/Microsoft/go-winio/pkg/guid/guid.go
+++ b/vendor/github.com/Microsoft/go-winio/pkg/guid/guid.go
@ -1,5 +1,3 @@
-// +build windows
-
 // Package guid provides a GUID type. The backing structure for a GUID is
 // identical to that used by the golang.org/x/sys/windows GUID type.
 // There are two main binary encodings used for a GUID, the big-endian encoding,
--- a/vendor/github.com/Microsoft/go-winio/pkg/security/grantvmgroupaccess.go
+++ b/vendor/github.com/Microsoft/go-winio/pkg/security/grantvmgroupaccess.go
@ -1,161 +0,0 @@
-// +build windows
-
-package security
-
-import (
-	"os"
-	"syscall"
-	"unsafe"
-
-	"github.com/pkg/errors"
-)
-
-type (
-	accessMask          uint32
-	accessMode          uint32
-	desiredAccess       uint32
-	inheritMode         uint32
-	objectType          uint32
-	shareMode           uint32
-	securityInformation uint32
-	trusteeForm         uint32
-	trusteeType         uint32
-
-	explicitAccess struct {
-		accessPermissions accessMask
-		accessMode        accessMode
-		inheritance       inheritMode
-		trustee           trustee
-	}
-
-	trustee struct {
-		multipleTrustee          *trustee
-		multipleTrusteeOperation int32
-		trusteeForm              trusteeForm
-		trusteeType              trusteeType
-		name                     uintptr
-	}
-)
-
-const (
-	accessMaskDesiredPermission accessMask = 1 << 31 // GENERIC_READ
-
-	accessModeGrant accessMode = 1
-
-	desiredAccessReadControl desiredAccess = 0x20000
-	desiredAccessWriteDac    desiredAccess = 0x40000
-
-	gvmga = "GrantVmGroupAccess:"
-
-	inheritModeNoInheritance                  inheritMode = 0x0
-	inheritModeSubContainersAndObjectsInherit inheritMode = 0x3
-
-	objectTypeFileObject objectType = 0x1
-
-	securityInformationDACL securityInformation = 0x4
-
-	shareModeRead  shareMode = 0x1
-	shareModeWrite shareMode = 0x2
-
-	sidVmGroup = "S-1-5-83-0"
-
-	trusteeFormIsSid trusteeForm = 0
-
-	trusteeTypeWellKnownGroup trusteeType = 5
-)
-
-// GrantVMGroupAccess sets the DACL for a specified file or directory to
-// include Grant ACE entries for the VM Group SID. This is a golang re-
-// implementation of the same function in vmcompute, just not exported in
-// RS5. Which kind of sucks. Sucks a lot :/
-func GrantVmGroupAccess(name string) error {
-	// Stat (to determine if `name` is a directory).
-	s, err := os.Stat(name)
-	if err != nil {
-		return errors.Wrapf(err, "%s os.Stat %s", gvmga, name)
-	}
-
-	// Get a handle to the file/directory. Must defer Close on success.
-	fd, err := createFile(name, s.IsDir())
-	if err != nil {
-		return err // Already wrapped
-	}
-	defer syscall.CloseHandle(fd)
-
-	// Get the current DACL and Security Descriptor. Must defer LocalFree on success.
-	ot := objectTypeFileObject
-	si := securityInformationDACL
-	sd := uintptr(0)
-	origDACL := uintptr(0)
-	if err := getSecurityInfo(fd, uint32(ot), uint32(si), nil, nil, &origDACL, nil, &sd); err != nil {
-		return errors.Wrapf(err, "%s GetSecurityInfo %s", gvmga, name)
-	}
-	defer syscall.LocalFree((syscall.Handle)(unsafe.Pointer(sd)))
-
-	// Generate a new DACL which is the current DACL with the required ACEs added.
-	// Must defer LocalFree on success.
-	newDACL, err := generateDACLWithAcesAdded(name, s.IsDir(), origDACL)
-	if err != nil {
-		return err // Already wrapped
-	}
-	defer syscall.LocalFree((syscall.Handle)(unsafe.Pointer(newDACL)))
-
-	// And finally use SetSecurityInfo to apply the updated DACL.
-	if err := setSecurityInfo(fd, uint32(ot), uint32(si), uintptr(0), uintptr(0), newDACL, uintptr(0)); err != nil {
-		return errors.Wrapf(err, "%s SetSecurityInfo %s", gvmga, name)
-	}
-
-	return nil
-}
-
-// createFile is a helper function to call [Nt]CreateFile to get a handle to
-// the file or directory.
-func createFile(name string, isDir bool) (syscall.Handle, error) {
-	namep := syscall.StringToUTF16(name)
-	da := uint32(desiredAccessReadControl | desiredAccessWriteDac)
-	sm := uint32(shareModeRead | shareModeWrite)
-	fa := uint32(syscall.FILE_ATTRIBUTE_NORMAL)
-	if isDir {
-		fa = uint32(fa | syscall.FILE_FLAG_BACKUP_SEMANTICS)
-	}
-	fd, err := syscall.CreateFile(&namep[0], da, sm, nil, syscall.OPEN_EXISTING, fa, 0)
-	if err != nil {
-		return 0, errors.Wrapf(err, "%s syscall.CreateFile %s", gvmga, name)
-	}
-	return fd, nil
-}
-
-// generateDACLWithAcesAdded generates a new DACL with the two needed ACEs added.
-// The caller is responsible for LocalFree of the returned DACL on success.
-func generateDACLWithAcesAdded(name string, isDir bool, origDACL uintptr) (uintptr, error) {
-	// Generate pointers to the SIDs based on the string SIDs
-	sid, err := syscall.StringToSid(sidVmGroup)
-	if err != nil {
-		return 0, errors.Wrapf(err, "%s syscall.StringToSid %s %s", gvmga, name, sidVmGroup)
-	}
-
-	inheritance := inheritModeNoInheritance
-	if isDir {
-		inheritance = inheritModeSubContainersAndObjectsInherit
-	}
-
-	eaArray := []explicitAccess{
-		explicitAccess{
-			accessPermissions: accessMaskDesiredPermission,
-			accessMode:        accessModeGrant,
-			inheritance:       inheritance,
-			trustee: trustee{
-				trusteeForm: trusteeFormIsSid,
-				trusteeType: trusteeTypeWellKnownGroup,
-				name:        uintptr(unsafe.Pointer(sid)),
-			},
-		},
-	}
-
-	modifiedDACL := uintptr(0)
-	if err := setEntriesInAcl(uintptr(uint32(1)), uintptr(unsafe.Pointer(&eaArray[0])), origDACL, &modifiedDACL); err != nil {
-		return 0, errors.Wrapf(err, "%s SetEntriesInAcl %s", gvmga, name)
-	}
-
-	return modifiedDACL, nil
-}
--- a/vendor/github.com/Microsoft/go-winio/pkg/security/syscall_windows.go
+++ b/vendor/github.com/Microsoft/go-winio/pkg/security/syscall_windows.go
@ -1,7 +0,0 @@
-package security
-
-//go:generate go run mksyscall_windows.go -output zsyscall_windows.go syscall_windows.go
-
-//sys getSecurityInfo(handle syscall.Handle, objectType uint32, si uint32, ppsidOwner **uintptr, ppsidGroup **uintptr, ppDacl *uintptr, ppSacl *uintptr, ppSecurityDescriptor *uintptr) (win32err error) = advapi32.GetSecurityInfo
-//sys setSecurityInfo(handle syscall.Handle, objectType uint32, si uint32, psidOwner uintptr, psidGroup uintptr, pDacl uintptr, pSacl uintptr) (win32err error) = advapi32.SetSecurityInfo
-//sys setEntriesInAcl(count uintptr, pListOfEEs uintptr, oldAcl uintptr, newAcl *uintptr) (win32err error) = advapi32.SetEntriesInAclW
--- a/vendor/github.com/Microsoft/go-winio/pkg/security/zsyscall_windows.go
+++ b/vendor/github.com/Microsoft/go-winio/pkg/security/zsyscall_windows.go
@ -1,70 +0,0 @@
-// Code generated by 'go generate'; DO NOT EDIT.
-
-package security
-
-import (
-	"syscall"
-	"unsafe"
-
-	"golang.org/x/sys/windows"
-)
-
-var _ unsafe.Pointer
-
-// Do the interface allocations only once for common
-// Errno values.
-const (
-	errnoERROR_IO_PENDING = 997
-)
-
-var (
-	errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
-	errERROR_EINVAL     error = syscall.EINVAL
-)
-
-// errnoErr returns common boxed Errno values, to prevent
-// allocations at runtime.
-func errnoErr(e syscall.Errno) error {
-	switch e {
-	case 0:
-		return errERROR_EINVAL
-	case errnoERROR_IO_PENDING:
-		return errERROR_IO_PENDING
-	}
-	// TODO: add more here, after collecting data on the common
-	// error values see on Windows. (perhaps when running
-	// all.bat?)
-	return e
-}
-
-var (
-	modadvapi32 = windows.NewLazySystemDLL("advapi32.dll")
-
-	procGetSecurityInfo  = modadvapi32.NewProc("GetSecurityInfo")
-	procSetEntriesInAclW = modadvapi32.NewProc("SetEntriesInAclW")
-	procSetSecurityInfo  = modadvapi32.NewProc("SetSecurityInfo")
-)
-
-func getSecurityInfo(handle syscall.Handle, objectType uint32, si uint32, ppsidOwner **uintptr, ppsidGroup **uintptr, ppDacl *uintptr, ppSacl *uintptr, ppSecurityDescriptor *uintptr) (win32err error) {
-	r0, _, _ := syscall.Syscall9(procGetSecurityInfo.Addr(), 8, uintptr(handle), uintptr(objectType), uintptr(si), uintptr(unsafe.Pointer(ppsidOwner)), uintptr(unsafe.Pointer(ppsidGroup)), uintptr(unsafe.Pointer(ppDacl)), uintptr(unsafe.Pointer(ppSacl)), uintptr(unsafe.Pointer(ppSecurityDescriptor)), 0)
-	if r0 != 0 {
-		win32err = syscall.Errno(r0)
-	}
-	return
-}
-
-func setEntriesInAcl(count uintptr, pListOfEEs uintptr, oldAcl uintptr, newAcl *uintptr) (win32err error) {
-	r0, _, _ := syscall.Syscall6(procSetEntriesInAclW.Addr(), 4, uintptr(count), uintptr(pListOfEEs), uintptr(oldAcl), uintptr(unsafe.Pointer(newAcl)), 0, 0)
-	if r0 != 0 {
-		win32err = syscall.Errno(r0)
-	}
-	return
-}
-
-func setSecurityInfo(handle syscall.Handle, objectType uint32, si uint32, psidOwner uintptr, psidGroup uintptr, pDacl uintptr, pSacl uintptr) (win32err error) {
-	r0, _, _ := syscall.Syscall9(procSetSecurityInfo.Addr(), 7, uintptr(handle), uintptr(objectType), uintptr(si), uintptr(psidOwner), uintptr(psidGroup), uintptr(pDacl), uintptr(pSacl), 0, 0)
-	if r0 != 0 {
-		win32err = syscall.Errno(r0)
-	}
-	return
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Alex Ellis (OpenFaaS Ltd)	409fa5e642	Alteration for version passing Signed-off-by: Alex Ellis (OpenFaaS Ltd) <alexellis2@gmail.com>	2019-12-31 12:27:21 +00:00
Alex Ellis (OpenFaaS Ltd)	03fe48db99	Pass version from main Signed-off-by: Alex Ellis (OpenFaaS Ltd) <alexellis2@gmail.com>	2019-12-31 12:22:21 +00:00