33 files changed, 1380 insertions, 240 deletions

diff --git a/vendor/github.com/hashicorp/go-getter/.travis.yml b/vendor/github.com/hashicorp/go-getter/.travis.yml
index da804c2..4fe9176 100644
--- a/vendor/github.com/hashicorp/go-getter/.travis.yml
+++ b/vendor/github.com/hashicorp/go-getter/.travis.yml
@@ -9,15 +9,16 @@ addons:
 
 language: go
 
+os:
+  - linux
+  - osx
+
 go:
-  - 1.8.x
-  - 1.9.x
-  - master
+  - "1.11.x"
+
+before_script:
+  - go build ./cmd/go-getter
 
 branches:
   only:
     - master
-
-matrix:
-  allow_failures:
-    - go: master
diff --git a/vendor/github.com/hashicorp/go-getter/README.md b/vendor/github.com/hashicorp/go-getter/README.md
index 40ace74..ba4df6f 100644
--- a/vendor/github.com/hashicorp/go-getter/README.md
+++ b/vendor/github.com/hashicorp/go-getter/README.md
@@ -71,6 +71,7 @@ can be augmented at runtime by implementing the `Getter` interface.
   * Mercurial
   * HTTP
   * Amazon S3
+  * Google GCP
 
 In addition to the above protocols, go-getter has what are called "detectors."
 These take a URL and attempt to automatically choose the best protocol for
@@ -97,7 +98,7 @@ would download the given HTTP URL using the Git protocol.
 
 Forced protocols will also override any detectors.
 
-In the absense of a forced protocol, detectors may be run on the URL, transforming
+In the absence of a forced protocol, detectors may be run on the URL, transforming
 the protocol anyways. The above example would've used the Git protocol either
 way since the Git detector would've detected it was a GitHub URL.
 
@@ -155,20 +156,44 @@ For file downloads of any protocol, go-getter can automatically verify
 a checksum for you. Note that checksumming only works for downloading files,
 not directories, but checksumming will work for any protocol.
 
-To checksum a file, append a `checksum` query parameter to the URL.
-The paramter value should be in the format of `type:value`, where
-type is "md5", "sha1", "sha256", or "sha512". The "value" should be
-the actual checksum value. go-getter will parse out this query parameter
-automatically and use it to verify the checksum. An example URL
-is shown below:
+To checksum a file, append a `checksum` query parameter to the URL. go-getter
+will parse out this query parameter automatically and use it to verify the
+checksum. The parameter value can be in the format of `type:value` or just
+`value`, where type is "md5", "sha1", "sha256", "sha512" or "file" . The
+"value" should be the actual checksum value or download URL for "file". When
+`type` part is omitted, type will be guessed based on the length of the
+checksum string. Examples:
 
 ```
 ./foo.txt?checksum=md5:b7d96c89d09d9e204f5fedc4d5d55b21
 ```
 
+```
+./foo.txt?checksum=b7d96c89d09d9e204f5fedc4d5d55b21
+```
+
+```
+./foo.txt?checksum=file:./foo.txt.sha256sum
+```
+ 
+When checksumming from a file - ex: with `checksum=file:url` - go-getter will
+get the file linked in the URL after `file:` using the same configuration. For
+example, in `file:http://releases.ubuntu.com/cosmic/MD5SUMS` go-getter will
+download a checksum file under the aforementioned url using the http protocol.
+All protocols supported by go-getter can be used. The checksum file will be
+downloaded in a temporary file then parsed. The destination of the temporary
+file can be changed by setting system specific environment variables: `TMPDIR`
+for unix; `TMP`, `TEMP` or `USERPROFILE` on windows. Read godoc of
+[os.TempDir](https://golang.org/pkg/os/#TempDir) for more information on the
+temporary directory selection. Content of files are expected to be BSD or GNU
+style. Once go-getter is done with the checksum file; it is deleted.
+
 The checksum query parameter is never sent to the backend protocol
 implementation. It is used at a higher level by go-getter itself.
 
+If the destination file exists and the checksums match: download
+will be skipped.
+
 ### Unarchiving
 
 go-getter will automatically unarchive files into a file or directory
@@ -215,11 +240,12 @@ from the URL before going to the final protocol downloader.
 
 ## Protocol-Specific Options
 
-This section documents the protocol-specific options that can be specified
-for go-getter. These options should be appended to the input as normal query
-parameters. Depending on the usage of go-getter, applications may provide
-alternate ways of inputting options. For example, [Nomad](https://www.nomadproject.io)
-provides a nice options block for specifying options rather than in the URL.
+This section documents the protocol-specific options that can be specified for
+go-getter. These options should be appended to the input as normal query
+parameters ([HTTP headers](#headers) are an exception to this, however).
+Depending on the usage of go-getter, applications may provide alternate ways of
+inputting options. For example, [Nomad](https://www.nomadproject.io) provides a
+nice options block for specifying options rather than in the URL.
 
 ## General (All Protocols)
 
@@ -250,6 +276,19 @@ None
     from a private key file on disk, you would run `base64 -w0 <file>`.
 
     **Note**: Git 2.3+ is required to use this feature.
+  
+  * `depth` - The Git clone depth. The provided number specifies the last `n`
+    revisions to clone from the repository.
+
+
+The `git` getter accepts both URL-style SSH addresses like
+`git::ssh://git@example.com/foo/bar`, and "scp-style" addresses like
+`git::git@example.com/foo/bar`. In the latter case, omitting the `git::`
+force prefix is allowed if the username prefix is exactly `git@`.
+
+The "scp-style" addresses _cannot_ be used in conjunction with the `ssh://`
+scheme prefix, because in that case the colon is used to mark an optional
+port number to connect on, rather than to delimit the path from the host.
 
 ### Mercurial (`hg`)
 
@@ -263,6 +302,13 @@ To use HTTP basic authentication with go-getter, simply prepend `username:passwo
 hostname in the URL such as `https://Aladdin:OpenSesame@www.example.com/index.html`. All special
 characters, including the username and password, must be URL encoded.
 
+#### Headers
+
+Optional request headers can be added by supplying them in a custom
+[`HttpGetter`](https://godoc.org/github.com/hashicorp/go-getter#HttpGetter)
+(_not_ as query parameters like most other options). These headers will be sent
+out on every request the getter in question makes.
+
 ### S3 (`s3`)
 
 S3 takes various access configurations in the URL. Note that it will also
@@ -299,3 +345,14 @@ Some examples for these addressing schemes:
 - bucket.s3-eu-west-1.amazonaws.com/foo/bar
 - "s3::http://127.0.0.1:9000/test-bucket/hello.txt?aws_access_key_id=KEYID&aws_access_key_secret=SECRETKEY&region=us-east-2"
 
+### GCS (`gcs`)
+
+#### GCS Authentication
+
+In order to access to GCS, authentication credentials should be provided. More information can be found [here](https://cloud.google.com/docs/authentication/getting-started)
+
+#### GCS Bucket Examples
+
+- gcs::https://www.googleapis.com/storage/v1/bucket
+- gcs::https://www.googleapis.com/storage/v1/bucket/foo.zip
+- www.googleapis.com/storage/v1/bucket/foo
diff --git a/vendor/github.com/hashicorp/go-getter/appveyor.yml b/vendor/github.com/hashicorp/go-getter/appveyor.yml
index ec48d45..1e8718e 100644
--- a/vendor/github.com/hashicorp/go-getter/appveyor.yml
+++ b/vendor/github.com/hashicorp/go-getter/appveyor.yml
@@ -13,4 +13,4 @@ install:
 
     go get -d -v -t ./...
 build_script:
-- cmd: go test -v ./...
+- cmd: go test ./...
diff --git a/vendor/github.com/hashicorp/go-getter/checksum.go b/vendor/github.com/hashicorp/go-getter/checksum.go
new file mode 100644
index 0000000..bea7ed1
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-getter/checksum.go
@@ -0,0 +1,314 @@
+package getter
+
+import (
+        "bufio"
+        "bytes"
+        "crypto/md5"
+        "crypto/sha1"
+        "crypto/sha256"
+        "crypto/sha512"
+        "encoding/hex"
+        "fmt"
+        "hash"
+        "io"
+        "net/url"
+        "os"
+        "path/filepath"
+        "strings"
+
+        urlhelper "github.com/hashicorp/go-getter/helper/url"
+)
+
+// fileChecksum helps verifying the checksum for a file.
+type fileChecksum struct {
+        Type     string
+        Hash     hash.Hash
+        Value    []byte
+        Filename string
+}
+
+// A ChecksumError is returned when a checksum differs
+type ChecksumError struct {
+        Hash     hash.Hash
+        Actual   []byte
+        Expected []byte
+        File     string
+}
+
+func (cerr *ChecksumError) Error() string {
+        if cerr == nil {
+                return "<nil>"
+        }
+        return fmt.Sprintf(
+                "Checksums did not match for %s.\nExpected: %s\nGot: %s\n%T",
+                cerr.File,
+                hex.EncodeToString(cerr.Expected),
+                hex.EncodeToString(cerr.Actual),
+                cerr.Hash, // ex: *sha256.digest
+        )
+}
+
+// checksum is a simple method to compute the checksum of a source file
+// and compare it to the given expected value.
+func (c *fileChecksum) checksum(source string) error {
+        f, err := os.Open(source)
+        if err != nil {
+                return fmt.Errorf("Failed to open file for checksum: %s", err)
+        }
+        defer f.Close()
+
+        c.Hash.Reset()
+        if _, err := io.Copy(c.Hash, f); err != nil {
+                return fmt.Errorf("Failed to hash: %s", err)
+        }
+
+        if actual := c.Hash.Sum(nil); !bytes.Equal(actual, c.Value) {
+                return &ChecksumError{
+                        Hash:     c.Hash,
+                        Actual:   actual,
+                        Expected: c.Value,
+                        File:     source,
+                }
+        }
+
+        return nil
+}
+
+// extractChecksum will return a fileChecksum based on the 'checksum'
+// parameter of u.
+// ex:
+//  http://hashicorp.com/terraform?checksum=<checksumValue>
+//  http://hashicorp.com/terraform?checksum=<checksumType>:<checksumValue>
+//  http://hashicorp.com/terraform?checksum=file:<checksum_url>
+// when checksumming from a file, extractChecksum will go get checksum_url
+// in a temporary directory, parse the content of the file then delete it.
+// Content of files are expected to be BSD style or GNU style.
+//
+// BSD-style checksum:
+//  MD5 (file1) = <checksum>
+//  MD5 (file2) = <checksum>
+//
+// GNU-style:
+//  <checksum>  file1
+//  <checksum> *file2
+//
+// see parseChecksumLine for more detail on checksum file parsing
+func (c *Client) extractChecksum(u *url.URL) (*fileChecksum, error) {
+        q := u.Query()
+        v := q.Get("checksum")
+
+        if v == "" {
+                return nil, nil
+        }
+
+        vs := strings.SplitN(v, ":", 2)
+        switch len(vs) {
+        case 2:
+                break // good
+        default:
+                // here, we try to guess the checksum from it's length
+                // if the type was not passed
+                return newChecksumFromValue(v, filepath.Base(u.EscapedPath()))
+        }
+
+        checksumType, checksumValue := vs[0], vs[1]
+
+        switch checksumType {
+        case "file":
+                return c.checksumFromFile(checksumValue, u)
+        default:
+                return newChecksumFromType(checksumType, checksumValue, filepath.Base(u.EscapedPath()))
+        }
+}
+
+func newChecksum(checksumValue, filename string) (*fileChecksum, error) {
+        c := &fileChecksum{
+                Filename: filename,
+        }
+        var err error
+        c.Value, err = hex.DecodeString(checksumValue)
+        if err != nil {
+                return nil, fmt.Errorf("invalid checksum: %s", err)
+        }
+        return c, nil
+}
+
+func newChecksumFromType(checksumType, checksumValue, filename string) (*fileChecksum, error) {
+        c, err := newChecksum(checksumValue, filename)
+        if err != nil {
+                return nil, err
+        }
+
+        c.Type = strings.ToLower(checksumType)
+        switch c.Type {
+        case "md5":
+                c.Hash = md5.New()
+        case "sha1":
+                c.Hash = sha1.New()
+        case "sha256":
+                c.Hash = sha256.New()
+        case "sha512":
+                c.Hash = sha512.New()
+        default:
+                return nil, fmt.Errorf(
+                        "unsupported checksum type: %s", checksumType)
+        }
+
+        return c, nil
+}
+
+func newChecksumFromValue(checksumValue, filename string) (*fileChecksum, error) {
+        c, err := newChecksum(checksumValue, filename)
+        if err != nil {
+                return nil, err
+        }
+
+        switch len(c.Value) {
+        case md5.Size:
+                c.Hash = md5.New()
+                c.Type = "md5"
+        case sha1.Size:
+                c.Hash = sha1.New()
+                c.Type = "sha1"
+        case sha256.Size:
+                c.Hash = sha256.New()
+                c.Type = "sha256"
+        case sha512.Size:
+                c.Hash = sha512.New()
+                c.Type = "sha512"
+        default:
+                return nil, fmt.Errorf("Unknown type for checksum %s", checksumValue)
+        }
+
+        return c, nil
+}
+
+// checksumsFromFile will return all the fileChecksums found in file
+//
+// checksumsFromFile will try to guess the hashing algorithm based on content
+// of checksum file
+//
+// checksumsFromFile will only return checksums for files that match file
+// behind src
+func (c *Client) checksumFromFile(checksumFile string, src *url.URL) (*fileChecksum, error) {
+        checksumFileURL, err := urlhelper.Parse(checksumFile)
+        if err != nil {
+                return nil, err
+        }
+
+        tempfile, err := tmpFile("", filepath.Base(checksumFileURL.Path))
+        if err != nil {
+                return nil, err
+        }
+        defer os.Remove(tempfile)
+
+        c2 := &Client{
+                Ctx:              c.Ctx,
+                Getters:          c.Getters,
+                Decompressors:    c.Decompressors,
+                Detectors:        c.Detectors,
+                Pwd:              c.Pwd,
+                Dir:              false,
+                Src:              checksumFile,
+                Dst:              tempfile,
+                ProgressListener: c.ProgressListener,
+        }
+        if err = c2.Get(); err != nil {
+                return nil, fmt.Errorf(
+                        "Error downloading checksum file: %s", err)
+        }
+
+        filename := filepath.Base(src.Path)
+        absPath, err := filepath.Abs(src.Path)
+        if err != nil {
+                return nil, err
+        }
+        checksumFileDir := filepath.Dir(checksumFileURL.Path)
+        relpath, err := filepath.Rel(checksumFileDir, absPath)
+        switch {
+        case err == nil ||
+                err.Error() == "Rel: can't make "+absPath+" relative to "+checksumFileDir:
+                // ex: on windows C:\gopath\...\content.txt cannot be relative to \
+                // which is okay, may be another expected path will work.
+                break
+        default:
+                return nil, err
+        }
+
+        // possible file identifiers:
+        options := []string{
+                filename,       // ubuntu-14.04.1-server-amd64.iso
+                "*" + filename, // *ubuntu-14.04.1-server-amd64.iso  Standard checksum
+                "?" + filename, // ?ubuntu-14.04.1-server-amd64.iso  shasum -p
+                relpath,        // dir/ubuntu-14.04.1-server-amd64.iso
+                "./" + relpath, // ./dir/ubuntu-14.04.1-server-amd64.iso
+                absPath,        // fullpath; set if local
+        }
+
+        f, err := os.Open(tempfile)
+        if err != nil {
+                return nil, fmt.Errorf(
+                        "Error opening downloaded file: %s", err)
+        }
+        defer f.Close()
+        rd := bufio.NewReader(f)
+        for {
+                line, err := rd.ReadString('\n')
+                if err != nil {
+                        if err != io.EOF {
+                                return nil, fmt.Errorf(
+                                        "Error reading checksum file: %s", err)
+                        }
+                        break
+                }
+                checksum, err := parseChecksumLine(line)
+                if err != nil || checksum == nil {
+                        continue
+                }
+                if checksum.Filename == "" {
+                        // filename not sure, let's try
+                        return checksum, nil
+                }
+                // make sure the checksum is for the right file
+                for _, option := range options {
+                        if option != "" && checksum.Filename == option {
+                                // any checksum will work so we return the first one
+                                return checksum, nil
+                        }
+                }
+        }
+        return nil, fmt.Errorf("no checksum found in: %s", checksumFile)
+}
+
+// parseChecksumLine takes a line from a checksum file and returns
+// checksumType, checksumValue and filename parseChecksumLine guesses the style
+// of the checksum BSD vs GNU by splitting the line and by counting the parts.
+// of a line.
+// for BSD type sums parseChecksumLine guesses the hashing algorithm
+// by checking the length of the checksum.
+func parseChecksumLine(line string) (*fileChecksum, error) {
+        parts := strings.Fields(line)
+
+        switch len(parts) {
+        case 4:
+                // BSD-style checksum:
+                //  MD5 (file1) = <checksum>
+                //  MD5 (file2) = <checksum>
+                if len(parts[1]) <= 2 ||
+                        parts[1][0] != '(' || parts[1][len(parts[1])-1] != ')' {
+                        return nil, fmt.Errorf(
+                                "Unexpected BSD-style-checksum filename format: %s", line)
+                }
+                filename := parts[1][1 : len(parts[1])-1]
+                return newChecksumFromType(parts[0], parts[3], filename)
+        case 2:
+                // GNU-style:
+                //  <checksum>  file1
+                //  <checksum> *file2
+                return newChecksumFromValue(parts[0], parts[1])
+        case 0:
+                return nil, nil // empty line
+        default:
+                return newChecksumFromValue(parts[0], "")
+        }
+}
diff --git a/vendor/github.com/hashicorp/go-getter/client.go b/vendor/github.com/hashicorp/go-getter/client.go
index 300301c..007a78b 100644
--- a/vendor/github.com/hashicorp/go-getter/client.go
+++ b/vendor/github.com/hashicorp/go-getter/client.go
@@ -1,15 +1,8 @@
 package getter
 
 import (
-        "bytes"
-        "crypto/md5"
-        "crypto/sha1"
-        "crypto/sha256"
-        "crypto/sha512"
-        "encoding/hex"
+        "context"
         "fmt"
-        "hash"
-        "io"
         "io/ioutil"
         "os"
         "path/filepath"
@@ -17,7 +10,7 @@ import (
         "strings"
 
         urlhelper "github.com/hashicorp/go-getter/helper/url"
-        "github.com/hashicorp/go-safetemp"
+        safetemp "github.com/hashicorp/go-safetemp"
 )
 
 // Client is a client for downloading things.
@@ -26,6 +19,9 @@ import (
 // Using a client directly allows more fine-grained control over how downloading
 // is done, as well as customizing the protocols supported.
 type Client struct {
+        // Ctx for cancellation
+        Ctx context.Context
+
         // Src is the source URL to get.
         //
         // Dst is the path to save the downloaded thing as. If Dir is set to
@@ -62,10 +58,20 @@ type Client struct {
         //
         // WARNING: deprecated. If Mode is set, that will take precedence.
         Dir bool
+
+        // ProgressListener allows to track file downloads.
+        // By default a no op progress listener is used.
+        ProgressListener ProgressTracker
+
+        Options []ClientOption
 }
 
 // Get downloads the configured source to the destination.
 func (c *Client) Get() error {
+        if err := c.Configure(c.Options...); err != nil {
+                return err
+        }
+
         // Store this locally since there are cases we swap this
         mode := c.Mode
         if mode == ClientModeInvalid {
@@ -76,18 +82,7 @@ func (c *Client) Get() error {
                 }
         }
 
-        // Default decompressor value
-        decompressors := c.Decompressors
-        if decompressors == nil {
-                decompressors = Decompressors
-        }
-
-        // Detect the URL. This is safe if it is already detected.
-        detectors := c.Detectors
-        if detectors == nil {
-                detectors = Detectors
-        }
-        src, err := Detect(c.Src, c.Pwd, detectors)
+        src, err := Detect(c.Src, c.Pwd, c.Detectors)
         if err != nil {
                 return err
         }
@@ -119,12 +114,7 @@ func (c *Client) Get() error {
                 force = u.Scheme
         }
 
-        getters := c.Getters
-        if getters == nil {
-                getters = Getters
-        }
-
-        g, ok := getters[force]
+        g, ok := c.Getters[force]
         if !ok {
                 return fmt.Errorf(
                         "download not supported for scheme '%s'", force)
@@ -150,7 +140,7 @@ func (c *Client) Get() error {
         if archiveV == "" {
                 // We don't appear to... but is it part of the filename?
                 matchingLen := 0
-                for k, _ := range decompressors {
+                for k := range c.Decompressors {
                         if strings.HasSuffix(u.Path, "."+k) && len(k) > matchingLen {
                                 archiveV = k
                                 matchingLen = len(k)
@@ -163,7 +153,7 @@ func (c *Client) Get() error {
         // real path.
         var decompressDst string
         var decompressDir bool
-        decompressor := decompressors[archiveV]
+        decompressor := c.Decompressors[archiveV]
         if decompressor != nil {
                 // Create a temporary directory to store our archive. We delete
                 // this at the end of everything.
@@ -182,44 +172,16 @@ func (c *Client) Get() error {
                 mode = ClientModeFile
         }
 
-        // Determine if we have a checksum
-        var checksumHash hash.Hash
-        var checksumValue []byte
-        if v := q.Get("checksum"); v != "" {
-                // Delete the query parameter if we have it.
-                q.Del("checksum")
-                u.RawQuery = q.Encode()
-
-                // Determine the checksum hash type
-                checksumType := ""
-                idx := strings.Index(v, ":")
-                if idx > -1 {
-                        checksumType = v[:idx]
-                }
-                switch checksumType {
-                case "md5":
-                        checksumHash = md5.New()
-                case "sha1":
-                        checksumHash = sha1.New()
-                case "sha256":
-                        checksumHash = sha256.New()
-                case "sha512":
-                        checksumHash = sha512.New()
-                default:
-                        return fmt.Errorf(
-                                "unsupported checksum type: %s", checksumType)
-                }
-
-                // Get the remainder of the value and parse it into bytes
-                b, err := hex.DecodeString(v[idx+1:])
-                if err != nil {
-                        return fmt.Errorf("invalid checksum: %s", err)
-                }
-
-                // Set our value
-                checksumValue = b
+        // Determine checksum if we have one
+        checksum, err := c.extractChecksum(u)
+        if err != nil {
+                return fmt.Errorf("invalid checksum: %s", err)
         }
 
+        // Delete the query parameter if we have it.
+        q.Del("checksum")
+        u.RawQuery = q.Encode()
+
         if mode == ClientModeAny {
                 // Ask the getter which client mode to use
                 mode, err = g.ClientMode(u)
@@ -248,15 +210,24 @@ func (c *Client) Get() error {
         // If we're not downloading a directory, then just download the file
         // and return.
         if mode == ClientModeFile {
-                err := g.GetFile(dst, u)
-                if err != nil {
-                        return err
+                getFile := true
+                if checksum != nil {
+                        if err := checksum.checksum(dst); err == nil {
+                                // don't get the file if the checksum of dst is correct
+                                getFile = false
+                        }
                 }
-
-                if checksumHash != nil {
-                        if err := checksum(dst, checksumHash, checksumValue); err != nil {
+                if getFile {
+                        err := g.GetFile(dst, u)
+                        if err != nil {
                                 return err
                         }
+
+                        if checksum != nil {
+                                if err := checksum.checksum(dst); err != nil {
+                                        return err
+                                }
+                        }
                 }
 
                 if decompressor != nil {
@@ -291,7 +262,7 @@ func (c *Client) Get() error {
         if decompressor == nil {
                 // If we're getting a directory, then this is an error. You cannot
                 // checksum a directory. TODO: test
-                if checksumHash != nil {
+                if checksum != nil {
                         return fmt.Errorf(
                                 "checksum cannot be specified for directory download")
                 }
@@ -320,30 +291,7 @@ func (c *Client) Get() error {
                         return err
                 }
 
-                return copyDir(realDst, subDir, false)
-        }
-
-        return nil
-}
-
-// checksum is a simple method to compute the checksum of a source file
-// and compare it to the given expected value.
-func checksum(source string, h hash.Hash, v []byte) error {
-        f, err := os.Open(source)
-        if err != nil {
-                return fmt.Errorf("Failed to open file for checksum: %s", err)
-        }
-        defer f.Close()
-
-        if _, err := io.Copy(h, f); err != nil {
-                return fmt.Errorf("Failed to hash: %s", err)
-        }
-
-        if actual := h.Sum(nil); !bytes.Equal(actual, v) {
-                return fmt.Errorf(
-                        "Checksums did not match.\nExpected: %s\nGot: %s",
-                        hex.EncodeToString(v),
-                        hex.EncodeToString(actual))
+                return copyDir(c.Ctx, realDst, subDir, false)
         }
 
         return nil
diff --git a/vendor/github.com/hashicorp/go-getter/client_option.go b/vendor/github.com/hashicorp/go-getter/client_option.go
new file mode 100644
index 0000000..c1ee413
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-getter/client_option.go
@@ -0,0 +1,46 @@
+package getter
+
+import "context"
+
+// A ClientOption allows to configure a client
+type ClientOption func(*Client) error
+
+// Configure configures a client with options.
+func (c *Client) Configure(opts ...ClientOption) error {
+        if c.Ctx == nil {
+                c.Ctx = context.Background()
+        }
+        c.Options = opts
+        for _, opt := range opts {
+                err := opt(c)
+                if err != nil {
+                        return err
+                }
+        }
+        // Default decompressor values
+        if c.Decompressors == nil {
+                c.Decompressors = Decompressors
+        }
+        // Default detector values
+        if c.Detectors == nil {
+                c.Detectors = Detectors
+        }
+        // Default getter values
+        if c.Getters == nil {
+                c.Getters = Getters
+        }
+
+        for _, getter := range c.Getters {
+                getter.SetClient(c)
+        }
+        return nil
+}
+
+// WithContext allows to pass a context to operation
+// in order to be able to cancel a download in progress.
+func WithContext(ctx context.Context) func(*Client) error {
+        return func(c *Client) error {
+                c.Ctx = ctx
+                return nil
+        }
+}
diff --git a/vendor/github.com/hashicorp/go-getter/client_option_progress.go b/vendor/github.com/hashicorp/go-getter/client_option_progress.go
new file mode 100644
index 0000000..9b185f7
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-getter/client_option_progress.go
@@ -0,0 +1,38 @@
+package getter
+
+import (
+        "io"
+)
+
+// WithProgress allows for a user to track
+// the progress of a download.
+// For example by displaying a progress bar with
+// current download.
+// Not all getters have progress support yet.
+func WithProgress(pl ProgressTracker) func(*Client) error {
+        return func(c *Client) error {
+                c.ProgressListener = pl
+                return nil
+        }
+}
+
+// ProgressTracker allows to track the progress of downloads.
+type ProgressTracker interface {
+        // TrackProgress should be called when
+        // a new object is being downloaded.
+        // src is the location the file is
+        // downloaded from.
+        // currentSize is the current size of
+        // the file in case it is a partial
+        // download.
+        // totalSize is the total size in bytes,
+        // size can be zero if the file size
+        // is not known.
+        // stream is the file being downloaded, every
+        // written byte will add up to processed size.
+        //
+        // TrackProgress returns a ReadCloser that wraps the
+        // download in progress ( stream ).
+        // When the download is finished, body shall be closed.
+        TrackProgress(src string, currentSize, totalSize int64, stream io.ReadCloser) (body io.ReadCloser)
+}
diff --git a/vendor/github.com/hashicorp/go-getter/common.go b/vendor/github.com/hashicorp/go-getter/common.go
new file mode 100644
index 0000000..d2afd8a
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-getter/common.go
@@ -0,0 +1,14 @@
+package getter
+
+import (
+        "io/ioutil"
+)
+
+func tmpFile(dir, pattern string) (string, error) {
+        f, err := ioutil.TempFile(dir, pattern)
+        if err != nil {
+                return "", err
+        }
+        f.Close()
+        return f.Name(), nil
+}
diff --git a/vendor/github.com/hashicorp/go-getter/copy_dir.go b/vendor/github.com/hashicorp/go-getter/copy_dir.go
index 2f58e8a..641fe6d 100644
--- a/vendor/github.com/hashicorp/go-getter/copy_dir.go
+++ b/vendor/github.com/hashicorp/go-getter/copy_dir.go
@@ -1,7 +1,7 @@
 package getter
 
 import (
-        "io"
+        "context"
         "os"
         "path/filepath"
         "strings"
@@ -11,7 +11,7 @@ import (
 // should already exist.
 //
 // If ignoreDot is set to true, then dot-prefixed files/folders are ignored.
-func copyDir(dst string, src string, ignoreDot bool) error {
+func copyDir(ctx context.Context, dst string, src string, ignoreDot bool) error {
         src, err := filepath.EvalSymlinks(src)
         if err != nil {
                 return err
@@ -66,7 +66,7 @@ func copyDir(dst string, src string, ignoreDot bool) error {
                 }
                 defer dstF.Close()
 
-                if _, err := io.Copy(dstF, srcF); err != nil {
+                if _, err := Copy(ctx, dstF, srcF); err != nil {
                         return err
                 }
 
diff --git a/vendor/github.com/hashicorp/go-getter/decompress_tar.go b/vendor/github.com/hashicorp/go-getter/decompress_tar.go
index 39cb392..b6986a2 100644
--- a/vendor/github.com/hashicorp/go-getter/decompress_tar.go
+++ b/vendor/github.com/hashicorp/go-getter/decompress_tar.go
@@ -6,6 +6,7 @@ import (
         "io"
         "os"
         "path/filepath"
+        "time"
 )
 
 // untar is a shared helper for untarring an archive. The reader should provide
@@ -14,6 +15,7 @@ func untar(input io.Reader, dst, src string, dir bool) error {
         tarR := tar.NewReader(input)
         done := false
         dirHdrs := []*tar.Header{}
+        now := time.Now()
         for {
                 hdr, err := tarR.Next()
                 if err == io.EOF {
@@ -95,17 +97,37 @@ func untar(input io.Reader, dst, src string, dir bool) error {
                         return err
                 }
 
-                // Set the access and modification time
-                if err := os.Chtimes(path, hdr.AccessTime, hdr.ModTime); err != nil {
+                // Set the access and modification time if valid, otherwise default to current time
+                aTime := now
+                mTime := now
+                if hdr.AccessTime.Unix() > 0 {
+                        aTime = hdr.AccessTime
+                }
+                if hdr.ModTime.Unix() > 0 {
+                        mTime = hdr.ModTime
+                }
+                if err := os.Chtimes(path, aTime, mTime); err != nil {
                         return err
                 }
         }
 
-        // Adding a file or subdirectory changes the mtime of a directory
-        // We therefore wait until we've extracted everything and then set the mtime and atime attributes
+        // Perform a final pass over extracted directories to update metadata
         for _, dirHdr := range dirHdrs {
                 path := filepath.Join(dst, dirHdr.Name)
-                if err := os.Chtimes(path, dirHdr.AccessTime, dirHdr.ModTime); err != nil {
+                // Chmod the directory since they might be created before we know the mode flags
+                if err := os.Chmod(path, dirHdr.FileInfo().Mode()); err != nil {
+                        return err
+                }
+                // Set the mtime/atime attributes since they would have been changed during extraction
+                aTime := now
+                mTime := now
+                if dirHdr.AccessTime.Unix() > 0 {
+                        aTime = dirHdr.AccessTime
+                }
+                if dirHdr.ModTime.Unix() > 0 {
+                        mTime = dirHdr.ModTime
+                }
+                if err := os.Chtimes(path, aTime, mTime); err != nil {
                         return err
                 }
         }
diff --git a/vendor/github.com/hashicorp/go-getter/decompress_testing.go b/vendor/github.com/hashicorp/go-getter/decompress_testing.go
index 91cf33d..b2f662a 100644
--- a/vendor/github.com/hashicorp/go-getter/decompress_testing.go
+++ b/vendor/github.com/hashicorp/go-getter/decompress_testing.go
@@ -18,16 +18,18 @@ import (
 
 // TestDecompressCase is a single test case for testing decompressors
 type TestDecompressCase struct {
-        Input   string   // Input is the complete path to the input file
-        Dir     bool     // Dir is whether or not we're testing directory mode
-        Err     bool     // Err is whether we expect an error or not
-        DirList []string // DirList is the list of files for Dir mode
-        FileMD5 string   // FileMD5 is the expected MD5 for a single file
-        Mtime *time.Time // Mtime is the optionally expected mtime for a single file (or all files if in Dir mode)
+        Input   string     // Input is the complete path to the input file
+        Dir     bool       // Dir is whether or not we're testing directory mode
+        Err     bool       // Err is whether we expect an error or not
+        DirList []string   // DirList is the list of files for Dir mode
+        FileMD5 string     // FileMD5 is the expected MD5 for a single file
+        Mtime   *time.Time // Mtime is the optionally expected mtime for a single file (or all files if in Dir mode)
 }
 
 // TestDecompressor is a helper function for testing generic decompressors.
 func TestDecompressor(t testing.T, d Decompressor, cases []TestDecompressCase) {
+        t.Helper()
+
         for _, tc := range cases {
                 t.Logf("Testing: %s", tc.Input)
 
@@ -72,9 +74,13 @@ func TestDecompressor(t testing.T, d Decompressor, cases []TestDecompressCase) {
 
                                 if tc.Mtime != nil {
                                         actual := fi.ModTime()
-                                        expected := *tc.Mtime
-                                        if actual != expected {
-                                                t.Fatalf("err %s: expected mtime '%s' for %s, got '%s'", tc.Input, expected.String(), dst, actual.String())
+                                        if tc.Mtime.Unix() > 0 {
+                                                expected := *tc.Mtime
+                                                if actual != expected {
+                                                        t.Fatalf("err %s: expected mtime '%s' for %s, got '%s'", tc.Input, expected.String(), dst, actual.String())
+                                                }
+                                        } else if actual.Unix() <= 0 {
+                                                t.Fatalf("err %s: expected mtime to be > 0, got '%s'", actual.String())
                                         }
                                 }
 
@@ -103,10 +109,15 @@ func TestDecompressor(t testing.T, d Decompressor, cases []TestDecompressCase) {
                                                 t.Fatalf("err: %s", err)
                                         }
                                         actual := fi.ModTime()
-                                        expected := *tc.Mtime
-                                        if actual != expected {
-                                                t.Fatalf("err %s: expected mtime '%s' for %s, got '%s'", tc.Input, expected.String(), path, actual.String())
+                                        if tc.Mtime.Unix() > 0 {
+                                                expected := *tc.Mtime
+                                                if actual != expected {
+                                                        t.Fatalf("err %s: expected mtime '%s' for %s, got '%s'", tc.Input, expected.String(), path, actual.String())
+                                                }
+                                        } else if actual.Unix() < 0 {
+                                                t.Fatalf("err %s: expected mtime to be > 0, got '%s'", actual.String())
                                         }
+
                                 }
                         }
                 }()
diff --git a/vendor/github.com/hashicorp/go-getter/decompress_zip.go b/vendor/github.com/hashicorp/go-getter/decompress_zip.go
index b0e70ca..0830f79 100644
--- a/vendor/github.com/hashicorp/go-getter/decompress_zip.go
+++ b/vendor/github.com/hashicorp/go-getter/decompress_zip.go
@@ -9,7 +9,7 @@ import (
 )
 
 // ZipDecompressor is an implementation of Decompressor that can
-// decompress tar.gzip files.
+// decompress zip files.
 type ZipDecompressor struct{}
 
 func (d *ZipDecompressor) Decompress(dst, src string, dir bool) error {
diff --git a/vendor/github.com/hashicorp/go-getter/detect.go b/vendor/github.com/hashicorp/go-getter/detect.go
index c369551..5bb750c 100644
--- a/vendor/github.com/hashicorp/go-getter/detect.go
+++ b/vendor/github.com/hashicorp/go-getter/detect.go
@@ -23,8 +23,10 @@ var Detectors []Detector
 func init() {
         Detectors = []Detector{
                 new(GitHubDetector),
+                new(GitDetector),
                 new(BitBucketDetector),
                 new(S3Detector),
+                new(GCSDetector),
                 new(FileDetector),
         }
 }
diff --git a/vendor/github.com/hashicorp/go-getter/detect_gcs.go b/vendor/github.com/hashicorp/go-getter/detect_gcs.go
new file mode 100644
index 0000000..1136373
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-getter/detect_gcs.go
@@ -0,0 +1,43 @@
+package getter
+
+import (
+        "fmt"
+        "net/url"
+        "strings"
+)
+
+// GCSDetector implements Detector to detect GCS URLs and turn
+// them into URLs that the GCSGetter can understand.
+type GCSDetector struct{}
+
+func (d *GCSDetector) Detect(src, _ string) (string, bool, error) {
+        if len(src) == 0 {
+                return "", false, nil
+        }
+
+        if strings.Contains(src, "googleapis.com/") {
+                return d.detectHTTP(src)
+        }
+
+        return "", false, nil
+}
+
+func (d *GCSDetector) detectHTTP(src string) (string, bool, error) {
+
+        parts := strings.Split(src, "/")
+        if len(parts) < 5 {
+                return "", false, fmt.Errorf(
+                        "URL is not a valid GCS URL")
+        }
+        version := parts[2]
+        bucket := parts[3]
+        object := strings.Join(parts[4:], "/")
+
+        url, err := url.Parse(fmt.Sprintf("https://www.googleapis.com/storage/%s/%s/%s",
+                version, bucket, object))
+        if err != nil {
+                return "", false, fmt.Errorf("error parsing GCS URL: %s", err)
+        }
+
+        return "gcs::" + url.String(), true, nil
+}
diff --git a/vendor/github.com/hashicorp/go-getter/detect_git.go b/vendor/github.com/hashicorp/go-getter/detect_git.go
new file mode 100644
index 0000000..eeb8a04
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-getter/detect_git.go
@@ -0,0 +1,26 @@
+package getter
+
+// GitDetector implements Detector to detect Git SSH URLs such as
+// git@host.com:dir1/dir2 and converts them to proper URLs.
+type GitDetector struct{}
+
+func (d *GitDetector) Detect(src, _ string) (string, bool, error) {
+        if len(src) == 0 {
+                return "", false, nil
+        }
+
+        u, err := detectSSH(src)
+        if err != nil {
+                return "", true, err
+        }
+        if u == nil {
+                return "", false, nil
+        }
+
+        // We require the username to be "git" to assume that this is a Git URL
+        if u.User.Username() != "git" {
+                return "", false, nil
+        }
+
+        return "git::" + u.String(), true, nil
+}
diff --git a/vendor/github.com/hashicorp/go-getter/detect_github.go b/vendor/github.com/hashicorp/go-getter/detect_github.go
index c084ad9..4bf4daf 100644
--- a/vendor/github.com/hashicorp/go-getter/detect_github.go
+++ b/vendor/github.com/hashicorp/go-getter/detect_github.go
@@ -17,8 +17,6 @@ func (d *GitHubDetector) Detect(src, _ string) (string, bool, error) {
 
         if strings.HasPrefix(src, "github.com/") {
                 return d.detectHTTP(src)
-        } else if strings.HasPrefix(src, "git@github.com:") {
-                return d.detectSSH(src)
         }
 
         return "", false, nil
@@ -47,27 +45,3 @@ func (d *GitHubDetector) detectHTTP(src string) (string, bool, error) {
 
         return "git::" + url.String(), true, nil
 }
-
-func (d *GitHubDetector) detectSSH(src string) (string, bool, error) {
-        idx := strings.Index(src, ":")
-        qidx := strings.Index(src, "?")
-        if qidx == -1 {
-                qidx = len(src)
-        }
-
-        var u url.URL
-        u.Scheme = "ssh"
-        u.User = url.User("git")
-        u.Host = "github.com"
-        u.Path = src[idx+1 : qidx]
-        if qidx < len(src) {
-                q, err := url.ParseQuery(src[qidx+1:])
-                if err != nil {
-                        return "", true, fmt.Errorf("error parsing GitHub SSH URL: %s", err)
-                }
-
-                u.RawQuery = q.Encode()
-        }
-
-        return "git::" + u.String(), true, nil
-}
diff --git a/vendor/github.com/hashicorp/go-getter/detect_ssh.go b/vendor/github.com/hashicorp/go-getter/detect_ssh.go
new file mode 100644
index 0000000..c0dbe9d
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-getter/detect_ssh.go
@@ -0,0 +1,49 @@
+package getter
+
+import (
+        "fmt"
+        "net/url"
+        "regexp"
+        "strings"
+)
+
+// Note that we do not have an SSH-getter currently so this file serves
+// only to hold the detectSSH helper that is used by other detectors.
+
+// sshPattern matches SCP-like SSH patterns (user@host:path)
+var sshPattern = regexp.MustCompile("^(?:([^@]+)@)?([^:]+):/?(.+)$")
+
+// detectSSH determines if the src string matches an SSH-like URL and
+// converts it into a net.URL compatible string. This returns nil if the
+// string doesn't match the SSH pattern.
+//
+// This function is tested indirectly via detect_git_test.go
+func detectSSH(src string) (*url.URL, error) {
+        matched := sshPattern.FindStringSubmatch(src)
+        if matched == nil {
+                return nil, nil
+        }
+
+        user := matched[1]
+        host := matched[2]
+        path := matched[3]
+        qidx := strings.Index(path, "?")
+        if qidx == -1 {
+                qidx = len(path)
+        }
+
+        var u url.URL
+        u.Scheme = "ssh"
+        u.User = url.User(user)
+        u.Host = host
+        u.Path = path[0:qidx]
+        if qidx < len(path) {
+                q, err := url.ParseQuery(path[qidx+1:])
+                if err != nil {
+                        return nil, fmt.Errorf("error parsing GitHub SSH URL: %s", err)
+                }
+                u.RawQuery = q.Encode()
+        }
+
+        return &u, nil
+}
diff --git a/vendor/github.com/hashicorp/go-getter/get.go b/vendor/github.com/hashicorp/go-getter/get.go
index e6053d9..c233763 100644
--- a/vendor/github.com/hashicorp/go-getter/get.go
+++ b/vendor/github.com/hashicorp/go-getter/get.go
@@ -41,6 +41,11 @@ type Getter interface {
         // ClientMode returns the mode based on the given URL. This is used to
         // allow clients to let the getters decide which mode to use.
         ClientMode(*url.URL) (ClientMode, error)
+
+        // SetClient allows a getter to know it's client
+        // in order to access client's Get functions or
+        // progress tracking.
+        SetClient(*Client)
 }
 
 // Getters is the mapping of scheme to the Getter implementation that will
@@ -62,6 +67,7 @@ func init() {
         Getters = map[string]Getter{
                 "file":  new(FileGetter),
                 "git":   new(GitGetter),
+                "gcs":   new(GCSGetter),
                 "hg":    new(HgGetter),
                 "s3":    new(S3Getter),
                 "http":  httpGetter,
@@ -74,12 +80,12 @@ func init() {
 //
 // src is a URL, whereas dst is always just a file path to a folder. This
 // folder doesn't need to exist. It will be created if it doesn't exist.
-func Get(dst, src string) error {
+func Get(dst, src string, opts ...ClientOption) error {
         return (&Client{
                 Src:     src,
                 Dst:     dst,
                 Dir:     true,
-                Getters: Getters,
+                Options: opts,
         }).Get()
 }
 
@@ -89,23 +95,23 @@ func Get(dst, src string) error {
 // dst must be a directory. If src is a file, it will be downloaded
 // into dst with the basename of the URL. If src is a directory or
 // archive, it will be unpacked directly into dst.
-func GetAny(dst, src string) error {
+func GetAny(dst, src string, opts ...ClientOption) error {
         return (&Client{
                 Src:     src,
                 Dst:     dst,
                 Mode:    ClientModeAny,
-                Getters: Getters,
+                Options: opts,
         }).Get()
 }
 
 // GetFile downloads the file specified by src into the path specified by
 // dst.
-func GetFile(dst, src string) error {
+func GetFile(dst, src string, opts ...ClientOption) error {
         return (&Client{
                 Src:     src,
                 Dst:     dst,
                 Dir:     false,
-                Getters: Getters,
+                Options: opts,
         }).Get()
 }
 
diff --git a/vendor/github.com/hashicorp/go-getter/get_base.go b/vendor/github.com/hashicorp/go-getter/get_base.go
new file mode 100644
index 0000000..09e9b63
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-getter/get_base.go
@@ -0,0 +1,20 @@
+package getter
+
+import "context"
+
+// getter is our base getter; it regroups
+// fields all getters have in common.
+type getter struct {
+        client *Client
+}
+
+func (g *getter) SetClient(c *Client) { g.client = c }
+
+// Context tries to returns the Contex from the getter's
+// client. otherwise context.Background() is returned.
+func (g *getter) Context() context.Context {
+        if g == nil || g.client == nil {
+                return context.Background()
+        }
+        return g.client.Ctx
+}
diff --git a/vendor/github.com/hashicorp/go-getter/get_file.go b/vendor/github.com/hashicorp/go-getter/get_file.go
index e5d2d61..7866083 100644
--- a/vendor/github.com/hashicorp/go-getter/get_file.go
+++ b/vendor/github.com/hashicorp/go-getter/get_file.go
@@ -8,7 +8,11 @@ import (
 // FileGetter is a Getter implementation that will download a module from
 // a file scheme.
 type FileGetter struct {
-        // Copy, if set to true, will copy data instead of using a symlink
+        getter
+
+        // Copy, if set to true, will copy data instead of using a symlink. If
+        // false, attempts to symlink to speed up the operation and to lower the
+        // disk space usage. If the symlink fails, may attempt to copy on windows.
         Copy bool
 }
 
diff --git a/vendor/github.com/hashicorp/go-getter/get_file_copy.go b/vendor/github.com/hashicorp/go-getter/get_file_copy.go
new file mode 100644
index 0000000..d70fb49
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-getter/get_file_copy.go
@@ -0,0 +1,29 @@
+package getter
+
+import (
+        "context"
+        "io"
+)
+
+// readerFunc is syntactic sugar for read interface.
+type readerFunc func(p []byte) (n int, err error)
+
+func (rf readerFunc) Read(p []byte) (n int, err error) { return rf(p) }
+
+// Copy is a io.Copy cancellable by context
+func Copy(ctx context.Context, dst io.Writer, src io.Reader) (int64, error) {
+        // Copy will call the Reader and Writer interface multiple time, in order
+        // to copy by chunk (avoiding loading the whole file in memory).
+        return io.Copy(dst, readerFunc(func(p []byte) (int, error) {
+
+                select {
+                case <-ctx.Done():
+                        // context has been canceled
+                        // stop process and propagate "context canceled" error
+                        return 0, ctx.Err()
+                default:
+                        // otherwise just run default io.Reader implementation
+                        return src.Read(p)
+                }
+        }))
+}
diff --git a/vendor/github.com/hashicorp/go-getter/get_file_unix.go b/vendor/github.com/hashicorp/go-getter/get_file_unix.go
index c89a2d5..c3b28ae 100644
--- a/vendor/github.com/hashicorp/go-getter/get_file_unix.go
+++ b/vendor/github.com/hashicorp/go-getter/get_file_unix.go
@@ -4,7 +4,6 @@ package getter
 
 import (
         "fmt"
-        "io"
         "net/url"
         "os"
         "path/filepath"
@@ -50,6 +49,7 @@ func (g *FileGetter) Get(dst string, u *url.URL) error {
 }
 
 func (g *FileGetter) GetFile(dst string, u *url.URL) error {
+        ctx := g.Context()
         path := u.Path
         if u.RawPath != "" {
                 path = u.RawPath
@@ -98,6 +98,6 @@ func (g *FileGetter) GetFile(dst string, u *url.URL) error {
         }
         defer dstF.Close()
 
-        _, err = io.Copy(dstF, srcF)
+        _, err = Copy(ctx, dstF, srcF)
         return err
 }
diff --git a/vendor/github.com/hashicorp/go-getter/get_file_windows.go b/vendor/github.com/hashicorp/go-getter/get_file_windows.go
index f87ed0a..24f1acb 100644
--- a/vendor/github.com/hashicorp/go-getter/get_file_windows.go
+++ b/vendor/github.com/hashicorp/go-getter/get_file_windows.go
@@ -4,15 +4,16 @@ package getter
 
 import (
         "fmt"
-        "io"
         "net/url"
         "os"
         "os/exec"
         "path/filepath"
         "strings"
+        "syscall"
 )
 
 func (g *FileGetter) Get(dst string, u *url.URL) error {
+        ctx := g.Context()
         path := u.Path
         if u.RawPath != "" {
                 path = u.RawPath
@@ -51,7 +52,7 @@ func (g *FileGetter) Get(dst string, u *url.URL) error {
         sourcePath := toBackslash(path)
 
         // Use mklink to create a junction point
-        output, err := exec.Command("cmd", "/c", "mklink", "/J", dst, sourcePath).CombinedOutput()
+        output, err := exec.CommandContext(ctx, "cmd", "/c", "mklink", "/J", dst, sourcePath).CombinedOutput()
         if err != nil {
                 return fmt.Errorf("failed to run mklink %v %v: %v %q", dst, sourcePath, err, output)
         }
@@ -60,6 +61,7 @@ func (g *FileGetter) Get(dst string, u *url.URL) error {
 }
 
 func (g *FileGetter) GetFile(dst string, u *url.URL) error {
+        ctx := g.Context()
         path := u.Path
         if u.RawPath != "" {
                 path = u.RawPath
@@ -92,7 +94,21 @@ func (g *FileGetter) GetFile(dst string, u *url.URL) error {
 
         // If we're not copying, just symlink and we're done
         if !g.Copy {
-                return os.Symlink(path, dst)
+                if err = os.Symlink(path, dst); err == nil {
+                        return err
+                }
+                lerr, ok := err.(*os.LinkError)
+                if !ok {
+                        return err
+                }
+                switch lerr.Err {
+                case syscall.ERROR_PRIVILEGE_NOT_HELD:
+                        // no symlink privilege, let's
+                        // fallback to a copy to avoid an error.
+                        break
+                default:
+                        return err
+                }
         }
 
         // Copy
@@ -108,7 +124,7 @@ func (g *FileGetter) GetFile(dst string, u *url.URL) error {
         }
         defer dstF.Close()
 
-        _, err = io.Copy(dstF, srcF)
+        _, err = Copy(ctx, dstF, srcF)
         return err
 }
 
diff --git a/vendor/github.com/hashicorp/go-getter/get_gcs.go b/vendor/github.com/hashicorp/go-getter/get_gcs.go
new file mode 100644
index 0000000..6faa70f
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-getter/get_gcs.go
@@ -0,0 +1,172 @@
+package getter
+
+import (
+        "context"
+        "fmt"
+        "net/url"
+        "os"
+        "path/filepath"
+        "strings"
+
+        "cloud.google.com/go/storage"
+        "google.golang.org/api/iterator"
+)
+
+// GCSGetter is a Getter implementation that will download a module from
+// a GCS bucket.
+type GCSGetter struct {
+        getter
+}
+
+func (g *GCSGetter) ClientMode(u *url.URL) (ClientMode, error) {
+        ctx := g.Context()
+
+        // Parse URL
+        bucket, object, err := g.parseURL(u)
+        if err != nil {
+                return 0, err
+        }
+
+        client, err := storage.NewClient(ctx)
+        if err != nil {
+                return 0, err
+        }
+        iter := client.Bucket(bucket).Objects(ctx, &storage.Query{Prefix: object})
+        for {
+                obj, err := iter.Next()
+                if err != nil && err != iterator.Done {
+                        return 0, err
+                }
+
+                if err == iterator.Done {
+                        break
+                }
+                if strings.HasSuffix(obj.Name, "/") {
+                        // A directory matched the prefix search, so this must be a directory
+                        return ClientModeDir, nil
+                } else if obj.Name != object {
+                        // A file matched the prefix search and doesn't have the same name
+                        // as the query, so this must be a directory
+                        return ClientModeDir, nil
+                }
+        }
+        // There are no directories or subdirectories, and if a match was returned,
+        // it was exactly equal to the prefix search. So return File mode
+        return ClientModeFile, nil
+}
+
+func (g *GCSGetter) Get(dst string, u *url.URL) error {
+        ctx := g.Context()
+
+        // Parse URL
+        bucket, object, err := g.parseURL(u)
+        if err != nil {
+                return err
+        }
+
+        // Remove destination if it already exists
+        _, err = os.Stat(dst)
+        if err != nil && !os.IsNotExist(err) {
+                return err
+        }
+        if err == nil {
+                // Remove the destination
+                if err := os.RemoveAll(dst); err != nil {
+                        return err
+                }
+        }
+
+        // Create all the parent directories
+        if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil {
+                return err
+        }
+
+        client, err := storage.NewClient(ctx)
+        if err != nil {
+                return err
+        }
+
+        // Iterate through all matching objects.
+        iter := client.Bucket(bucket).Objects(ctx, &storage.Query{Prefix: object})
+        for {
+                obj, err := iter.Next()
+                if err != nil && err != iterator.Done {
+                        return err
+                }
+                if err == iterator.Done {
+                        break
+                }
+
+                if !strings.HasSuffix(obj.Name, "/") {
+                        // Get the object destination path
+                        objDst, err := filepath.Rel(object, obj.Name)
+                        if err != nil {
+                                return err
+                        }
+                        objDst = filepath.Join(dst, objDst)
+                        // Download the matching object.
+                        err = g.getObject(ctx, client, objDst, bucket, obj.Name)
+                        if err != nil {
+                                return err
+                        }
+                }
+        }
+        return nil
+}
+
+func (g *GCSGetter) GetFile(dst string, u *url.URL) error {
+        ctx := g.Context()
+
+        // Parse URL
+        bucket, object, err := g.parseURL(u)
+        if err != nil {
+                return err
+        }
+
+        client, err := storage.NewClient(ctx)
+        if err != nil {
+                return err
+        }
+        return g.getObject(ctx, client, dst, bucket, object)
+}
+
+func (g *GCSGetter) getObject(ctx context.Context, client *storage.Client, dst, bucket, object string) error {
+        rc, err := client.Bucket(bucket).Object(object).NewReader(ctx)
+        if err != nil {
+                return err
+        }
+        defer rc.Close()
+
+        // Create all the parent directories
+        if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil {
+                return err
+        }
+
+        f, err := os.Create(dst)
+        if err != nil {
+                return err
+        }
+        defer f.Close()
+
+        _, err = Copy(ctx, f, rc)
+        return err
+}
+
+func (g *GCSGetter) parseURL(u *url.URL) (bucket, path string, err error) {
+        if strings.Contains(u.Host, "googleapis.com") {
+                hostParts := strings.Split(u.Host, ".")
+                if len(hostParts) != 3 {
+                        err = fmt.Errorf("URL is not a valid GCS URL")
+                        return
+                }
+
+                pathParts := strings.SplitN(u.Path, "/", 5)
+                if len(pathParts) != 5 {
+                        err = fmt.Errorf("URL is not a valid GCS URL")
+                        return
+                }
+                bucket = pathParts[3]
+                path = pathParts[4]
+        }
+        return
+}
diff --git a/vendor/github.com/hashicorp/go-getter/get_git.go b/vendor/github.com/hashicorp/go-getter/get_git.go
index cb1d029..67e8b2f 100644
--- a/vendor/github.com/hashicorp/go-getter/get_git.go
+++ b/vendor/github.com/hashicorp/go-getter/get_git.go
@@ -1,6 +1,7 @@
 package getter
 
 import (
+        "context"
         "encoding/base64"
         "fmt"
         "io/ioutil"
@@ -8,28 +9,43 @@ import (
         "os"
         "os/exec"
         "path/filepath"
+        "runtime"
+        "strconv"
         "strings"
 
         urlhelper "github.com/hashicorp/go-getter/helper/url"
-        "github.com/hashicorp/go-safetemp"
-        "github.com/hashicorp/go-version"
+        safetemp "github.com/hashicorp/go-safetemp"
+        version "github.com/hashicorp/go-version"
 )
 
 // GitGetter is a Getter implementation that will download a module from
 // a git repository.
-type GitGetter struct{}
+type GitGetter struct {
+        getter
+}
 
 func (g *GitGetter) ClientMode(_ *url.URL) (ClientMode, error) {
         return ClientModeDir, nil
 }
 
 func (g *GitGetter) Get(dst string, u *url.URL) error {
+        ctx := g.Context()
         if _, err := exec.LookPath("git"); err != nil {
                 return fmt.Errorf("git must be available and on the PATH")
         }
 
+        // The port number must be parseable as an integer. If not, the user
+        // was probably trying to use a scp-style address, in which case the
+        // ssh:// prefix must be removed to indicate that.
+        if portStr := u.Port(); portStr != "" {
+                if _, err := strconv.ParseUint(portStr, 10, 16); err != nil {
+                        return fmt.Errorf("invalid port number %q; if using the \"scp-like\" git address scheme where a colon introduces the path instead, remove the ssh:// portion and use just the git:: prefix", portStr)
+                }
+        }
+
         // Extract some query parameters we use
         var ref, sshKey string
+        var depth int
         q := u.Query()
         if len(q) > 0 {
                 ref = q.Get("ref")
@@ -38,6 +54,11 @@ func (g *GitGetter) Get(dst string, u *url.URL) error {
                 sshKey = q.Get("sshkey")
                 q.Del("sshkey")
 
+                if n, err := strconv.Atoi(q.Get("depth")); err == nil {
+                        depth = n
+                }
+                q.Del("depth")
+
                 // Copy the URL
                 var newU url.URL = *u
                 u = &newU
@@ -84,9 +105,9 @@ func (g *GitGetter) Get(dst string, u *url.URL) error {
                 return err
         }
         if err == nil {
-                err = g.update(dst, sshKeyFile, ref)
+                err = g.update(ctx, dst, sshKeyFile, ref, depth)
         } else {
-                err = g.clone(dst, sshKeyFile, u)
+                err = g.clone(ctx, dst, sshKeyFile, u, depth)
         }
         if err != nil {
                 return err
@@ -100,7 +121,7 @@ func (g *GitGetter) Get(dst string, u *url.URL) error {
         }
 
         // Lastly, download any/all submodules.
-        return g.fetchSubmodules(dst, sshKeyFile)
+        return g.fetchSubmodules(ctx, dst, sshKeyFile, depth)
 }
 
 // GetFile for Git doesn't support updating at this time. It will download
@@ -138,16 +159,23 @@ func (g *GitGetter) checkout(dst string, ref string) error {
         return getRunCommand(cmd)
 }
 
-func (g *GitGetter) clone(dst, sshKeyFile string, u *url.URL) error {
-        cmd := exec.Command("git", "clone", u.String(), dst)
+func (g *GitGetter) clone(ctx context.Context, dst, sshKeyFile string, u *url.URL, depth int) error {
+        args := []string{"clone"}
+
+        if depth > 0 {
+                args = append(args, "--depth", strconv.Itoa(depth))
+        }
+
+        args = append(args, u.String(), dst)
+        cmd := exec.CommandContext(ctx, "git", args...)
         setupGitEnv(cmd, sshKeyFile)
         return getRunCommand(cmd)
 }
 
-func (g *GitGetter) update(dst, sshKeyFile, ref string) error {
+func (g *GitGetter) update(ctx context.Context, dst, sshKeyFile, ref string, depth int) error {
         // Determine if we're a branch. If we're NOT a branch, then we just
         // switch to master prior to checking out
-        cmd := exec.Command("git", "show-ref", "-q", "--verify", "refs/heads/"+ref)
+        cmd := exec.CommandContext(ctx, "git", "show-ref", "-q", "--verify", "refs/heads/"+ref)
         cmd.Dir = dst
 
         if getRunCommand(cmd) != nil {
@@ -162,15 +190,24 @@ func (g *GitGetter) update(dst, sshKeyFile, ref string) error {
                 return err
         }
 
-        cmd = exec.Command("git", "pull", "--ff-only")
+        if depth > 0 {
+                cmd = exec.Command("git", "pull", "--depth", strconv.Itoa(depth), "--ff-only")
+        } else {
+                cmd = exec.Command("git", "pull", "--ff-only")
+        }
+
         cmd.Dir = dst
         setupGitEnv(cmd, sshKeyFile)
         return getRunCommand(cmd)
 }
 
 // fetchSubmodules downloads any configured submodules recursively.
-func (g *GitGetter) fetchSubmodules(dst, sshKeyFile string) error {
-        cmd := exec.Command("git", "submodule", "update", "--init", "--recursive")
+func (g *GitGetter) fetchSubmodules(ctx context.Context, dst, sshKeyFile string, depth int) error {
+        args := []string{"submodule", "update", "--init", "--recursive"}
+        if depth > 0 {
+                args = append(args, "--depth", strconv.Itoa(depth))
+        }
+        cmd := exec.CommandContext(ctx, "git", args...)
         cmd.Dir = dst
         setupGitEnv(cmd, sshKeyFile)
         return getRunCommand(cmd)
@@ -187,7 +224,7 @@ func setupGitEnv(cmd *exec.Cmd, sshKeyFile string) {
         // with versions of Go < 1.9.
         env := os.Environ()
         for i, v := range env {
-                if strings.HasPrefix(v, gitSSHCommand) {
+                if strings.HasPrefix(v, gitSSHCommand) && len(v) > len(gitSSHCommand) {
                         sshCmd = []string{v}
 
                         env[i], env[len(env)-1] = env[len(env)-1], env[i]
@@ -202,6 +239,9 @@ func setupGitEnv(cmd *exec.Cmd, sshKeyFile string) {
 
         if sshKeyFile != "" {
                 // We have an SSH key temp file configured, tell ssh about this.
+                if runtime.GOOS == "windows" {
+                        sshKeyFile = strings.Replace(sshKeyFile, `\`, `/`, -1)
+                }
                 sshCmd = append(sshCmd, "-i", sshKeyFile)
         }
 
@@ -224,11 +264,20 @@ func checkGitVersion(min string) error {
         }
 
         fields := strings.Fields(string(out))
-        if len(fields) != 3 {
+        if len(fields) < 3 {
                 return fmt.Errorf("Unexpected 'git version' output: %q", string(out))
         }
+        v := fields[2]
+        if runtime.GOOS == "windows" && strings.Contains(v, ".windows.") {
+                // on windows, git version will return for example:
+                // git version 2.20.1.windows.1
+                // Which does not follow the semantic versionning specs
+                // https://semver.org. We remove that part in order for
+                // go-version to not error.
+                v = v[:strings.Index(v, ".windows.")]
+        }
 
-        have, err := version.NewVersion(fields[2])
+        have, err := version.NewVersion(v)
         if err != nil {
                 return err
         }
diff --git a/vendor/github.com/hashicorp/go-getter/get_hg.go b/vendor/github.com/hashicorp/go-getter/get_hg.go
index f386922..290649c 100644
--- a/vendor/github.com/hashicorp/go-getter/get_hg.go
+++ b/vendor/github.com/hashicorp/go-getter/get_hg.go
@@ -1,6 +1,7 @@
 package getter
 
 import (
+        "context"
         "fmt"
         "net/url"
         "os"
@@ -9,18 +10,21 @@ import (
         "runtime"
 
         urlhelper "github.com/hashicorp/go-getter/helper/url"
-        "github.com/hashicorp/go-safetemp"
+        safetemp "github.com/hashicorp/go-safetemp"
 )
 
 // HgGetter is a Getter implementation that will download a module from
 // a Mercurial repository.
-type HgGetter struct{}
+type HgGetter struct {
+        getter
+}
 
 func (g *HgGetter) ClientMode(_ *url.URL) (ClientMode, error) {
         return ClientModeDir, nil
 }
 
 func (g *HgGetter) Get(dst string, u *url.URL) error {
+        ctx := g.Context()
         if _, err := exec.LookPath("hg"); err != nil {
                 return fmt.Errorf("hg must be available and on the PATH")
         }
@@ -58,7 +62,7 @@ func (g *HgGetter) Get(dst string, u *url.URL) error {
                 return err
         }
 
-        return g.update(dst, newURL, rev)
+        return g.update(ctx, dst, newURL, rev)
 }
 
 // GetFile for Hg doesn't support updating at this time. It will download
@@ -93,7 +97,7 @@ func (g *HgGetter) GetFile(dst string, u *url.URL) error {
                 return err
         }
 
-        fg := &FileGetter{Copy: true}
+        fg := &FileGetter{Copy: true, getter: g.getter}
         return fg.GetFile(dst, u)
 }
 
@@ -108,13 +112,13 @@ func (g *HgGetter) pull(dst string, u *url.URL) error {
         return getRunCommand(cmd)
 }
 
-func (g *HgGetter) update(dst string, u *url.URL, rev string) error {
+func (g *HgGetter) update(ctx context.Context, dst string, u *url.URL, rev string) error {
         args := []string{"update"}
         if rev != "" {
                 args = append(args, rev)
         }
 
-        cmd := exec.Command("hg", args...)
+        cmd := exec.CommandContext(ctx, "hg", args...)
         cmd.Dir = dst
         return getRunCommand(cmd)
 }
diff --git a/vendor/github.com/hashicorp/go-getter/get_http.go b/vendor/github.com/hashicorp/go-getter/get_http.go
index d2e2879..7c4541c 100644
--- a/vendor/github.com/hashicorp/go-getter/get_http.go
+++ b/vendor/github.com/hashicorp/go-getter/get_http.go
@@ -1,6 +1,7 @@
 package getter
 
 import (
+        "context"
         "encoding/xml"
         "fmt"
         "io"
@@ -8,9 +9,10 @@ import (
         "net/url"
         "os"
         "path/filepath"
+        "strconv"
         "strings"
 
-        "github.com/hashicorp/go-safetemp"
+        safetemp "github.com/hashicorp/go-safetemp"
 )
 
 // HttpGetter is a Getter implementation that will download from an HTTP
@@ -18,7 +20,7 @@ import (
 //
 // For file downloads, HTTP is used directly.
 //
-// The protocol for downloading a directory from an HTTP endpoing is as follows:
+// The protocol for downloading a directory from an HTTP endpoint is as follows:
 //
 // An HTTP GET request is made to the URL with the additional GET parameter
 // "terraform-get=1". This lets you handle that scenario specially if you
@@ -34,6 +36,8 @@ import (
 // formed URL. The shorthand syntax of "github.com/foo/bar" or relative
 // paths are not allowed.
 type HttpGetter struct {
+        getter
+
         // Netrc, if true, will lookup and use auth information found
         // in the user's netrc file if available.
         Netrc bool
@@ -41,6 +45,12 @@ type HttpGetter struct {
         // Client is the http.Client to use for Get requests.
         // This defaults to a cleanhttp.DefaultClient if left unset.
         Client *http.Client
+
+        // Header contains optional request header fields that should be included
+        // with every HTTP request. Note that the zero value of this field is nil,
+        // and as such it needs to be initialized before use, via something like
+        // make(http.Header).
+        Header http.Header
 }
 
 func (g *HttpGetter) ClientMode(u *url.URL) (ClientMode, error) {
@@ -51,6 +61,7 @@ func (g *HttpGetter) ClientMode(u *url.URL) (ClientMode, error) {
 }
 
 func (g *HttpGetter) Get(dst string, u *url.URL) error {
+        ctx := g.Context()
         // Copy the URL so we can modify it
         var newU url.URL = *u
         u = &newU
@@ -72,10 +83,17 @@ func (g *HttpGetter) Get(dst string, u *url.URL) error {
         u.RawQuery = q.Encode()
 
         // Get the URL
-        resp, err := g.Client.Get(u.String())
+        req, err := http.NewRequest("GET", u.String(), nil)
         if err != nil {
                 return err
         }
+
+        req.Header = g.Header
+        resp, err := g.Client.Do(req)
+        if err != nil {
+                return err
+        }
+
         defer resp.Body.Close()
         if resp.StatusCode < 200 || resp.StatusCode >= 300 {
                 return fmt.Errorf("bad response code: %d", resp.StatusCode)
@@ -99,57 +117,107 @@ func (g *HttpGetter) Get(dst string, u *url.URL) error {
         // into a temporary directory, then copy over the proper subdir.
         source, subDir := SourceDirSubdir(source)
         if subDir == "" {
-                return Get(dst, source)
+                var opts []ClientOption
+                if g.client != nil {
+                        opts = g.client.Options
+                }
+                return Get(dst, source, opts...)
         }
 
         // We have a subdir, time to jump some hoops
-        return g.getSubdir(dst, source, subDir)
+        return g.getSubdir(ctx, dst, source, subDir)
 }
 
-func (g *HttpGetter) GetFile(dst string, u *url.URL) error {
+func (g *HttpGetter) GetFile(dst string, src *url.URL) error {
+        ctx := g.Context()
         if g.Netrc {
                 // Add auth from netrc if we can
-                if err := addAuthFromNetrc(u); err != nil {
+                if err := addAuthFromNetrc(src); err != nil {
                         return err
                 }
         }
 
-        if g.Client == nil {
-                g.Client = httpClient
+        // Create all the parent directories if needed
+        if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil {
+                return err
         }
 
-        resp, err := g.Client.Get(u.String())
+        f, err := os.OpenFile(dst, os.O_RDWR|os.O_CREATE, os.FileMode(0666))
         if err != nil {
                 return err
         }
-        defer resp.Body.Close()
-        if resp.StatusCode != 200 {
-                return fmt.Errorf("bad response code: %d", resp.StatusCode)
+        defer f.Close()
+
+        if g.Client == nil {
+                g.Client = httpClient
         }
 
-        // Create all the parent directories
-        if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil {
+        var currentFileSize int64
+
+        // We first make a HEAD request so we can check
+        // if the server supports range queries. If the server/URL doesn't
+        // support HEAD requests, we just fall back to GET.
+        req, err := http.NewRequest("HEAD", src.String(), nil)
+        if err != nil {
                 return err
         }
+        if g.Header != nil {
+                req.Header = g.Header
+        }
+        headResp, err := g.Client.Do(req)
+        if err == nil && headResp != nil {
+                headResp.Body.Close()
+                if headResp.StatusCode == 200 {
+                        // If the HEAD request succeeded, then attempt to set the range
+                        // query if we can.
+                        if headResp.Header.Get("Accept-Ranges") == "bytes" {
+                                if fi, err := f.Stat(); err == nil {
+                                        if _, err = f.Seek(0, os.SEEK_END); err == nil {
+                                                req.Header.Set("Range", fmt.Sprintf("bytes=%d-", fi.Size()))
+                                                currentFileSize = fi.Size()
+                                                totalFileSize, _ := strconv.ParseInt(headResp.Header.Get("Content-Length"), 10, 64)
+                                                if currentFileSize >= totalFileSize {
+                                                        // file already present
+                                                        return nil
+                                                }
+                                        }
+                                }
+                        }
+                }
+        }
+        req.Method = "GET"
 
-        f, err := os.Create(dst)
+        resp, err := g.Client.Do(req)
         if err != nil {
                 return err
         }
+        switch resp.StatusCode {
+        case http.StatusOK, http.StatusPartialContent:
+                // all good
+        default:
+                resp.Body.Close()
+                return fmt.Errorf("bad response code: %d", resp.StatusCode)
+        }
+
+        body := resp.Body
 
-        n, err := io.Copy(f, resp.Body)
+        if g.client != nil && g.client.ProgressListener != nil {
+                // track download
+                fn := filepath.Base(src.EscapedPath())
+                body = g.client.ProgressListener.TrackProgress(fn, currentFileSize, currentFileSize+resp.ContentLength, resp.Body)
+        }
+        defer body.Close()
+
+        n, err := Copy(ctx, f, body)
         if err == nil && n < resp.ContentLength {
                 err = io.ErrShortWrite
         }
-        if err1 := f.Close(); err == nil {
-                err = err1
-        }
         return err
 }
 
 // getSubdir downloads the source into the destination, but with
 // the proper subdir.
-func (g *HttpGetter) getSubdir(dst, source, subDir string) error {
+func (g *HttpGetter) getSubdir(ctx context.Context, dst, source, subDir string) error {
         // Create a temporary directory to store the full source. This has to be
         // a non-existent directory.
         td, tdcloser, err := safetemp.Dir("", "getter")
@@ -158,8 +226,12 @@ func (g *HttpGetter) getSubdir(dst, source, subDir string) error {
         }
         defer tdcloser.Close()
 
+        var opts []ClientOption
+        if g.client != nil {
+                opts = g.client.Options
+        }
         // Download that into the given directory
-        if err := Get(td, source); err != nil {
+        if err := Get(td, source, opts...); err != nil {
                 return err
         }
 
@@ -185,7 +257,7 @@ func (g *HttpGetter) getSubdir(dst, source, subDir string) error {
                 return err
         }
 
-        return copyDir(dst, sourcePath, false)
+        return copyDir(ctx, dst, sourcePath, false)
 }
 
 // parseMeta looks for the first meta tag in the given reader that
diff --git a/vendor/github.com/hashicorp/go-getter/get_mock.go b/vendor/github.com/hashicorp/go-getter/get_mock.go
index 882e694..e2a98ea 100644
--- a/vendor/github.com/hashicorp/go-getter/get_mock.go
+++ b/vendor/github.com/hashicorp/go-getter/get_mock.go
@@ -6,6 +6,8 @@ import (
 
 // MockGetter is an implementation of Getter that can be used for tests.
 type MockGetter struct {
+        getter
+
         // Proxy, if set, will be called after recording the calls below.
         // If it isn't set, then the *Err values will be returned.
         Proxy Getter
diff --git a/vendor/github.com/hashicorp/go-getter/get_s3.go b/vendor/github.com/hashicorp/go-getter/get_s3.go
index ebb3217..93eeb0b 100644
--- a/vendor/github.com/hashicorp/go-getter/get_s3.go
+++ b/vendor/github.com/hashicorp/go-getter/get_s3.go
@@ -1,8 +1,8 @@
 package getter
 
 import (
+        "context"
         "fmt"
-        "io"
         "net/url"
         "os"
         "path/filepath"
@@ -18,7 +18,9 @@ import (
 
 // S3Getter is a Getter implementation that will download a module from
 // a S3 bucket.
-type S3Getter struct{}
+type S3Getter struct {
+        getter
+}
 
 func (g *S3Getter) ClientMode(u *url.URL) (ClientMode, error) {
         // Parse URL
@@ -60,6 +62,8 @@ func (g *S3Getter) ClientMode(u *url.URL) (ClientMode, error) {
 }
 
 func (g *S3Getter) Get(dst string, u *url.URL) error {
+        ctx := g.Context()
+
         // Parse URL
         region, bucket, path, _, creds, err := g.parseUrl(u)
         if err != nil {
@@ -124,7 +128,7 @@ func (g *S3Getter) Get(dst string, u *url.URL) error {
                         }
                         objDst = filepath.Join(dst, objDst)
 
-                        if err := g.getObject(client, objDst, bucket, objPath, ""); err != nil {
+                        if err := g.getObject(ctx, client, objDst, bucket, objPath, ""); err != nil {
                                 return err
                         }
                 }
@@ -134,6 +138,7 @@ func (g *S3Getter) Get(dst string, u *url.URL) error {
 }
 
 func (g *S3Getter) GetFile(dst string, u *url.URL) error {
+        ctx := g.Context()
         region, bucket, path, version, creds, err := g.parseUrl(u)
         if err != nil {
                 return err
@@ -142,10 +147,10 @@ func (g *S3Getter) GetFile(dst string, u *url.URL) error {
         config := g.getAWSConfig(region, u, creds)
         sess := session.New(config)
         client := s3.New(sess)
-        return g.getObject(client, dst, bucket, path, version)
+        return g.getObject(ctx, client, dst, bucket, path, version)
 }
 
-func (g *S3Getter) getObject(client *s3.S3, dst, bucket, key, version string) error {
+func (g *S3Getter) getObject(ctx context.Context, client *s3.S3, dst, bucket, key, version string) error {
         req := &s3.GetObjectInput{
                 Bucket: aws.String(bucket),
                 Key:    aws.String(key),
@@ -170,7 +175,7 @@ func (g *S3Getter) getObject(client *s3.S3, dst, bucket, key, version string) er
         }
         defer f.Close()
 
-        _, err = io.Copy(f, resp.Body)
+        _, err = Copy(ctx, f, resp.Body)
         return err
 }
 
diff --git a/vendor/github.com/hashicorp/go-getter/go.mod b/vendor/github.com/hashicorp/go-getter/go.mod
new file mode 100644
index 0000000..807c0a2
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-getter/go.mod
@@ -0,0 +1,22 @@
+module github.com/hashicorp/go-getter
+
+require (
+        cloud.google.com/go v0.36.0
+        github.com/aws/aws-sdk-go v1.15.78
+        github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d
+        github.com/cheggaaa/pb v1.0.27
+        github.com/fatih/color v1.7.0 // indirect
+        github.com/hashicorp/go-cleanhttp v0.5.0
+        github.com/hashicorp/go-safetemp v1.0.0
+        github.com/hashicorp/go-version v1.1.0
+        github.com/mattn/go-colorable v0.0.9 // indirect
+        github.com/mattn/go-isatty v0.0.4 // indirect
+        github.com/mattn/go-runewidth v0.0.4 // indirect
+        github.com/mitchellh/go-homedir v1.0.0
+        github.com/mitchellh/go-testing-interface v1.0.0
+        github.com/ulikunitz/xz v0.5.5
+        golang.org/x/net v0.0.0-20181114220301-adae6a3d119a // indirect
+        golang.org/x/sys v0.0.0-20181213200352-4d1cda033e06 // indirect
+        google.golang.org/api v0.1.0
+        gopkg.in/cheggaaa/pb.v1 v1.0.27 // indirect
+)
diff --git a/vendor/github.com/hashicorp/go-getter/go.sum b/vendor/github.com/hashicorp/go-getter/go.sum
new file mode 100644
index 0000000..0fc5088
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-getter/go.sum
@@ -0,0 +1,182 @@
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.31.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.36.0 h1:+aCSj7tOo2LODWVEuZDZeGCckdt6MlSF+X/rB3wUiS8=
+cloud.google.com/go v0.36.0/go.mod h1:RUoy9p/M4ge0HzT8L+SDZ8jg+Q6fth0CiBuhFJpSV40=
+dmitri.shuralyov.com/app/changes v0.0.0-20180602232624-0a106ad413e3/go.mod h1:Yl+fi1br7+Rr3LqpNJf1/uxUdtRUV+Tnj0o93V2B9MU=
+dmitri.shuralyov.com/html/belt v0.0.0-20180602232347-f7d459c86be0/go.mod h1:JLBrvjyP0v+ecvNYvCpyZgu5/xkfAUhi6wJj28eUfSU=
+dmitri.shuralyov.com/service/change v0.0.0-20181023043359-a85b471d5412/go.mod h1:a1inKt/atXimZ4Mv927x+r7UpyzRUf4emIoiiSC2TN4=
+dmitri.shuralyov.com/state v0.0.0-20180228185332-28bcc343414c/go.mod h1:0PRwlb0D6DFvNNtx+9ybjezNCa8XF0xaYcETyp6rHWU=
+git.apache.org/thrift.git v0.0.0-20180902110319-2566ecd5d999/go.mod h1:fPE2ZNJGynbRyZ4dJvy6G277gSllfV2HJqblrnkyeyg=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYUyUczH0OGQWaF5ceTx0UBShxjsH6f8oGKYe2c=
+github.com/aws/aws-sdk-go v1.15.78 h1:LaXy6lWR0YK7LKyuU0QWy2ws/LWTPfYV/UgfiBu4tvY=
+github.com/aws/aws-sdk-go v1.15.78/go.mod h1:E3/ieXAlvM0XWO57iftYVDLLvQ824smPP3ATZkfNZeM=
+github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
+github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d h1:xDfNPAt8lFiC1UJrqV3uuy861HCTo708pDMbjHHdCas=
+github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d/go.mod h1:6QX/PXZ00z/TKoufEY6K/a0k6AhaJrQKdFe6OfVXsa4=
+github.com/bradfitz/go-smtpd v0.0.0-20170404230938-deb6d6237625/go.mod h1:HYsPBTaaSFSlLx/70C2HPIMNZpVV8+vt/A+FMnYP11g=
+github.com/cheggaaa/pb v1.0.27 h1:wIkZHkNfC7R6GI5w7l/PdAdzXzlrbcI3p8OAlnkTsnc=
+github.com/cheggaaa/pb v1.0.27/go.mod h1:pQciLPpbU0oxA0h+VJYYLxO+XeDQb5pZijXscXHm81s=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/coreos/go-systemd v0.0.0-20181012123002-c6f51f82210d/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
+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/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys=
+github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
+github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
+github.com/gliderlabs/ssh v0.1.1/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0=
+github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:tluoj9z5200jBnyusfRPU2LqT6J+DAorxEvtC7LHB+E=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-github v17.0.0+incompatible/go.mod h1:zLgOLi98H3fifZn+44m+umXrS52loVEgC2AApnigrVQ=
+github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
+github.com/google/martian v2.1.0+incompatible h1:/CP5g8u/VJHijgedC/Legn3BAbAaWPgecwXBIDzw5no=
+github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
+github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/googleapis/gax-go v2.0.0+incompatible h1:j0GKcs05QVmm7yesiZq2+9cxHkNK9YM6zKx4D2qucQU=
+github.com/googleapis/gax-go v2.0.0+incompatible/go.mod h1:SFVmujtThgffbyetf+mdk2eWhX2bMyUtNHzFKcPA9HY=
+github.com/googleapis/gax-go/v2 v2.0.3 h1:siORttZ36U2R/WjiJuDz8znElWBiAlO9rVt+mqJt0Cc=
+github.com/googleapis/gax-go/v2 v2.0.3/go.mod h1:LLvjysVCY1JZeum8Z6l8qUty8fiNwE08qbEPm1M08qg=
+github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
+github.com/grpc-ecosystem/grpc-gateway v1.5.0/go.mod h1:RSKVYQBd5MCa4OVpNdGskqpgL2+G+NZTnrVHpWWfpdw=
+github.com/hashicorp/go-cleanhttp v0.5.0 h1:wvCrVc9TjDls6+YGAF2hAifE1E5U1+b4tH6KdvN3Gig=
+github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
+github.com/hashicorp/go-safetemp v1.0.0 h1:2HR189eFNrjHQyENnQMMpCiBAsRxzbTMIgBhEyExpmo=
+github.com/hashicorp/go-safetemp v1.0.0/go.mod h1:oaerMy3BhqiTbVye6QuFhFtIceqFoDHxNAB65b+Rj1I=
+github.com/hashicorp/go-version v1.1.0 h1:bPIoEKD27tNdebFGGxxYwcL4nepeY4j1QP23PFRGzg0=
+github.com/hashicorp/go-version v1.1.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
+github.com/jellevandenhooff/dkim v0.0.0-20150330215556-f50fe3d243e1/go.mod h1:E0B/fFc00Y+Rasa88328GlI/XbtyysCtTHZS8h7IrBU=
+github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8 h1:12VvqtR6Aowv3l/EQUlocDHW2Cp4G9WJVH7uyH8QFJE=
+github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/pty v1.1.3/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/mattn/go-colorable v0.0.9 h1:UVL0vNpWh04HeJXV0KLcaT7r06gOH2l4OW6ddYRUIY4=
+github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
+github.com/mattn/go-isatty v0.0.4 h1:bnP0vzxcAdeI1zdubAl5PjU6zsERjGZb7raWodagDYs=
+github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-runewidth v0.0.4 h1:2BvfKmzob6Bmd4YsL0zygOqfdFnK7GR4QL06Do4/p7Y=
+github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
+github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
+github.com/microcosm-cc/bluemonday v1.0.1/go.mod h1:hsXNsILzKxV+sX77C5b8FSuKF00vh2OMYv+xgHpAMF4=
+github.com/mitchellh/go-homedir v1.0.0 h1:vKb8ShqSby24Yrqr/yDYkuFz8d0WUjys40rvnGC8aR0=
+github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
+github.com/mitchellh/go-testing-interface v1.0.0 h1:fzU/JVNcaqHQEcVFAKeR41fkiLdIPrefOvVG1VZ96U0=
+github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI=
+github.com/neelance/astrewrite v0.0.0-20160511093645-99348263ae86/go.mod h1:kHJEU3ofeGjhHklVoIGuVj85JJwZ6kWPaJwCIxgnFmo=
+github.com/neelance/sourcemap v0.0.0-20151028013722-8c68805598ab/go.mod h1:Qr6/a/Q4r9LP1IltGz7tA7iOK1WonHEYhu1HRBA7ZiM=
+github.com/openzipkin/zipkin-go v0.1.1/go.mod h1:NtoC/o8u3JlF1lSlyPNswIbeQH9bJTmOf0Erfk+hxe8=
+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/prometheus/client_golang v0.8.0/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
+github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/common v0.0.0-20180801064454-c7de2306084e/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
+github.com/prometheus/procfs v0.0.0-20180725123919-05ee40e3a273/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
+github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/shurcooL/component v0.0.0-20170202220835-f88ec8f54cc4/go.mod h1:XhFIlyj5a1fBNx5aJTbKoIq0mNaPvOagO+HjB3EtxrY=
+github.com/shurcooL/events v0.0.0-20181021180414-410e4ca65f48/go.mod h1:5u70Mqkb5O5cxEA8nxTsgrgLehJeAw6Oc4Ab1c/P1HM=
+github.com/shurcooL/github_flavored_markdown v0.0.0-20181002035957-2122de532470/go.mod h1:2dOwnU2uBioM+SGy2aZoq1f/Sd1l9OkAeAUvjSyvgU0=
+github.com/shurcooL/go v0.0.0-20180423040247-9e1955d9fb6e/go.mod h1:TDJrrUr11Vxrven61rcy3hJMUqaf/CLWYhHNPmT14Lk=
+github.com/shurcooL/go-goon v0.0.0-20170922171312-37c2f522c041/go.mod h1:N5mDOmsrJOB+vfqUK+7DmDyjhSLIIBnXo9lvZJj3MWQ=
+github.com/shurcooL/gofontwoff v0.0.0-20180329035133-29b52fc0a18d/go.mod h1:05UtEgK5zq39gLST6uB0cf3NEHjETfB4Fgr3Gx5R9Vw=
+github.com/shurcooL/gopherjslib v0.0.0-20160914041154-feb6d3990c2c/go.mod h1:8d3azKNyqcHP1GaQE/c6dDgjkgSx2BZ4IoEi4F1reUI=
+github.com/shurcooL/highlight_diff v0.0.0-20170515013008-09bb4053de1b/go.mod h1:ZpfEhSmds4ytuByIcDnOLkTHGUI6KNqRNPDLHDk+mUU=
+github.com/shurcooL/highlight_go v0.0.0-20181028180052-98c3abbbae20/go.mod h1:UDKB5a1T23gOMUJrI+uSuH0VRDStOiUVSjBTRDVBVag=
+github.com/shurcooL/home v0.0.0-20181020052607-80b7ffcb30f9/go.mod h1:+rgNQw2P9ARFAs37qieuu7ohDNQ3gds9msbT2yn85sg=
+github.com/shurcooL/htmlg v0.0.0-20170918183704-d01228ac9e50/go.mod h1:zPn1wHpTIePGnXSHpsVPWEktKXHr6+SS6x/IKRb7cpw=
+github.com/shurcooL/httperror v0.0.0-20170206035902-86b7830d14cc/go.mod h1:aYMfkZ6DWSJPJ6c4Wwz3QtW22G7mf/PEgaB9k/ik5+Y=
+github.com/shurcooL/httpfs v0.0.0-20171119174359-809beceb2371/go.mod h1:ZY1cvUeJuFPAdZ/B6v7RHavJWZn2YPVFQ1OSXhCGOkg=
+github.com/shurcooL/httpgzip v0.0.0-20180522190206-b1c53ac65af9/go.mod h1:919LwcH0M7/W4fcZ0/jy0qGght1GIhqyS/EgWGH2j5Q=
+github.com/shurcooL/issues v0.0.0-20181008053335-6292fdc1e191/go.mod h1:e2qWDig5bLteJ4fwvDAc2NHzqFEthkqn7aOZAOpj+PQ=
+github.com/shurcooL/issuesapp v0.0.0-20180602232740-048589ce2241/go.mod h1:NPpHK2TI7iSaM0buivtFUc9offApnI0Alt/K8hcHy0I=
+github.com/shurcooL/notifications v0.0.0-20181007000457-627ab5aea122/go.mod h1:b5uSkrEVM1jQUspwbixRBhaIjIzL2xazXp6kntxYle0=
+github.com/shurcooL/octicon v0.0.0-20181028054416-fa4f57f9efb2/go.mod h1:eWdoE5JD4R5UVWDucdOPg1g2fqQRq78IQa9zlOV1vpQ=
+github.com/shurcooL/reactions v0.0.0-20181006231557-f2e0b4ca5b82/go.mod h1:TCR1lToEk4d2s07G3XGfz2QrgHXg4RJBvjrOozvoWfk=
+github.com/shurcooL/sanitized_anchor_name v0.0.0-20170918181015-86672fcb3f95/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
+github.com/shurcooL/users v0.0.0-20180125191416-49c67e49c537/go.mod h1:QJTqeLYEDaXHZDBsXlPCDqdhQuJkuw4NOtaxYe3xii4=
+github.com/shurcooL/webdavfs v0.0.0-20170829043945-18c3829fa133/go.mod h1:hKmq5kWdCj2z2KEozexVbfEZIWiTjhE0+UjmZgPqehw=
+github.com/sourcegraph/annotate v0.0.0-20160123013949-f4cad6c6324d/go.mod h1:UdhH50NIW0fCiwBSr0co2m7BnFLdv4fQTgdqdJTHFeE=
+github.com/sourcegraph/syntaxhighlight v0.0.0-20170531221838-bd320f5d308e/go.mod h1:HuIsMU8RRBOtsCgI77wP899iHVBQpCmg4ErYMZB+2IA=
+github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07/go.mod h1:kDXzergiv9cbyO7IOYJZWg1U88JhDg3PB6klq9Hg2pA=
+github.com/ulikunitz/xz v0.5.5 h1:pFrO0lVpTBXLpYw+pnLj6TbvHuyjXMfjGeCwSqCVwok=
+github.com/ulikunitz/xz v0.5.5/go.mod h1:2bypXElzHzzJZwzH67Y6wb67pO62Rzfn7BSiF4ABRW8=
+go.opencensus.io v0.18.0 h1:Mk5rgZcggtbvtAun5aJzAtjKKN/t0R3jJPlWILlv938=
+go.opencensus.io v0.18.0/go.mod h1:vKdFvxhtzZ9onBp9VKHK8z/sRpBMnKAsufL7wlDrCOA=
+go4.org v0.0.0-20180809161055-417644f6feb5/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE=
+golang.org/x/build v0.0.0-20190111050920-041ab4dc3f9d/go.mod h1:OWs+y06UdEOHN4y+MfF/py+xQ/tYqIWW03b70/CG9Rw=
+golang.org/x/crypto v0.0.0-20181030102418-4d3f4d9ffa16/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181029044818-c44066c5c816/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181106065722-10aee1819953/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181114220301-adae6a3d119a h1:gOpx8G595UYyvj8UK4+OFyY4rx037g3fmfhe5SasG3U=
+golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20181017192945-9dcd33a902f4/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890 h1:uESlIz09WIHT2I+pasSXcpLYqYK8wHcdCetU3VuMBJE=
+golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/perf v0.0.0-20180704124530-6e6d33e29852/go.mod h1:JLpeXjPJfIyPr5TlbXLkXWLhP8nz10XfvxElABhCtcw=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f h1:Bl/8QSvNqXvPGPGXa2z5xUTmV7VDcZyvRZ+QQXkXTZQ=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181029174526-d69651ed3497/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181213200352-4d1cda033e06 h1:0oC8rFnE+74kEmuHZ46F6KHsMr5Gx2gUQPuNz28iQZM=
+golang.org/x/sys v0.0.0-20181213200352-4d1cda033e06/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2 h1:z99zHgr7hKfrUcX/KsoJk5FJfjTceCKIp96+biqP4To=
+golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20181030000716-a0a13e073c7b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+google.golang.org/api v0.0.0-20180910000450-7ca32eb868bf/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
+google.golang.org/api v0.0.0-20181030000543-1d582fd0359e/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
+google.golang.org/api v0.1.0 h1:K6z2u68e86TPdSdefXdzvXgR1zEMa+459vBSfWYAZkI=
+google.golang.org/api v0.1.0/go.mod h1:UGEZY7KEX120AnNLIHFMKIo4obdJhkp2tPbaPlQx13Y=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.3.0 h1:FBSsiFRMz3LBeXIomRnVzrQwSDj4ibvcRexLG0LZGQk=
+google.golang.org/appengine v1.3.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20180831171423-11092d34479b/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20181029155118-b69ba1387ce2/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20181202183823-bd91e49a0898/go.mod h1:7Ep/1NZk928CDR8SjdVbjWNpdIf6nzjE3BTgJDr2Atg=
+google.golang.org/genproto v0.0.0-20190201180003-4b09977fb922 h1:mBVYJnbrXLA/ZCBTCe7PtEgAUP+1bg92qTaFoPHdz+8=
+google.golang.org/genproto v0.0.0-20190201180003-4b09977fb922/go.mod h1:L3J43x8/uS+qIUoksaLKe6OS3nUKxOKuIFz1sl2/jx4=
+google.golang.org/grpc v1.14.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
+google.golang.org/grpc v1.16.0/go.mod h1:0JHn/cJsOMiMfNA9+DeHDlAU7KAAB5GDlYFpa9MZMio=
+google.golang.org/grpc v1.17.0 h1:TRJYBgMclJvGYn2rIMjj+h9KtMt5r1Ij7ODVRIZkwhk=
+google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/cheggaaa/pb.v1 v1.0.27 h1:kJdccidYzt3CaHD1crCFTS1hxyhSi059NhOFUf03YFo=
+gopkg.in/cheggaaa/pb.v1 v1.0.27/go.mod h1:V/YB90LKu/1FcN3WVnfiiE5oMCibMjukxqG/qStrOgw=
+gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+grpc.go4.org v0.0.0-20170609214715-11d0a25b4919/go.mod h1:77eQGdRu53HpSqPFJFmuJdjuHRquDANNeA4x7B8WQ9o=
+honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+sourcegraph.com/sourcegraph/go-diff v0.5.0/go.mod h1:kuch7UrkMzY0X+p9CRK03kfuPQ2zzQcaEFbx8wA8rck=
+sourcegraph.com/sqs/pbtypes v0.0.0-20180604144634-d3ebe8f20ae4/go.mod h1:ketZ/q3QxT9HOBeFhu6RdvsftgpsbFHBF5Cas6cDKZ0=
diff --git a/vendor/github.com/hashicorp/go-getter/helper/url/url_windows.go b/vendor/github.com/hashicorp/go-getter/helper/url/url_windows.go
index 4655226..4280ec5 100644
--- a/vendor/github.com/hashicorp/go-getter/helper/url/url_windows.go
+++ b/vendor/github.com/hashicorp/go-getter/helper/url/url_windows.go
@@ -11,19 +11,18 @@ func parse(rawURL string) (*url.URL, error) {
         // Make sure we're using "/" since URLs are "/"-based.
         rawURL = filepath.ToSlash(rawURL)
 
+        if len(rawURL) > 1 && rawURL[1] == ':' {
+                // Assume we're dealing with a drive letter. In which case we
+                // force the 'file' scheme to avoid "net/url" URL.String() prepending
+                // our url with "./".
+                rawURL = "file://" + rawURL
+        }
+
         u, err := url.Parse(rawURL)
         if err != nil {
                 return nil, err
         }
 
-        if len(rawURL) > 1 && rawURL[1] == ':' {
-                // Assume we're dealing with a drive letter file path where the drive
-                // letter has been parsed into the URL Scheme, and the rest of the path
-                // has been parsed into the URL Path without the leading ':' character.
-                u.Path = fmt.Sprintf("%s:%s", string(rawURL[0]), u.Path)
-                u.Scheme = ""
-        }
-
         if len(u.Host) > 1 && u.Host[1] == ':' && strings.HasPrefix(rawURL, "file://") {
                 // Assume we're dealing with a drive letter file path where the drive
                 // letter has been parsed into the URL Host.
diff --git a/vendor/github.com/hashicorp/go-getter/source.go b/vendor/github.com/hashicorp/go-getter/source.go
index c63f2bb..dab6d40 100644
--- a/vendor/github.com/hashicorp/go-getter/source.go
+++ b/vendor/github.com/hashicorp/go-getter/source.go
@@ -6,18 +6,31 @@ import (
         "strings"
 )
 
-// SourceDirSubdir takes a source and returns a tuple of the URL without
-// the subdir and the URL with the subdir.
+// SourceDirSubdir takes a source URL and returns a tuple of the URL without
+// the subdir and the subdir.
+//
+// ex:
+//   dom.com/path/?q=p               => dom.com/path/?q=p, ""
+//   proto://dom.com/path//*?q=p     => proto://dom.com/path?q=p, "*"
+//   proto://dom.com/path//path2?q=p => proto://dom.com/path?q=p, "path2"
+//
 func SourceDirSubdir(src string) (string, string) {
-        // Calcaulate an offset to avoid accidentally marking the scheme
+
+        // URL might contains another url in query parameters
+        stop := len(src)
+        if idx := strings.Index(src, "?"); idx > -1 {
+                stop = idx
+        }
+
+        // Calculate an offset to avoid accidentally marking the scheme
         // as the dir.
         var offset int
-        if idx := strings.Index(src, "://"); idx > -1 {
+        if idx := strings.Index(src[:stop], "://"); idx > -1 {
                 offset = idx + 3
         }
 
         // First see if we even have an explicit subdir
-        idx := strings.Index(src[offset:], "//")
+        idx := strings.Index(src[offset:stop], "//")
         if idx == -1 {
                 return src, ""
         }