pax_global_header00006660000000000000000000000064133372150170014514gustar00rootroot0000000000000052 comment=906e15686e6309ff310c1c10463ab53287c3a678 golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/000077500000000000000000000000001333721501700232565ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/.travis.yml000066400000000000000000000003501333721501700253650ustar00rootroot00000000000000sudo: false addons: apt: sources: - sourceline: 'ppa:git-core/ppa' packages: - git language: go go: - 1.8.x - 1.9.x - master branches: only: - master matrix: allow_failures: - go: master golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/LICENSE000066400000000000000000000371511333721501700242720ustar00rootroot00000000000000Mozilla Public License, version 2.0 1. Definitions 1.1. “Contributor” means each individual or legal entity that creates, contributes to the creation of, or owns Covered Software. 1.2. “Contributor Version” means the combination of the Contributions of others (if any) used by a Contributor and that particular Contributor’s Contribution. 1.3. “Contribution” means Covered Software of a particular Contributor. 1.4. “Covered Software” means Source Code Form to which the initial Contributor has attached the notice in Exhibit A, the Executable Form of such Source Code Form, and Modifications of such Source Code Form, in each case including portions thereof. 1.5. “Incompatible With Secondary Licenses” means a. that the initial Contributor has attached the notice described in Exhibit B to the Covered Software; or b. that the Covered Software was made available under the terms of version 1.1 or earlier of the License, but not also under the terms of a Secondary License. 1.6. “Executable Form” means any form of the work other than Source Code Form. 1.7. “Larger Work” means a work that combines Covered Software with other material, in a separate file or files, that is not Covered Software. 1.8. “License” means this document. 1.9. “Licensable” means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently, any and all of the rights conveyed by this License. 1.10. “Modifications” means any of the following: a. any file in Source Code Form that results from an addition to, deletion from, or modification of the contents of Covered Software; or b. any new file in Source Code Form that contains any Covered Software. 1.11. “Patent Claims” of a Contributor means any patent claim(s), including without limitation, method, process, and apparatus claims, in any patent Licensable by such Contributor that would be infringed, but for the grant of the License, by the making, using, selling, offering for sale, having made, import, or transfer of either its Contributions or its Contributor Version. 1.12. “Secondary License” means either the GNU General Public License, Version 2.0, the GNU Lesser General Public License, Version 2.1, the GNU Affero General Public License, Version 3.0, or any later versions of those licenses. 1.13. “Source Code Form” means the form of the work preferred for making modifications. 1.14. “You” (or “Your”) means an individual or a legal entity exercising rights under this License. For legal entities, “You” includes any entity that controls, is controlled by, or is under common control with You. For purposes of this definition, “control” means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity. 2. License Grants and Conditions 2.1. Grants Each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license: a. under intellectual property rights (other than patent or trademark) Licensable by such Contributor to use, reproduce, make available, modify, display, perform, distribute, and otherwise exploit its Contributions, either on an unmodified basis, with Modifications, or as part of a Larger Work; and b. under Patent Claims of such Contributor to make, use, sell, offer for sale, have made, import, and otherwise transfer either its Contributions or its Contributor Version. 2.2. Effective Date The licenses granted in Section 2.1 with respect to any Contribution become effective for each Contribution on the date the Contributor first distributes such Contribution. 2.3. Limitations on Grant Scope The licenses granted in this Section 2 are the only rights granted under this License. No additional rights or licenses will be implied from the distribution or licensing of Covered Software under this License. Notwithstanding Section 2.1(b) above, no patent license is granted by a Contributor: a. for any code that a Contributor has removed from Covered Software; or b. for infringements caused by: (i) Your and any other third party’s modifications of Covered Software, or (ii) the combination of its Contributions with other software (except as part of its Contributor Version); or c. under Patent Claims infringed by Covered Software in the absence of its Contributions. This License does not grant any rights in the trademarks, service marks, or logos of any Contributor (except as may be necessary to comply with the notice requirements in Section 3.4). 2.4. Subsequent Licenses No Contributor makes additional grants as a result of Your choice to distribute the Covered Software under a subsequent version of this License (see Section 10.2) or under the terms of a Secondary License (if permitted under the terms of Section 3.3). 2.5. Representation Each Contributor represents that the Contributor believes its Contributions are its original creation(s) or it has sufficient rights to grant the rights to its Contributions conveyed by this License. 2.6. Fair Use This License is not intended to limit any rights You have under applicable copyright doctrines of fair use, fair dealing, or other equivalents. 2.7. Conditions Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in Section 2.1. 3. Responsibilities 3.1. Distribution of Source Form All distribution of Covered Software in Source Code Form, including any Modifications that You create or to which You contribute, must be under the terms of this License. You must inform recipients that the Source Code Form of the Covered Software is governed by the terms of this License, and how they can obtain a copy of this License. You may not attempt to alter or restrict the recipients’ rights in the Source Code Form. 3.2. Distribution of Executable Form If You distribute Covered Software in Executable Form then: a. such Covered Software must also be made available in Source Code Form, as described in Section 3.1, and You must inform recipients of the Executable Form how they can obtain a copy of such Source Code Form by reasonable means in a timely manner, at a charge no more than the cost of distribution to the recipient; and b. You may distribute such Executable Form under the terms of this License, or sublicense it under different terms, provided that the license for the Executable Form does not attempt to limit or alter the recipients’ rights in the Source Code Form under this License. 3.3. Distribution of a Larger Work You may create and distribute a Larger Work under terms of Your choice, provided that You also comply with the requirements of this License for the Covered Software. If the Larger Work is a combination of Covered Software with a work governed by one or more Secondary Licenses, and the Covered Software is not Incompatible With Secondary Licenses, this License permits You to additionally distribute such Covered Software under the terms of such Secondary License(s), so that the recipient of the Larger Work may, at their option, further distribute the Covered Software under the terms of either this License or such Secondary License(s). 3.4. Notices You may not remove or alter the substance of any license notices (including copyright notices, patent notices, disclaimers of warranty, or limitations of liability) contained within the Source Code Form of the Covered Software, except that You may alter any license notices to the extent required to remedy known factual inaccuracies. 3.5. Application of Additional Terms You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Software. However, You may do so only on Your own behalf, and not on behalf of any Contributor. You must make it absolutely clear that any such warranty, support, indemnity, or liability obligation is offered by You alone, and You hereby agree to indemnify every Contributor for any liability incurred by such Contributor as a result of warranty, support, indemnity or liability terms You offer. You may include additional disclaimers of warranty and limitations of liability specific to any jurisdiction. 4. Inability to Comply Due to Statute or Regulation If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Software due to statute, judicial order, or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be placed in a text file included with all distributions of the Covered Software under this License. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it. 5. Termination 5.1. The rights granted under this License will terminate automatically if You fail to comply with any of its terms. However, if You become compliant, then the rights granted under this License from a particular Contributor are reinstated (a) provisionally, unless and until such Contributor explicitly and finally terminates Your grants, and (b) on an ongoing basis, if such Contributor fails to notify You of the non-compliance by some reasonable means prior to 60 days after You have come back into compliance. Moreover, Your grants from a particular Contributor are reinstated on an ongoing basis if such Contributor notifies You of the non-compliance by some reasonable means, this is the first time You have received notice of non-compliance with this License from such Contributor, and You become compliant prior to 30 days after Your receipt of the notice. 5.2. If You initiate litigation against any entity by asserting a patent infringement claim (excluding declaratory judgment actions, counter-claims, and cross-claims) alleging that a Contributor Version directly or indirectly infringes any patent, then the rights granted to You by any and all Contributors for the Covered Software under Section 2.1 of this License shall terminate. 5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or Your distributors under this License prior to termination shall survive termination. 6. Disclaimer of Warranty Covered Software is provided under this License on an “as is” basis, without warranty of any kind, either expressed, implied, or statutory, including, without limitation, warranties that the Covered Software is free of defects, merchantable, fit for a particular purpose or non-infringing. The entire risk as to the quality and performance of the Covered Software is with You. Should any Covered Software prove defective in any respect, You (not any Contributor) assume the cost of any necessary servicing, repair, or correction. This disclaimer of warranty constitutes an essential part of this License. No use of any Covered Software is authorized under this License except under this disclaimer. 7. Limitation of Liability Under no circumstances and under no legal theory, whether tort (including negligence), contract, or otherwise, shall any Contributor, or anyone who distributes Covered Software as permitted above, be liable to You for any direct, indirect, special, incidental, or consequential damages of any character including, without limitation, damages for lost profits, loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses, even if such party shall have been informed of the possibility of such damages. This limitation of liability shall not apply to liability for death or personal injury resulting from such party’s negligence to the extent applicable law prohibits such limitation. Some jurisdictions do not allow the exclusion or limitation of incidental or consequential damages, so this exclusion and limitation may not apply to You. 8. Litigation Any litigation relating to this License may be brought only in the courts of a jurisdiction where the defendant maintains its principal place of business and such litigation shall be governed by laws of that jurisdiction, without reference to its conflict-of-law provisions. Nothing in this Section shall prevent a party’s ability to bring cross-claims or counter-claims. 9. Miscellaneous This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not be used to construe this License against a Contributor. 10. Versions of the License 10.1. New Versions Mozilla Foundation is the license steward. Except as provided in Section 10.3, no one other than the license steward has the right to modify or publish new versions of this License. Each version will be given a distinguishing version number. 10.2. Effect of New Versions You may distribute the Covered Software under the terms of the version of the License under which You originally received the Covered Software, or under the terms of any subsequent version published by the license steward. 10.3. Modified Versions If you create software not governed by this License, and you want to create a new license for such software, you may create and use a modified version of this License if you rename the license and remove any references to the name of the license steward (except to note that such modified license differs from this License). 10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses If You choose to distribute Source Code Form that is Incompatible With Secondary Licenses under the terms of this version of the License, the notice described in Exhibit B of this License must be attached. Exhibit A - Source Code Form License Notice This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/. If it is not possible or desirable to put the notice in a particular file, then You may include the notice in a location (such as a LICENSE file in a relevant directory) where a recipient would be likely to look for such a notice. You may add additional accurate notices of copyright ownership. Exhibit B - “Incompatible With Secondary Licenses” Notice This Source Code Form is “Incompatible With Secondary Licenses”, as defined by the Mozilla Public License, v. 2.0. golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/README.md000066400000000000000000000256231333721501700245450ustar00rootroot00000000000000# go-getter [![Build Status](http://img.shields.io/travis/hashicorp/go-getter.svg?style=flat-square)][travis] [![Build status](https://ci.appveyor.com/api/projects/status/ulq3qr43n62croyq/branch/master?svg=true)][appveyor] [![Go Documentation](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)][godocs] [travis]: http://travis-ci.org/hashicorp/go-getter [godocs]: http://godoc.org/github.com/hashicorp/go-getter [appveyor]: https://ci.appveyor.com/project/hashicorp/go-getter/branch/master go-getter is a library for Go (golang) for downloading files or directories from various sources using a URL as the primary form of input. The power of this library is being flexible in being able to download from a number of different sources (file paths, Git, HTTP, Mercurial, etc.) using a single string as input. This removes the burden of knowing how to download from a variety of sources from the implementer. The concept of a _detector_ automatically turns invalid URLs into proper URLs. For example: "github.com/hashicorp/go-getter" would turn into a Git URL. Or "./foo" would turn into a file URL. These are extensible. This library is used by [Terraform](https://terraform.io) for downloading modules and [Nomad](https://nomadproject.io) for downloading binaries. ## Installation and Usage Package documentation can be found on [GoDoc](http://godoc.org/github.com/hashicorp/go-getter). Installation can be done with a normal `go get`: ``` $ go get github.com/hashicorp/go-getter ``` go-getter also has a command you can use to test URL strings: ``` $ go install github.com/hashicorp/go-getter/cmd/go-getter ... $ go-getter github.com/foo/bar ./foo ... ``` The command is useful for verifying URL structures. ## URL Format go-getter uses a single string URL as input to download from a variety of protocols. go-getter has various "tricks" with this URL to do certain things. This section documents the URL format. ### Supported Protocols and Detectors **Protocols** are used to download files/directories using a specific mechanism. Example protocols are Git and HTTP. **Detectors** are used to transform a valid or invalid URL into another URL if it matches a certain pattern. Example: "github.com/user/repo" is automatically transformed into a fully valid Git URL. This allows go-getter to be very user friendly. go-getter out of the box supports the following protocols. Additional protocols can be augmented at runtime by implementing the `Getter` interface. * Local files * Git * Mercurial * HTTP * Amazon S3 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 it, which might involve even changing the protocol. The following detection is built-in by default: * File paths such as "./foo" are automatically changed to absolute file URLs. * GitHub URLs, such as "github.com/mitchellh/vagrant" are automatically changed to Git protocol over HTTP. * BitBucket URLs, such as "bitbucket.org/mitchellh/vagrant" are automatically changed to a Git or mercurial protocol using the BitBucket API. ### Forced Protocol In some cases, the protocol to use is ambiguous depending on the source URL. For example, "http://github.com/mitchellh/vagrant.git" could reference an HTTP URL or a Git URL. Forced protocol syntax is used to disambiguate this URL. Forced protocol can be done by prefixing the URL with the protocol followed by double colons. For example: `git::http://github.com/mitchellh/vagrant.git` 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 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. ### Protocol-Specific Options Each protocol can support protocol-specific options to configure that protocol. For example, the `git` protocol supports specifying a `ref` query parameter that tells it what ref to checkout for that Git repository. The options are specified as query parameters on the URL (or URL-like string) given to go-getter. Using the Git example above, the URL below is a valid input to go-getter: github.com/hashicorp/go-getter?ref=abcd1234 The protocol-specific options are documented below the URL format section. But because they are part of the URL, we point it out here so you know they exist. ### Subdirectories If you want to download only a specific subdirectory from a downloaded directory, you can specify a subdirectory after a double-slash `//`. go-getter will first download the URL specified _before_ the double-slash (as if you didn't specify a double-slash), but will then copy the path after the double slash into the target directory. For example, if you're downloading this GitHub repository, but you only want to download the `test-fixtures` directory, you can do the following: ``` https://github.com/hashicorp/go-getter.git//test-fixtures ``` If you downloaded this to the `/tmp` directory, then the file `/tmp/archive.gz` would exist. Notice that this file is in the `test-fixtures` directory in this repository, but because we specified a subdirectory, go-getter automatically copied only that directory contents. Subdirectory paths may contain may also use filesystem glob patterns. The path must match _exactly one_ entry or go-getter will return an error. This is useful if you're not sure the exact directory name but it follows a predictable naming structure. For example, the following URL would also work: ``` https://github.com/hashicorp/go-getter.git//test-* ``` ### Checksumming 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: ``` ./foo.txt?checksum=md5:b7d96c89d09d9e204f5fedc4d5d55b21 ``` The checksum query parameter is never sent to the backend protocol implementation. It is used at a higher level by go-getter itself. ### Unarchiving go-getter will automatically unarchive files into a file or directory based on the extension of the file being requested (over any protocol). This works for both file and directory downloads. go-getter looks for an `archive` query parameter to specify the format of the archive. If this isn't specified, go-getter will use the extension of the path to see if it appears archived. Unarchiving can be explicitly disabled by setting the `archive` query parameter to `false`. The following archive formats are supported: * `tar.gz` and `tgz` * `tar.bz2` and `tbz2` * `tar.xz` and `txz` * `zip` * `gz` * `bz2` * `xz` For example, an example URL is shown below: ``` ./foo.zip ``` This will automatically be inferred to be a ZIP file and will be extracted. You can also be explicit about the archive type: ``` ./some/other/path?archive=zip ``` And finally, you can disable archiving completely: ``` ./some/path?archive=false ``` You can combine unarchiving with the other features of go-getter such as checksumming. The special `archive` query parameter will be removed 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. ## General (All Protocols) The options below are available to all protocols: * `archive` - The archive format to use to unarchive this file, or "" (empty string) to disable unarchiving. For more details, see the complete section on archive support above. * `checksum` - Checksum to verify the downloaded file or archive. See the entire section on checksumming above for format and more details. * `filename` - When in file download mode, allows specifying the name of the downloaded file on disk. Has no effect in directory mode. ### Local Files (`file`) None ### Git (`git`) * `ref` - The Git ref to checkout. This is a ref, so it can point to a commit SHA, a branch name, etc. If it is a named ref such as a branch name, go-getter will update it to the latest on each get. * `sshkey` - An SSH private key to use during clones. The provided key must be a base64-encoded string. For example, to generate a suitable `sshkey` from a private key file on disk, you would run `base64 -w0 `. **Note**: Git 2.3+ is required to use this feature. ### Mercurial (`hg`) * `rev` - The Mercurial revision to checkout. ### HTTP (`http`) #### Basic Authentication To use HTTP basic authentication with go-getter, simply prepend `username:password@` to the 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. ### S3 (`s3`) S3 takes various access configurations in the URL. Note that it will also read these from standard AWS environment variables if they're set. S3 compliant servers like Minio are also supported. If the query parameters are present, these take priority. * `aws_access_key_id` - AWS access key. * `aws_access_key_secret` - AWS access key secret. * `aws_access_token` - AWS access token if this is being used. #### Using IAM Instance Profiles with S3 If you use go-getter and want to use an EC2 IAM Instance Profile to avoid using credentials, then just omit these and the profile, if available will be used automatically. ### Using S3 with Minio If you use go-gitter for Minio support, you must consider the following: * `aws_access_key_id` (required) - Minio access key. * `aws_access_key_secret` (required) - Minio access key secret. * `region` (optional - defaults to us-east-1) - Region identifier to use. * `version` (optional - defaults to Minio default) - Configuration file format. #### S3 Bucket Examples S3 has several addressing schemes used to reference your bucket. These are listed here: http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html#access-bucket-intro Some examples for these addressing schemes: - s3::https://s3.amazonaws.com/bucket/foo - s3::https://s3-eu-west-1.amazonaws.com/bucket/foo - bucket.s3.amazonaws.com/foo - 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®ion=us-east-2" golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/appveyor.yml000066400000000000000000000004241333721501700256460ustar00rootroot00000000000000version: "build-{branch}-{build}" image: Visual Studio 2017 clone_folder: c:\gopath\github.com\hashicorp\go-getter environment: GOPATH: c:\gopath install: - cmd: >- echo %Path% go version go env go get -d -v -t ./... build_script: - cmd: go test -v ./... golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/client.go000066400000000000000000000213121333721501700250620ustar00rootroot00000000000000package getter import ( "bytes" "crypto/md5" "crypto/sha1" "crypto/sha256" "crypto/sha512" "encoding/hex" "fmt" "hash" "io" "io/ioutil" "os" "path/filepath" "strconv" "strings" urlhelper "github.com/hashicorp/go-getter/helper/url" "github.com/hashicorp/go-safetemp" ) // Client is a client for downloading things. // // Top-level functions such as Get are shortcuts for interacting with a client. // Using a client directly allows more fine-grained control over how downloading // is done, as well as customizing the protocols supported. type Client struct { // Src is the source URL to get. // // Dst is the path to save the downloaded thing as. If Dir is set to // true, then this should be a directory. If the directory doesn't exist, // it will be created for you. // // Pwd is the working directory for detection. If this isn't set, some // detection may fail. Client will not default pwd to the current // working directory for security reasons. Src string Dst string Pwd string // Mode is the method of download the client will use. See ClientMode // for documentation. Mode ClientMode // Detectors is the list of detectors that are tried on the source. // If this is nil, then the default Detectors will be used. Detectors []Detector // Decompressors is the map of decompressors supported by this client. // If this is nil, then the default value is the Decompressors global. Decompressors map[string]Decompressor // Getters is the map of protocols supported by this client. If this // is nil, then the default Getters variable will be used. Getters map[string]Getter // Dir, if true, tells the Client it is downloading a directory (versus // a single file). This distinction is necessary since filenames and // directory names follow the same format so disambiguating is impossible // without knowing ahead of time. // // WARNING: deprecated. If Mode is set, that will take precedence. Dir bool } // Get downloads the configured source to the destination. func (c *Client) Get() error { // Store this locally since there are cases we swap this mode := c.Mode if mode == ClientModeInvalid { if c.Dir { mode = ClientModeDir } else { mode = ClientModeFile } } // 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) if err != nil { return err } // Determine if we have a forced protocol, i.e. "git::http://..." force, src := getForcedGetter(src) // If there is a subdir component, then we download the root separately // and then copy over the proper subdir. var realDst string dst := c.Dst src, subDir := SourceDirSubdir(src) if subDir != "" { td, tdcloser, err := safetemp.Dir("", "getter") if err != nil { return err } defer tdcloser.Close() realDst = dst dst = td } u, err := urlhelper.Parse(src) if err != nil { return err } if force == "" { force = u.Scheme } getters := c.Getters if getters == nil { getters = Getters } g, ok := getters[force] if !ok { return fmt.Errorf( "download not supported for scheme '%s'", force) } // We have magic query parameters that we use to signal different features q := u.Query() // Determine if we have an archive type archiveV := q.Get("archive") if archiveV != "" { // Delete the paramter since it is a magic parameter we don't // want to pass on to the Getter q.Del("archive") u.RawQuery = q.Encode() // If we can parse the value as a bool and it is false, then // set the archive to "-" which should never map to a decompressor if b, err := strconv.ParseBool(archiveV); err == nil && !b { archiveV = "-" } } if archiveV == "" { // We don't appear to... but is it part of the filename? matchingLen := 0 for k, _ := range decompressors { if strings.HasSuffix(u.Path, "."+k) && len(k) > matchingLen { archiveV = k matchingLen = len(k) } } } // If we have a decompressor, then we need to change the destination // to download to a temporary path. We unarchive this into the final, // real path. var decompressDst string var decompressDir bool decompressor := decompressors[archiveV] if decompressor != nil { // Create a temporary directory to store our archive. We delete // this at the end of everything. td, err := ioutil.TempDir("", "getter") if err != nil { return fmt.Errorf( "Error creating temporary directory for archive: %s", err) } defer os.RemoveAll(td) // Swap the download directory to be our temporary path and // store the old values. decompressDst = dst decompressDir = mode != ClientModeFile dst = filepath.Join(td, "archive") 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 } if mode == ClientModeAny { // Ask the getter which client mode to use mode, err = g.ClientMode(u) if err != nil { return err } // Destination is the base name of the URL path in "any" mode when // a file source is detected. if mode == ClientModeFile { filename := filepath.Base(u.Path) // Determine if we have a custom file name if v := q.Get("filename"); v != "" { // Delete the query parameter if we have it. q.Del("filename") u.RawQuery = q.Encode() filename = v } dst = filepath.Join(dst, filename) } } // 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 } if checksumHash != nil { if err := checksum(dst, checksumHash, checksumValue); err != nil { return err } } if decompressor != nil { // We have a decompressor, so decompress the current destination // into the final destination with the proper mode. err := decompressor.Decompress(decompressDst, dst, decompressDir) if err != nil { return err } // Swap the information back dst = decompressDst if decompressDir { mode = ClientModeAny } else { mode = ClientModeFile } } // We check the dir value again because it can be switched back // if we were unarchiving. If we're still only Get-ing a file, then // we're done. if mode == ClientModeFile { return nil } } // If we're at this point we're either downloading a directory or we've // downloaded and unarchived a directory and we're just checking subdir. // In the case we have a decompressor we don't Get because it was Get // above. if decompressor == nil { // If we're getting a directory, then this is an error. You cannot // checksum a directory. TODO: test if checksumHash != nil { return fmt.Errorf( "checksum cannot be specified for directory download") } // We're downloading a directory, which might require a bit more work // if we're specifying a subdir. err := g.Get(dst, u) if err != nil { err = fmt.Errorf("error downloading '%s': %s", src, err) return err } } // If we have a subdir, copy that over if subDir != "" { if err := os.RemoveAll(realDst); err != nil { return err } if err := os.MkdirAll(realDst, 0755); err != nil { return err } // Process any globs subDir, err := SubdirGlob(dst, subDir) if err != nil { 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 nil } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/client_mode.go000066400000000000000000000014101333721501700260630ustar00rootroot00000000000000package getter // ClientMode is the mode that the client operates in. type ClientMode uint const ( ClientModeInvalid ClientMode = iota // ClientModeAny downloads anything it can. In this mode, dst must // be a directory. If src is a file, it is saved into the directory // with the basename of the URL. If src is a directory or archive, // it is unpacked directly into dst. ClientModeAny // ClientModeFile downloads a single file. In this mode, dst must // be a file path (doesn't have to exist). src must point to a single // file. It is saved as dst. ClientModeFile // ClientModeDir downloads a directory. In this mode, dst must be // a directory path (doesn't have to exist). src must point to an // archive or directory (such as in s3). ClientModeDir ) golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/cmd/000077500000000000000000000000001333721501700240215ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/cmd/go-getter/000077500000000000000000000000001333721501700257165ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/cmd/go-getter/main.go000066400000000000000000000016561333721501700272010ustar00rootroot00000000000000package main import ( "flag" "log" "os" "github.com/hashicorp/go-getter" ) func main() { modeRaw := flag.String("mode", "any", "get mode (any, file, dir)") flag.Parse() args := flag.Args() if len(args) < 2 { log.Fatalf("Expected two args: URL and dst") os.Exit(1) } // Get the mode var mode getter.ClientMode switch *modeRaw { case "any": mode = getter.ClientModeAny case "file": mode = getter.ClientModeFile case "dir": mode = getter.ClientModeDir default: log.Fatalf("Invalid client mode, must be 'any', 'file', or 'dir': %s", *modeRaw) os.Exit(1) } // Get the pwd pwd, err := os.Getwd() if err != nil { log.Fatalf("Error getting wd: %s", err) os.Exit(1) } // Build the client client := &getter.Client{ Src: args[0], Dst: args[1], Pwd: pwd, Mode: mode, } if err := client.Get(); err != nil { log.Fatalf("Error downloading: %s", err) os.Exit(1) } log.Println("Success!") } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/copy_dir.go000066400000000000000000000030061333721501700254140ustar00rootroot00000000000000package getter import ( "io" "os" "path/filepath" "strings" ) // copyDir copies the src directory contents into dst. Both directories // 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 { src, err := filepath.EvalSymlinks(src) if err != nil { return err } walkFn := func(path string, info os.FileInfo, err error) error { if err != nil { return err } if path == src { return nil } if ignoreDot && strings.HasPrefix(filepath.Base(path), ".") { // Skip any dot files if info.IsDir() { return filepath.SkipDir } else { return nil } } // The "path" has the src prefixed to it. We need to join our // destination with the path without the src on it. dstPath := filepath.Join(dst, path[len(src):]) // If we have a directory, make that subdirectory, then continue // the walk. if info.IsDir() { if path == filepath.Join(src, dst) { // dst is in src; don't walk it. return nil } if err := os.MkdirAll(dstPath, 0755); err != nil { return err } return nil } // If we have a file, copy the contents. srcF, err := os.Open(path) if err != nil { return err } defer srcF.Close() dstF, err := os.Create(dstPath) if err != nil { return err } defer dstF.Close() if _, err := io.Copy(dstF, srcF); err != nil { return err } // Chmod it return os.Chmod(dstPath, info.Mode()) } return filepath.Walk(src, walkFn) } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/decompress.go000066400000000000000000000033651333721501700257600ustar00rootroot00000000000000package getter import ( "strings" ) // Decompressor defines the interface that must be implemented to add // support for decompressing a type. // // Important: if you're implementing a decompressor, please use the // containsDotDot helper in this file to ensure that files can't be // decompressed outside of the specified directory. type Decompressor interface { // Decompress should decompress src to dst. dir specifies whether dst // is a directory or single file. src is guaranteed to be a single file // that exists. dst is not guaranteed to exist already. Decompress(dst, src string, dir bool) error } // Decompressors is the mapping of extension to the Decompressor implementation // that will decompress that extension/type. var Decompressors map[string]Decompressor func init() { tbzDecompressor := new(TarBzip2Decompressor) tgzDecompressor := new(TarGzipDecompressor) txzDecompressor := new(TarXzDecompressor) Decompressors = map[string]Decompressor{ "bz2": new(Bzip2Decompressor), "gz": new(GzipDecompressor), "xz": new(XzDecompressor), "tar.bz2": tbzDecompressor, "tar.gz": tgzDecompressor, "tar.xz": txzDecompressor, "tbz2": tbzDecompressor, "tgz": tgzDecompressor, "txz": txzDecompressor, "zip": new(ZipDecompressor), } } // containsDotDot checks if the filepath value v contains a ".." entry. // This will check filepath components by splitting along / or \. This // function is copied directly from the Go net/http implementation. func containsDotDot(v string) bool { if !strings.Contains(v, "..") { return false } for _, ent := range strings.FieldsFunc(v, isSlashRune) { if ent == ".." { return true } } return false } func isSlashRune(r rune) bool { return r == '/' || r == '\\' } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/decompress_bzip2.go000066400000000000000000000015231333721501700270600ustar00rootroot00000000000000package getter import ( "compress/bzip2" "fmt" "io" "os" "path/filepath" ) // Bzip2Decompressor is an implementation of Decompressor that can // decompress bz2 files. type Bzip2Decompressor struct{} func (d *Bzip2Decompressor) Decompress(dst, src string, dir bool) error { // Directory isn't supported at all if dir { return fmt.Errorf("bzip2-compressed files can only unarchive to a single file") } // If we're going into a directory we should make that first if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil { return err } // File first f, err := os.Open(src) if err != nil { return err } defer f.Close() // Bzip2 compression is second bzipR := bzip2.NewReader(f) // Copy it out dstF, err := os.Create(dst) if err != nil { return err } defer dstF.Close() _, err = io.Copy(dstF, bzipR) return err } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/decompress_bzip2_test.go000066400000000000000000000007261333721501700301230ustar00rootroot00000000000000package getter import ( "path/filepath" "testing" ) func TestBzip2Decompressor(t *testing.T) { cases := []TestDecompressCase{ { "single.bz2", false, false, nil, "d3b07384d113edec49eaa6238ad5ff00", nil, }, { "single.bz2", true, true, nil, "", nil, }, } for i, tc := range cases { cases[i].Input = filepath.Join("./test-fixtures", "decompress-bz2", tc.Input) } TestDecompressor(t, new(Bzip2Decompressor), cases) } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/decompress_gzip.go000066400000000000000000000016101333721501700270000ustar00rootroot00000000000000package getter import ( "compress/gzip" "fmt" "io" "os" "path/filepath" ) // GzipDecompressor is an implementation of Decompressor that can // decompress gzip files. type GzipDecompressor struct{} func (d *GzipDecompressor) Decompress(dst, src string, dir bool) error { // Directory isn't supported at all if dir { return fmt.Errorf("gzip-compressed files can only unarchive to a single file") } // If we're going into a directory we should make that first if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil { return err } // File first f, err := os.Open(src) if err != nil { return err } defer f.Close() // gzip compression is second gzipR, err := gzip.NewReader(f) if err != nil { return err } defer gzipR.Close() // Copy it out dstF, err := os.Create(dst) if err != nil { return err } defer dstF.Close() _, err = io.Copy(dstF, gzipR) return err } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/decompress_gzip_test.go000066400000000000000000000007211333721501700300410ustar00rootroot00000000000000package getter import ( "path/filepath" "testing" ) func TestGzipDecompressor(t *testing.T) { cases := []TestDecompressCase{ { "single.gz", false, false, nil, "d3b07384d113edec49eaa6238ad5ff00", nil, }, { "single.gz", true, true, nil, "", nil, }, } for i, tc := range cases { cases[i].Input = filepath.Join("./test-fixtures", "decompress-gz", tc.Input) } TestDecompressor(t, new(GzipDecompressor), cases) } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/decompress_tar.go000066400000000000000000000071051333721501700266220ustar00rootroot00000000000000package getter import ( "archive/tar" "fmt" "io" "os" "path/filepath" "time" ) // untar is a shared helper for untarring an archive. The reader should provide // an uncompressed view of the tar archive. 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 { if !done { // Empty archive return fmt.Errorf("empty archive: %s", src) } break } if err != nil { return err } if hdr.Typeflag == tar.TypeXGlobalHeader || hdr.Typeflag == tar.TypeXHeader { // don't unpack extended headers as files continue } path := dst if dir { // Disallow parent traversal if containsDotDot(hdr.Name) { return fmt.Errorf("entry contains '..': %s", hdr.Name) } path = filepath.Join(path, hdr.Name) } if hdr.FileInfo().IsDir() { if !dir { return fmt.Errorf("expected a single file: %s", src) } // A directory, just make the directory and continue unarchiving... if err := os.MkdirAll(path, 0755); err != nil { return err } // Record the directory information so that we may set its attributes // after all files have been extracted dirHdrs = append(dirHdrs, hdr) continue } else { // There is no ordering guarantee that a file in a directory is // listed before the directory dstPath := filepath.Dir(path) // Check that the directory exists, otherwise create it if _, err := os.Stat(dstPath); os.IsNotExist(err) { if err := os.MkdirAll(dstPath, 0755); err != nil { return err } } } // We have a file. If we already decoded, then it is an error if !dir && done { return fmt.Errorf("expected a single file, got multiple: %s", src) } // Mark that we're done so future in single file mode errors done = true // Open the file for writing dstF, err := os.Create(path) if err != nil { return err } _, err = io.Copy(dstF, tarR) dstF.Close() if err != nil { return err } // Chmod the file if err := os.Chmod(path, hdr.FileInfo().Mode()); err != nil { return err } // 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 } } // Perform a final pass over extracted directories to update metadata for _, dirHdr := range dirHdrs { path := filepath.Join(dst, dirHdr.Name) // 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 } } return nil } // tarDecompressor is an implementation of Decompressor that can // unpack tar files. type tarDecompressor struct{} func (d *tarDecompressor) Decompress(dst, src string, dir bool) error { // If we're going into a directory we should make that first mkdir := dst if !dir { mkdir = filepath.Dir(dst) } if err := os.MkdirAll(mkdir, 0755); err != nil { return err } // File first f, err := os.Open(src) if err != nil { return err } defer f.Close() return untar(f, dst, src, dir) } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/decompress_tar_test.go000066400000000000000000000013501333721501700276550ustar00rootroot00000000000000package getter import ( "path/filepath" "testing" "time" ) func TestTar(t *testing.T) { mtime := time.Unix(0, 0) cases := []TestDecompressCase{ { "extended_header.tar", true, false, []string{"directory/", "directory/a", "directory/b"}, "", nil, }, { "implied_dir.tar", true, false, []string{"directory/", "directory/sub/", "directory/sub/a", "directory/sub/b"}, "", nil, }, { "unix_time_0.tar", true, false, []string{"directory/", "directory/sub/", "directory/sub/a", "directory/sub/b"}, "", &mtime, }, } for i, tc := range cases { cases[i].Input = filepath.Join("./test-fixtures", "decompress-tar", tc.Input) } TestDecompressor(t, new(tarDecompressor), cases) } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/decompress_tbz2.go000066400000000000000000000012171333721501700267130ustar00rootroot00000000000000package getter import ( "compress/bzip2" "os" "path/filepath" ) // TarBzip2Decompressor is an implementation of Decompressor that can // decompress tar.bz2 files. type TarBzip2Decompressor struct{} func (d *TarBzip2Decompressor) Decompress(dst, src string, dir bool) error { // If we're going into a directory we should make that first mkdir := dst if !dir { mkdir = filepath.Dir(dst) } if err := os.MkdirAll(mkdir, 0755); err != nil { return err } // File first f, err := os.Open(src) if err != nil { return err } defer f.Close() // Bzip2 compression is second bzipR := bzip2.NewReader(f) return untar(bzipR, dst, src, dir) } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/decompress_tbz2_test.go000066400000000000000000000017121333721501700277520ustar00rootroot00000000000000package getter import ( "path/filepath" "testing" ) func TestTarBzip2Decompressor(t *testing.T) { orderingPaths := []string{"workers/", "workers/mq/", "workers/mq/__init__.py"} cases := []TestDecompressCase{ { "empty.tar.bz2", false, true, nil, "", nil, }, { "single.tar.bz2", false, false, nil, "d3b07384d113edec49eaa6238ad5ff00", nil, }, { "single.tar.bz2", true, false, []string{"file"}, "", nil, }, { "multiple.tar.bz2", true, false, []string{"file1", "file2"}, "", nil, }, { "multiple.tar.bz2", false, true, nil, "", nil, }, // Tests when the file is listed before the parent folder { "ordering.tar.bz2", true, false, orderingPaths, "", nil, }, } for i, tc := range cases { cases[i].Input = filepath.Join("./test-fixtures", "decompress-tbz2", tc.Input) } TestDecompressor(t, new(TarBzip2Decompressor), cases) } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/decompress_testing.go000066400000000000000000000100721333721501700275060ustar00rootroot00000000000000package getter import ( "crypto/md5" "encoding/hex" "io" "io/ioutil" "os" "path/filepath" "reflect" "runtime" "sort" "strings" "time" "github.com/mitchellh/go-testing-interface" ) // 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) } // TestDecompressor is a helper function for testing generic decompressors. func TestDecompressor(t testing.T, d Decompressor, cases []TestDecompressCase) { for _, tc := range cases { t.Logf("Testing: %s", tc.Input) // Temporary dir to store stuff td, err := ioutil.TempDir("", "getter") if err != nil { t.Fatalf("err: %s", err) } // Destination is always joining result so that we have a new path dst := filepath.Join(td, "subdir", "result") // We use a function so defers work func() { defer os.RemoveAll(td) // Decompress err := d.Decompress(dst, tc.Input, tc.Dir) if (err != nil) != tc.Err { t.Fatalf("err %s: %s", tc.Input, err) } if tc.Err { return } // If it isn't a directory, then check for a single file if !tc.Dir { fi, err := os.Stat(dst) if err != nil { t.Fatalf("err %s: %s", tc.Input, err) } if fi.IsDir() { t.Fatalf("err %s: expected file, got directory", tc.Input) } if tc.FileMD5 != "" { actual := testMD5(t, dst) expected := tc.FileMD5 if actual != expected { t.Fatalf("err %s: expected MD5 %s, got %s", tc.Input, expected, actual) } } if tc.Mtime != nil { actual := fi.ModTime() 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()) } } return } // Convert expected for windows expected := tc.DirList if runtime.GOOS == "windows" { for i, v := range expected { expected[i] = strings.Replace(v, "/", "\\", -1) } } // Directory, check for the correct contents actual := testListDir(t, dst) if !reflect.DeepEqual(actual, expected) { t.Fatalf("bad %s\n\n%#v\n\n%#v", tc.Input, actual, expected) } // Check for correct atime/mtime for _, dir := range actual { path := filepath.Join(dst, dir) if tc.Mtime != nil { fi, err := os.Stat(path) if err != nil { t.Fatalf("err: %s", err) } actual := fi.ModTime() 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()) } } } }() } } func testListDir(t testing.T, path string) []string { var result []string err := filepath.Walk(path, func(sub string, info os.FileInfo, err error) error { if err != nil { return err } sub = strings.TrimPrefix(sub, path) if sub == "" { return nil } sub = sub[1:] // Trim the leading path sep. // If it is a dir, add trailing sep if info.IsDir() { sub += string(os.PathSeparator) } result = append(result, sub) return nil }) if err != nil { t.Fatalf("err: %s", err) } sort.Strings(result) return result } func testMD5(t testing.T, path string) string { f, err := os.Open(path) if err != nil { t.Fatalf("err: %s", err) } defer f.Close() h := md5.New() _, err = io.Copy(h, f) if err != nil { t.Fatalf("err: %s", err) } result := h.Sum(nil) return hex.EncodeToString(result) } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/decompress_tgz.go000066400000000000000000000014101333721501700266310ustar00rootroot00000000000000package getter import ( "compress/gzip" "fmt" "os" "path/filepath" ) // TarGzipDecompressor is an implementation of Decompressor that can // decompress tar.gzip files. type TarGzipDecompressor struct{} func (d *TarGzipDecompressor) Decompress(dst, src string, dir bool) error { // If we're going into a directory we should make that first mkdir := dst if !dir { mkdir = filepath.Dir(dst) } if err := os.MkdirAll(mkdir, 0755); err != nil { return err } // File first f, err := os.Open(src) if err != nil { return err } defer f.Close() // Gzip compression is second gzipR, err := gzip.NewReader(f) if err != nil { return fmt.Errorf("Error opening a gzip reader for %s: %s", src, err) } defer gzipR.Close() return untar(gzipR, dst, src, dir) } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/decompress_tgz_test.go000066400000000000000000000024031333721501700276730ustar00rootroot00000000000000package getter import ( "path/filepath" "testing" ) func TestTarGzipDecompressor(t *testing.T) { multiplePaths := []string{"dir/", "dir/test2", "test1"} orderingPaths := []string{"workers/", "workers/mq/", "workers/mq/__init__.py"} cases := []TestDecompressCase{ { "empty.tar.gz", false, true, nil, "", nil, }, { "single.tar.gz", false, false, nil, "d3b07384d113edec49eaa6238ad5ff00", nil, }, { "single.tar.gz", true, false, []string{"file"}, "", nil, }, { "multiple.tar.gz", true, false, []string{"file1", "file2"}, "", nil, }, { "multiple.tar.gz", false, true, nil, "", nil, }, { "multiple_dir.tar.gz", true, false, multiplePaths, "", nil, }, // Tests when the file is listed before the parent folder { "ordering.tar.gz", true, false, orderingPaths, "", nil, }, // Tests that a tar.gz can't contain references with "..". // GNU `tar` also disallows this. { "outside_parent.tar.gz", true, true, nil, "", nil, }, } for i, tc := range cases { cases[i].Input = filepath.Join("./test-fixtures", "decompress-tgz", tc.Input) } TestDecompressor(t, new(TarGzipDecompressor), cases) } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/decompress_txz.go000066400000000000000000000013571333721501700266640ustar00rootroot00000000000000package getter import ( "fmt" "os" "path/filepath" "github.com/ulikunitz/xz" ) // TarXzDecompressor is an implementation of Decompressor that can // decompress tar.xz files. type TarXzDecompressor struct{} func (d *TarXzDecompressor) Decompress(dst, src string, dir bool) error { // If we're going into a directory we should make that first mkdir := dst if !dir { mkdir = filepath.Dir(dst) } if err := os.MkdirAll(mkdir, 0755); err != nil { return err } // File first f, err := os.Open(src) if err != nil { return err } defer f.Close() // xz compression is second txzR, err := xz.NewReader(f) if err != nil { return fmt.Errorf("Error opening an xz reader for %s: %s", src, err) } return untar(txzR, dst, src, dir) } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/decompress_txz_test.go000066400000000000000000000021171333721501700277160ustar00rootroot00000000000000package getter import ( "path/filepath" "testing" ) func TestTarXzDecompressor(t *testing.T) { multiplePaths := []string{"dir/", "dir/test2", "test1"} orderingPaths := []string{"workers/", "workers/mq/", "workers/mq/__init__.py"} cases := []TestDecompressCase{ { "empty.tar.xz", false, true, nil, "", nil, }, { "single.tar.xz", false, false, nil, "d3b07384d113edec49eaa6238ad5ff00", nil, }, { "single.tar.xz", true, false, []string{"file"}, "", nil, }, { "multiple.tar.xz", true, false, []string{"file1", "file2"}, "", nil, }, { "multiple.tar.xz", false, true, nil, "", nil, }, { "multiple_dir.tar.xz", true, false, multiplePaths, "", nil, }, // Tests when the file is listed before the parent folder { "ordering.tar.xz", true, false, orderingPaths, "", nil, }, } for i, tc := range cases { cases[i].Input = filepath.Join("./test-fixtures", "decompress-txz", tc.Input) } TestDecompressor(t, new(TarXzDecompressor), cases) } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/decompress_xz.go000066400000000000000000000015541333721501700264770ustar00rootroot00000000000000package getter import ( "fmt" "io" "os" "path/filepath" "github.com/ulikunitz/xz" ) // XzDecompressor is an implementation of Decompressor that can // decompress xz files. type XzDecompressor struct{} func (d *XzDecompressor) Decompress(dst, src string, dir bool) error { // Directory isn't supported at all if dir { return fmt.Errorf("xz-compressed files can only unarchive to a single file") } // If we're going into a directory we should make that first if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil { return err } // File first f, err := os.Open(src) if err != nil { return err } defer f.Close() // xz compression is second xzR, err := xz.NewReader(f) if err != nil { return err } // Copy it out dstF, err := os.Create(dst) if err != nil { return err } defer dstF.Close() _, err = io.Copy(dstF, xzR) return err } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/decompress_xz_test.go000066400000000000000000000007151333721501700275340ustar00rootroot00000000000000package getter import ( "path/filepath" "testing" ) func TestXzDecompressor(t *testing.T) { cases := []TestDecompressCase{ { "single.xz", false, false, nil, "d3b07384d113edec49eaa6238ad5ff00", nil, }, { "single.xz", true, true, nil, "", nil, }, } for i, tc := range cases { cases[i].Input = filepath.Join("./test-fixtures", "decompress-xz", tc.Input) } TestDecompressor(t, new(XzDecompressor), cases) } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/decompress_zip.go000066400000000000000000000036511333721501700266400ustar00rootroot00000000000000package getter import ( "archive/zip" "fmt" "io" "os" "path/filepath" ) // ZipDecompressor is an implementation of Decompressor that can // decompress tar.gzip files. type ZipDecompressor struct{} func (d *ZipDecompressor) Decompress(dst, src string, dir bool) error { // If we're going into a directory we should make that first mkdir := dst if !dir { mkdir = filepath.Dir(dst) } if err := os.MkdirAll(mkdir, 0755); err != nil { return err } // Open the zip zipR, err := zip.OpenReader(src) if err != nil { return err } defer zipR.Close() // Check the zip integrity if len(zipR.File) == 0 { // Empty archive return fmt.Errorf("empty archive: %s", src) } if !dir && len(zipR.File) > 1 { return fmt.Errorf("expected a single file: %s", src) } // Go through and unarchive for _, f := range zipR.File { path := dst if dir { // Disallow parent traversal if containsDotDot(f.Name) { return fmt.Errorf("entry contains '..': %s", f.Name) } path = filepath.Join(path, f.Name) } if f.FileInfo().IsDir() { if !dir { return fmt.Errorf("expected a single file: %s", src) } // A directory, just make the directory and continue unarchiving... if err := os.MkdirAll(path, 0755); err != nil { return err } continue } // Create the enclosing directories if we must. ZIP files aren't // required to contain entries for just the directories so this // can happen. if dir { if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil { return err } } // Open the file for reading srcF, err := f.Open() if err != nil { return err } // Open the file for writing dstF, err := os.Create(path) if err != nil { srcF.Close() return err } _, err = io.Copy(dstF, srcF) srcF.Close() dstF.Close() if err != nil { return err } // Chmod the file if err := os.Chmod(path, f.Mode()); err != nil { return err } } return nil } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/decompress_zip_test.go000066400000000000000000000022331333721501700276720ustar00rootroot00000000000000package getter import ( "path/filepath" "testing" ) func TestZipDecompressor(t *testing.T) { cases := []TestDecompressCase{ { "empty.zip", false, true, nil, "", nil, }, { "single.zip", false, false, nil, "d3b07384d113edec49eaa6238ad5ff00", nil, }, { "single.zip", true, false, []string{"file"}, "", nil, }, { "multiple.zip", true, false, []string{"file1", "file2"}, "", nil, }, { "multiple.zip", false, true, nil, "", nil, }, { "subdir.zip", true, false, []string{"file1", "subdir/", "subdir/child"}, "", nil, }, { "subdir_empty.zip", true, false, []string{"file1", "subdir/"}, "", nil, }, { "subdir_missing_dir.zip", true, false, []string{"file1", "subdir/", "subdir/child"}, "", nil, }, // Tests that a zip can't contain references with "..". { "outside_parent.zip", true, true, nil, "", nil, }, } for i, tc := range cases { cases[i].Input = filepath.Join("./test-fixtures", "decompress-zip", tc.Input) } TestDecompressor(t, new(ZipDecompressor), cases) } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/detect.go000066400000000000000000000051511333721501700250570ustar00rootroot00000000000000package getter import ( "fmt" "path/filepath" "github.com/hashicorp/go-getter/helper/url" ) // Detector defines the interface that an invalid URL or a URL with a blank // scheme is passed through in order to determine if its shorthand for // something else well-known. type Detector interface { // Detect will detect whether the string matches a known pattern to // turn it into a proper URL. Detect(string, string) (string, bool, error) } // Detectors is the list of detectors that are tried on an invalid URL. // This is also the order they're tried (index 0 is first). var Detectors []Detector func init() { Detectors = []Detector{ new(GitHubDetector), new(BitBucketDetector), new(S3Detector), new(FileDetector), } } // Detect turns a source string into another source string if it is // detected to be of a known pattern. // // The third parameter should be the list of detectors to use in the // order to try them. If you don't want to configure this, just use // the global Detectors variable. // // This is safe to be called with an already valid source string: Detect // will just return it. func Detect(src string, pwd string, ds []Detector) (string, error) { getForce, getSrc := getForcedGetter(src) // Separate out the subdir if there is one, we don't pass that to detect getSrc, subDir := SourceDirSubdir(getSrc) u, err := url.Parse(getSrc) if err == nil && u.Scheme != "" { // Valid URL return src, nil } for _, d := range ds { result, ok, err := d.Detect(getSrc, pwd) if err != nil { return "", err } if !ok { continue } var detectForce string detectForce, result = getForcedGetter(result) result, detectSubdir := SourceDirSubdir(result) // If we have a subdir from the detection, then prepend it to our // requested subdir. if detectSubdir != "" { if subDir != "" { subDir = filepath.Join(detectSubdir, subDir) } else { subDir = detectSubdir } } if subDir != "" { u, err := url.Parse(result) if err != nil { return "", fmt.Errorf("Error parsing URL: %s", err) } u.Path += "//" + subDir // a subdir may contain wildcards, but in order to support them we // have to ensure the path isn't escaped. u.RawPath = u.Path result = u.String() } // Preserve the forced getter if it exists. We try to use the // original set force first, followed by any force set by the // detector. if getForce != "" { result = fmt.Sprintf("%s::%s", getForce, result) } else if detectForce != "" { result = fmt.Sprintf("%s::%s", detectForce, result) } return result, nil } return "", fmt.Errorf("invalid source string: %s", src) } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/detect_bitbucket.go000066400000000000000000000031401333721501700271070ustar00rootroot00000000000000package getter import ( "encoding/json" "fmt" "net/http" "net/url" "strings" ) // BitBucketDetector implements Detector to detect BitBucket URLs and turn // them into URLs that the Git or Hg Getter can understand. type BitBucketDetector struct{} func (d *BitBucketDetector) Detect(src, _ string) (string, bool, error) { if len(src) == 0 { return "", false, nil } if strings.HasPrefix(src, "bitbucket.org/") { return d.detectHTTP(src) } return "", false, nil } func (d *BitBucketDetector) detectHTTP(src string) (string, bool, error) { u, err := url.Parse("https://" + src) if err != nil { return "", true, fmt.Errorf("error parsing BitBucket URL: %s", err) } // We need to get info on this BitBucket repository to determine whether // it is Git or Hg. var info struct { SCM string `json:"scm"` } infoUrl := "https://api.bitbucket.org/1.0/repositories" + u.Path resp, err := http.Get(infoUrl) if err != nil { return "", true, fmt.Errorf("error looking up BitBucket URL: %s", err) } if resp.StatusCode == 403 { // A private repo return "", true, fmt.Errorf( "shorthand BitBucket URL can't be used for private repos, " + "please use a full URL") } dec := json.NewDecoder(resp.Body) if err := dec.Decode(&info); err != nil { return "", true, fmt.Errorf("error looking up BitBucket URL: %s", err) } switch info.SCM { case "git": if !strings.HasSuffix(u.Path, ".git") { u.Path += ".git" } return "git::" + u.String(), true, nil case "hg": return "hg::" + u.String(), true, nil default: return "", true, fmt.Errorf("unknown BitBucket SCM type: %s", info.SCM) } } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/detect_bitbucket_test.go000066400000000000000000000023171333721501700301530ustar00rootroot00000000000000package getter import ( "net/http" "strings" "testing" ) const testBBUrl = "https://bitbucket.org/hashicorp/tf-test-git" func TestBitBucketDetector(t *testing.T) { t.Parallel() if _, err := http.Get(testBBUrl); err != nil { t.Log("internet may not be working, skipping BB tests") t.Skip() } cases := []struct { Input string Output string }{ // HTTP { "bitbucket.org/hashicorp/tf-test-git", "git::https://bitbucket.org/hashicorp/tf-test-git.git", }, { "bitbucket.org/hashicorp/tf-test-git.git", "git::https://bitbucket.org/hashicorp/tf-test-git.git", }, { "bitbucket.org/hashicorp/tf-test-hg", "hg::https://bitbucket.org/hashicorp/tf-test-hg", }, } pwd := "/pwd" f := new(BitBucketDetector) for i, tc := range cases { var err error for i := 0; i < 3; i++ { var output string var ok bool output, ok, err = f.Detect(tc.Input, pwd) if err != nil { if strings.Contains(err.Error(), "invalid character") { continue } t.Fatalf("err: %s", err) } if !ok { t.Fatal("not ok") } if output != tc.Output { t.Fatalf("%d: bad: %#v", i, output) } break } if i >= 3 { t.Fatalf("failure from bitbucket: %s", err) } } } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/detect_file.go000066400000000000000000000030541333721501700260560ustar00rootroot00000000000000package getter import ( "fmt" "os" "path/filepath" "runtime" ) // FileDetector implements Detector to detect file paths. type FileDetector struct{} func (d *FileDetector) Detect(src, pwd string) (string, bool, error) { if len(src) == 0 { return "", false, nil } if !filepath.IsAbs(src) { if pwd == "" { return "", true, fmt.Errorf( "relative paths require a module with a pwd") } // Stat the pwd to determine if its a symbolic link. If it is, // then the pwd becomes the original directory. Otherwise, // `filepath.Join` below does some weird stuff. // // We just ignore if the pwd doesn't exist. That error will be // caught later when we try to use the URL. if fi, err := os.Lstat(pwd); !os.IsNotExist(err) { if err != nil { return "", true, err } if fi.Mode()&os.ModeSymlink != 0 { pwd, err = filepath.EvalSymlinks(pwd) if err != nil { return "", true, err } // The symlink itself might be a relative path, so we have to // resolve this to have a correctly rooted URL. pwd, err = filepath.Abs(pwd) if err != nil { return "", true, err } } } src = filepath.Join(pwd, src) } return fmtFileURL(src), true, nil } func fmtFileURL(path string) string { if runtime.GOOS == "windows" { // Make sure we're using "/" on Windows. URLs are "/"-based. path = filepath.ToSlash(path) return fmt.Sprintf("file://%s", path) } // Make sure that we don't start with "/" since we add that below. if path[0] == '/' { path = path[1:] } return fmt.Sprintf("file:///%s", path) } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/detect_file_test.go000066400000000000000000000050251333721501700271150ustar00rootroot00000000000000package getter import ( "fmt" "os" "path/filepath" "runtime" "strings" "testing" ) type fileTest struct { in, pwd, out string err bool } var fileTests = []fileTest{ {"./foo", "/pwd", "file:///pwd/foo", false}, {"./foo?foo=bar", "/pwd", "file:///pwd/foo?foo=bar", false}, {"foo", "/pwd", "file:///pwd/foo", false}, } var unixFileTests = []fileTest{ {"./foo", "test-fixtures/detect-file-symlink-pwd/syml/pwd", "test-fixtures/detect-file-symlink-pwd/real/foo", false}, {"/foo", "/pwd", "file:///foo", false}, {"/foo?bar=baz", "/pwd", "file:///foo?bar=baz", false}, } var winFileTests = []fileTest{ {"/foo", "/pwd", "file:///pwd/foo", false}, {`C:\`, `/pwd`, `file://C:/`, false}, {`C:\?bar=baz`, `/pwd`, `file://C:/?bar=baz`, false}, } func TestFileDetector(t *testing.T) { if runtime.GOOS == "windows" { fileTests = append(fileTests, winFileTests...) } else { fileTests = append(fileTests, unixFileTests...) } // Get the pwd pwdRoot, err := os.Getwd() if err != nil { t.Fatalf("err: %s", err) } pwdRoot, err = filepath.Abs(pwdRoot) if err != nil { t.Fatalf("err: %s", err) } f := new(FileDetector) for i, tc := range fileTests { t.Run(fmt.Sprintf("%d", i), func(t *testing.T) { pwd := tc.pwd if !filepath.IsAbs(pwd) { pwd = filepath.Join(pwdRoot, pwd) } out, ok, err := f.Detect(tc.in, pwd) if err != nil { t.Fatalf("err: %s", err) } if !ok { t.Fatal("not ok") } expected := tc.out if !strings.HasPrefix(expected, "file://") { expected = "file://" + filepath.Join(pwdRoot, expected) } if out != expected { t.Fatalf("input: %q\npwd: %q\nexpected: %q\nbad output: %#v", tc.in, pwd, expected, out) } }) } } var noPwdFileTests = []fileTest{ {in: "./foo", pwd: "", out: "", err: true}, {in: "foo", pwd: "", out: "", err: true}, } var noPwdUnixFileTests = []fileTest{ {in: "/foo", pwd: "", out: "file:///foo", err: false}, } var noPwdWinFileTests = []fileTest{ {in: "/foo", pwd: "", out: "", err: true}, {in: `C:\`, pwd: ``, out: `file://C:/`, err: false}, } func TestFileDetector_noPwd(t *testing.T) { if runtime.GOOS == "windows" { noPwdFileTests = append(noPwdFileTests, noPwdWinFileTests...) } else { noPwdFileTests = append(noPwdFileTests, noPwdUnixFileTests...) } f := new(FileDetector) for i, tc := range noPwdFileTests { out, ok, err := f.Detect(tc.in, tc.pwd) if err != nil != tc.err { t.Fatalf("%d: err: %s", i, err) } if !ok { t.Fatal("not ok") } if out != tc.out { t.Fatalf("%d: bad: %#v", i, out) } } } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/detect_file_unix_test.go000066400000000000000000000026021333721501700301560ustar00rootroot00000000000000// +build test unix package getter import ( "io/ioutil" "os" "path/filepath" "testing" ) // If a relative symlink is passed in as the pwd to Detect, the resulting URL // can have an invalid path. func TestFileDetector_relativeSymlink(t *testing.T) { tmpDir, err := ioutil.TempDir("", "go-getter") if err != nil { t.Fatal(err) } defer os.RemoveAll(tmpDir) // We may have a symlinked tmp dir, // e.g. OSX uses /var -> /private/var tmpDir, err = filepath.EvalSymlinks(tmpDir) if err != nil { t.Fatal(err) } err = os.Mkdir(filepath.Join(tmpDir, "realPWD"), 0755) if err != nil { t.Fatal(err) } subdir := filepath.Join(tmpDir, "subdir") err = os.Mkdir(subdir, 0755) if err != nil { t.Fatal(err) } prevDir, err := os.Getwd() if err != nil { t.Fatal(err) } defer os.Chdir(prevDir) err = os.Chdir(subdir) if err != nil { t.Fatal(err) } err = os.Symlink("../realPWD", "linkedPWD") if err != nil { t.Fatal(err) } // if detech doesn't fully resolve the pwd symlink, the output will be the // invalid path: "file:///../modules/foo" f := new(FileDetector) out, ok, err := f.Detect("../modules/foo", "./linkedPWD") if err != nil { t.Fatalf("err: %v", err) } if !ok { t.Fatal("not ok") } if out != "file://"+filepath.Join(tmpDir, "modules/foo") { t.Logf("expected: %v", "file://"+filepath.Join(tmpDir, "modules/foo")) t.Fatalf("bad: %v", out) } } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/detect_github.go000066400000000000000000000031201333721501700264130ustar00rootroot00000000000000package getter import ( "fmt" "net/url" "strings" ) // GitHubDetector implements Detector to detect GitHub URLs and turn // them into URLs that the Git Getter can understand. type GitHubDetector struct{} func (d *GitHubDetector) Detect(src, _ string) (string, bool, error) { if len(src) == 0 { return "", false, nil } 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 } func (d *GitHubDetector) detectHTTP(src string) (string, bool, error) { parts := strings.Split(src, "/") if len(parts) < 3 { return "", false, fmt.Errorf( "GitHub URLs should be github.com/username/repo") } urlStr := fmt.Sprintf("https://%s", strings.Join(parts[:3], "/")) url, err := url.Parse(urlStr) if err != nil { return "", true, fmt.Errorf("error parsing GitHub URL: %s", err) } if !strings.HasSuffix(url.Path, ".git") { url.Path += ".git" } if len(parts) > 3 { url.Path += "//" + strings.Join(parts[3:], "/") } 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 } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/detect_github_test.go000066400000000000000000000022741333721501700274630ustar00rootroot00000000000000package getter import ( "testing" ) func TestGitHubDetector(t *testing.T) { cases := []struct { Input string Output string }{ // HTTP {"github.com/hashicorp/foo", "git::https://github.com/hashicorp/foo.git"}, {"github.com/hashicorp/foo.git", "git::https://github.com/hashicorp/foo.git"}, { "github.com/hashicorp/foo/bar", "git::https://github.com/hashicorp/foo.git//bar", }, { "github.com/hashicorp/foo?foo=bar", "git::https://github.com/hashicorp/foo.git?foo=bar", }, { "github.com/hashicorp/foo.git?foo=bar", "git::https://github.com/hashicorp/foo.git?foo=bar", }, // SSH {"git@github.com:hashicorp/foo.git", "git::ssh://git@github.com/hashicorp/foo.git"}, { "git@github.com:hashicorp/foo.git//bar", "git::ssh://git@github.com/hashicorp/foo.git//bar", }, { "git@github.com:hashicorp/foo.git?foo=bar", "git::ssh://git@github.com/hashicorp/foo.git?foo=bar", }, } pwd := "/pwd" f := new(GitHubDetector) for i, tc := range cases { output, ok, err := f.Detect(tc.Input, pwd) if err != nil { t.Fatalf("err: %s", err) } if !ok { t.Fatal("not ok") } if output != tc.Output { t.Fatalf("%d: bad: %#v", i, output) } } } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/detect_s3.go000066400000000000000000000031071333721501700254630ustar00rootroot00000000000000package getter import ( "fmt" "net/url" "strings" ) // S3Detector implements Detector to detect S3 URLs and turn // them into URLs that the S3 getter can understand. type S3Detector struct{} func (d *S3Detector) Detect(src, _ string) (string, bool, error) { if len(src) == 0 { return "", false, nil } if strings.Contains(src, ".amazonaws.com/") { return d.detectHTTP(src) } return "", false, nil } func (d *S3Detector) detectHTTP(src string) (string, bool, error) { parts := strings.Split(src, "/") if len(parts) < 2 { return "", false, fmt.Errorf( "URL is not a valid S3 URL") } hostParts := strings.Split(parts[0], ".") if len(hostParts) == 3 { return d.detectPathStyle(hostParts[0], parts[1:]) } else if len(hostParts) == 4 { return d.detectVhostStyle(hostParts[1], hostParts[0], parts[1:]) } else { return "", false, fmt.Errorf( "URL is not a valid S3 URL") } } func (d *S3Detector) detectPathStyle(region string, parts []string) (string, bool, error) { urlStr := fmt.Sprintf("https://%s.amazonaws.com/%s", region, strings.Join(parts, "/")) url, err := url.Parse(urlStr) if err != nil { return "", false, fmt.Errorf("error parsing S3 URL: %s", err) } return "s3::" + url.String(), true, nil } func (d *S3Detector) detectVhostStyle(region, bucket string, parts []string) (string, bool, error) { urlStr := fmt.Sprintf("https://%s.amazonaws.com/%s/%s", region, bucket, strings.Join(parts, "/")) url, err := url.Parse(urlStr) if err != nil { return "", false, fmt.Errorf("error parsing S3 URL: %s", err) } return "s3::" + url.String(), true, nil } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/detect_s3_test.go000066400000000000000000000035551333721501700265310ustar00rootroot00000000000000package getter import ( "testing" ) func TestS3Detector(t *testing.T) { cases := []struct { Input string Output string }{ // Virtual hosted style { "bucket.s3.amazonaws.com/foo", "s3::https://s3.amazonaws.com/bucket/foo", }, { "bucket.s3.amazonaws.com/foo/bar", "s3::https://s3.amazonaws.com/bucket/foo/bar", }, { "bucket.s3.amazonaws.com/foo/bar.baz", "s3::https://s3.amazonaws.com/bucket/foo/bar.baz", }, { "bucket.s3-eu-west-1.amazonaws.com/foo", "s3::https://s3-eu-west-1.amazonaws.com/bucket/foo", }, { "bucket.s3-eu-west-1.amazonaws.com/foo/bar", "s3::https://s3-eu-west-1.amazonaws.com/bucket/foo/bar", }, { "bucket.s3-eu-west-1.amazonaws.com/foo/bar.baz", "s3::https://s3-eu-west-1.amazonaws.com/bucket/foo/bar.baz", }, // Path style { "s3.amazonaws.com/bucket/foo", "s3::https://s3.amazonaws.com/bucket/foo", }, { "s3.amazonaws.com/bucket/foo/bar", "s3::https://s3.amazonaws.com/bucket/foo/bar", }, { "s3.amazonaws.com/bucket/foo/bar.baz", "s3::https://s3.amazonaws.com/bucket/foo/bar.baz", }, { "s3-eu-west-1.amazonaws.com/bucket/foo", "s3::https://s3-eu-west-1.amazonaws.com/bucket/foo", }, { "s3-eu-west-1.amazonaws.com/bucket/foo/bar", "s3::https://s3-eu-west-1.amazonaws.com/bucket/foo/bar", }, { "s3-eu-west-1.amazonaws.com/bucket/foo/bar.baz", "s3::https://s3-eu-west-1.amazonaws.com/bucket/foo/bar.baz", }, // Misc tests { "s3-eu-west-1.amazonaws.com/bucket/foo/bar.baz?version=1234", "s3::https://s3-eu-west-1.amazonaws.com/bucket/foo/bar.baz?version=1234", }, } pwd := "/pwd" f := new(S3Detector) for i, tc := range cases { output, ok, err := f.Detect(tc.Input, pwd) if err != nil { t.Fatalf("err: %s", err) } if !ok { t.Fatal("not ok") } if output != tc.Output { t.Fatalf("%d: bad: %#v", i, output) } } } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/detect_test.go000066400000000000000000000020221333721501700261100ustar00rootroot00000000000000package getter import ( "testing" ) func TestDetect(t *testing.T) { cases := []struct { Input string Pwd string Output string Err bool }{ {"./foo", "/foo", "file:///foo/foo", false}, {"git::./foo", "/foo", "git::file:///foo/foo", false}, { "git::github.com/hashicorp/foo", "", "git::https://github.com/hashicorp/foo.git", false, }, { "./foo//bar", "/foo", "file:///foo/foo//bar", false, }, { "git::github.com/hashicorp/foo//bar", "", "git::https://github.com/hashicorp/foo.git//bar", false, }, { "git::https://github.com/hashicorp/consul.git", "", "git::https://github.com/hashicorp/consul.git", false, }, { "./foo/archive//*", "/bar", "file:///bar/foo/archive//*", false, }, } for i, tc := range cases { output, err := Detect(tc.Input, tc.Pwd, Detectors) if err != nil != tc.Err { t.Fatalf("%d: bad err: %s", i, err) } if output != tc.Output { t.Fatalf("%d: bad output: %s\nexpected: %s", i, output, tc.Output) } } } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/folder_storage.go000066400000000000000000000026611333721501700266110ustar00rootroot00000000000000package getter import ( "crypto/md5" "encoding/hex" "fmt" "os" "path/filepath" ) // FolderStorage is an implementation of the Storage interface that manages // modules on the disk. type FolderStorage struct { // StorageDir is the directory where the modules will be stored. StorageDir string } // Dir implements Storage.Dir func (s *FolderStorage) Dir(key string) (d string, e bool, err error) { d = s.dir(key) _, err = os.Stat(d) if err == nil { // Directory exists e = true return } if os.IsNotExist(err) { // Directory doesn't exist d = "" e = false err = nil return } // An error d = "" e = false return } // Get implements Storage.Get func (s *FolderStorage) Get(key string, source string, update bool) error { dir := s.dir(key) if !update { if _, err := os.Stat(dir); err == nil { // If the directory already exists, then we're done since // we're not updating. return nil } else if !os.IsNotExist(err) { // If the error we got wasn't a file-not-exist error, then // something went wrong and we should report it. return fmt.Errorf("Error reading module directory: %s", err) } } // Get the source. This always forces an update. return Get(dir, source) } // dir returns the directory name internally that we'll use to map to // internally. func (s *FolderStorage) dir(key string) string { sum := md5.Sum([]byte(key)) return filepath.Join(s.StorageDir, hex.EncodeToString(sum[:])) } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/folder_storage_test.go000066400000000000000000000014361333721501700276470ustar00rootroot00000000000000package getter import ( "os" "path/filepath" "testing" ) func TestFolderStorage_impl(t *testing.T) { var _ Storage = new(FolderStorage) } func TestFolderStorage(t *testing.T) { s := &FolderStorage{StorageDir: tempDir(t)} module := testModule("basic") // A module shouldn't exist at first... _, ok, err := s.Dir(module) if err != nil { t.Fatalf("err: %s", err) } if ok { t.Fatal("should not exist") } key := "foo" // We can get it err = s.Get(key, module, false) if err != nil { t.Fatalf("err: %s", err) } // Now the module exists dir, ok, err := s.Dir(key) if err != nil { t.Fatalf("err: %s", err) } if !ok { t.Fatal("should exist") } mainPath := filepath.Join(dir, "main.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/get.go000066400000000000000000000100711333721501700243630ustar00rootroot00000000000000// getter is a package for downloading files or directories from a variety of // protocols. // // getter is unique in its ability to download both directories and files. // It also detects certain source strings to be protocol-specific URLs. For // example, "github.com/hashicorp/go-getter" would turn into a Git URL and // use the Git protocol. // // Protocols and detectors are extensible. // // To get started, see Client. package getter import ( "bytes" "fmt" "net/url" "os/exec" "regexp" "syscall" cleanhttp "github.com/hashicorp/go-cleanhttp" ) // Getter defines the interface that schemes must implement to download // things. type Getter interface { // Get downloads the given URL into the given directory. This always // assumes that we're updating and gets the latest version that it can. // // The directory may already exist (if we're updating). If it is in a // format that isn't understood, an error should be returned. Get shouldn't // simply nuke the directory. Get(string, *url.URL) error // GetFile downloads the give URL into the given path. The URL must // reference a single file. If possible, the Getter should check if // the remote end contains the same file and no-op this operation. GetFile(string, *url.URL) error // 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) } // Getters is the mapping of scheme to the Getter implementation that will // be used to get a dependency. var Getters map[string]Getter // forcedRegexp is the regular expression that finds forced getters. This // syntax is schema::url, example: git::https://foo.com var forcedRegexp = regexp.MustCompile(`^([A-Za-z0-9]+)::(.+)$`) // httpClient is the default client to be used by HttpGetters. var httpClient = cleanhttp.DefaultClient() func init() { httpGetter := &HttpGetter{ Netrc: true, } Getters = map[string]Getter{ "file": new(FileGetter), "git": new(GitGetter), "hg": new(HgGetter), "s3": new(S3Getter), "http": httpGetter, "https": httpGetter, } } // Get downloads the directory specified by src into the folder specified by // dst. If dst already exists, Get will attempt to update it. // // 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 { return (&Client{ Src: src, Dst: dst, Dir: true, Getters: Getters, }).Get() } // GetAny downloads a URL into the given destination. Unlike Get or // GetFile, both directories and files are supported. // // 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 { return (&Client{ Src: src, Dst: dst, Mode: ClientModeAny, Getters: Getters, }).Get() } // GetFile downloads the file specified by src into the path specified by // dst. func GetFile(dst, src string) error { return (&Client{ Src: src, Dst: dst, Dir: false, Getters: Getters, }).Get() } // getRunCommand is a helper that will run a command and capture the output // in the case an error happens. func getRunCommand(cmd *exec.Cmd) error { var buf bytes.Buffer cmd.Stdout = &buf cmd.Stderr = &buf err := cmd.Run() if err == nil { return nil } if exiterr, ok := err.(*exec.ExitError); ok { // The program has exited with an exit code != 0 if status, ok := exiterr.Sys().(syscall.WaitStatus); ok { return fmt.Errorf( "%s exited with %d: %s", cmd.Path, status.ExitStatus(), buf.String()) } } return fmt.Errorf("error running %s: %s", cmd.Path, buf.String()) } // getForcedGetter takes a source and returns the tuple of the forced // getter and the raw URL (without the force syntax). func getForcedGetter(src string) (string, string) { var forced string if ms := forcedRegexp.FindStringSubmatch(src); ms != nil { forced = ms[1] src = ms[2] } return forced, src } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/get_file.go000066400000000000000000000010511333721501700253600ustar00rootroot00000000000000package getter import ( "net/url" "os" ) // 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 Copy bool } func (g *FileGetter) ClientMode(u *url.URL) (ClientMode, error) { path := u.Path if u.RawPath != "" { path = u.RawPath } fi, err := os.Stat(path) if err != nil { return 0, err } // Check if the source is a directory. if fi.IsDir() { return ClientModeDir, nil } return ClientModeFile, nil } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/get_file_test.go000066400000000000000000000105271333721501700264270ustar00rootroot00000000000000package getter import ( "os" "path/filepath" "testing" ) func TestFileGetter_impl(t *testing.T) { var _ Getter = new(FileGetter) } func TestFileGetter(t *testing.T) { g := new(FileGetter) dst := tempDir(t) // With a dir that doesn't exist if err := g.Get(dst, testModuleURL("basic")); err != nil { t.Fatalf("err: %s", err) } // Verify the destination folder is a symlink fi, err := os.Lstat(dst) if err != nil { t.Fatalf("err: %s", err) } if fi.Mode()&os.ModeSymlink == 0 { t.Fatal("destination is not a symlink") } // Verify the main file exists mainPath := filepath.Join(dst, "main.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestFileGetter_sourceFile(t *testing.T) { g := new(FileGetter) dst := tempDir(t) // With a source URL that is a path to a file u := testModuleURL("basic") u.Path += "/main.tf" if err := g.Get(dst, u); err == nil { t.Fatal("should error") } } func TestFileGetter_sourceNoExist(t *testing.T) { g := new(FileGetter) dst := tempDir(t) // With a source URL that doesn't exist u := testModuleURL("basic") u.Path += "/main" if err := g.Get(dst, u); err == nil { t.Fatal("should error") } } func TestFileGetter_dir(t *testing.T) { g := new(FileGetter) dst := tempDir(t) if err := os.MkdirAll(dst, 0755); err != nil { t.Fatalf("err: %s", err) } // With a dir that exists that isn't a symlink if err := g.Get(dst, testModuleURL("basic")); err == nil { t.Fatal("should error") } } func TestFileGetter_dirSymlink(t *testing.T) { g := new(FileGetter) dst := tempDir(t) dst2 := tempDir(t) // Make parents if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil { t.Fatalf("err: %s", err) } if err := os.MkdirAll(dst2, 0755); err != nil { t.Fatalf("err: %s", err) } // Make a symlink if err := os.Symlink(dst2, dst); err != nil { t.Fatalf("err: %s", err) } // With a dir that exists that isn't a symlink if err := g.Get(dst, testModuleURL("basic")); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists mainPath := filepath.Join(dst, "main.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestFileGetter_GetFile(t *testing.T) { g := new(FileGetter) dst := tempFile(t) // With a dir that doesn't exist if err := g.GetFile(dst, testModuleURL("basic-file/foo.txt")); err != nil { t.Fatalf("err: %s", err) } // Verify the destination folder is a symlink fi, err := os.Lstat(dst) if err != nil { t.Fatalf("err: %s", err) } if fi.Mode()&os.ModeSymlink == 0 { t.Fatal("destination is not a symlink") } // Verify the main file exists assertContents(t, dst, "Hello\n") } func TestFileGetter_GetFile_Copy(t *testing.T) { g := new(FileGetter) g.Copy = true dst := tempFile(t) // With a dir that doesn't exist if err := g.GetFile(dst, testModuleURL("basic-file/foo.txt")); err != nil { t.Fatalf("err: %s", err) } // Verify the destination folder is a symlink fi, err := os.Lstat(dst) if err != nil { t.Fatalf("err: %s", err) } if fi.Mode()&os.ModeSymlink != 0 { t.Fatal("destination is a symlink") } // Verify the main file exists assertContents(t, dst, "Hello\n") } // https://github.com/hashicorp/terraform/issues/8418 func TestFileGetter_percent2F(t *testing.T) { g := new(FileGetter) dst := tempDir(t) // With a dir that doesn't exist if err := g.Get(dst, testModuleURL("basic%2Ftest")); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists mainPath := filepath.Join(dst, "main.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestFileGetter_ClientMode_notexist(t *testing.T) { g := new(FileGetter) u := testURL("nonexistent") if _, err := g.ClientMode(u); err == nil { t.Fatal("expect source file error") } } func TestFileGetter_ClientMode_file(t *testing.T) { g := new(FileGetter) // Check the client mode when pointed at a file. mode, err := g.ClientMode(testModuleURL("basic-file/foo.txt")) if err != nil { t.Fatalf("err: %s", err) } if mode != ClientModeFile { t.Fatal("expect ClientModeFile") } } func TestFileGetter_ClientMode_dir(t *testing.T) { g := new(FileGetter) // Check the client mode when pointed at a directory. mode, err := g.ClientMode(testModuleURL("basic")) if err != nil { t.Fatalf("err: %s", err) } if mode != ClientModeDir { t.Fatal("expect ClientModeDir") } } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/get_file_unix.go000066400000000000000000000037401333721501700264320ustar00rootroot00000000000000// +build !windows package getter import ( "fmt" "io" "net/url" "os" "path/filepath" ) func (g *FileGetter) Get(dst string, u *url.URL) error { path := u.Path if u.RawPath != "" { path = u.RawPath } // The source path must exist and be a directory to be usable. if fi, err := os.Stat(path); err != nil { return fmt.Errorf("source path error: %s", err) } else if !fi.IsDir() { return fmt.Errorf("source path must be a directory") } fi, err := os.Lstat(dst) if err != nil && !os.IsNotExist(err) { return err } // If the destination already exists, it must be a symlink if err == nil { mode := fi.Mode() if mode&os.ModeSymlink == 0 { return fmt.Errorf("destination exists and is not a symlink") } // Remove the destination if err := os.Remove(dst); err != nil { return err } } // Create all the parent directories if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil { return err } return os.Symlink(path, dst) } func (g *FileGetter) GetFile(dst string, u *url.URL) error { path := u.Path if u.RawPath != "" { path = u.RawPath } // The source path must exist and be a file to be usable. if fi, err := os.Stat(path); err != nil { return fmt.Errorf("source path error: %s", err) } else if fi.IsDir() { return fmt.Errorf("source path must be a file") } _, err := os.Lstat(dst) if err != nil && !os.IsNotExist(err) { return err } // If the destination already exists, it must be a symlink if err == nil { // Remove the destination if err := os.Remove(dst); err != nil { return err } } // Create all the parent directories if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil { return err } // If we're not copying, just symlink and we're done if !g.Copy { return os.Symlink(path, dst) } // Copy srcF, err := os.Open(path) if err != nil { return err } defer srcF.Close() dstF, err := os.Create(dst) if err != nil { return err } defer dstF.Close() _, err = io.Copy(dstF, srcF) return err } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/get_file_windows.go000066400000000000000000000050011333721501700271310ustar00rootroot00000000000000// +build windows package getter import ( "fmt" "io" "net/url" "os" "os/exec" "path/filepath" "strings" ) func (g *FileGetter) Get(dst string, u *url.URL) error { path := u.Path if u.RawPath != "" { path = u.RawPath } // The source path must exist and be a directory to be usable. if fi, err := os.Stat(path); err != nil { return fmt.Errorf("source path error: %s", err) } else if !fi.IsDir() { return fmt.Errorf("source path must be a directory") } fi, err := os.Lstat(dst) if err != nil && !os.IsNotExist(err) { return err } // If the destination already exists, it must be a symlink if err == nil { mode := fi.Mode() if mode&os.ModeSymlink == 0 { return fmt.Errorf("destination exists and is not a symlink") } // Remove the destination if err := os.Remove(dst); err != nil { return err } } // Create all the parent directories if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil { return err } sourcePath := toBackslash(path) // Use mklink to create a junction point output, err := exec.Command("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) } return nil } func (g *FileGetter) GetFile(dst string, u *url.URL) error { path := u.Path if u.RawPath != "" { path = u.RawPath } // The source path must exist and be a directory to be usable. if fi, err := os.Stat(path); err != nil { return fmt.Errorf("source path error: %s", err) } else if fi.IsDir() { return fmt.Errorf("source path must be a file") } _, err := os.Lstat(dst) if err != nil && !os.IsNotExist(err) { return err } // If the destination already exists, it must be a symlink if err == nil { // Remove the destination if err := os.Remove(dst); err != nil { return err } } // Create all the parent directories if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil { return err } // If we're not copying, just symlink and we're done if !g.Copy { return os.Symlink(path, dst) } // Copy srcF, err := os.Open(path) if err != nil { return err } defer srcF.Close() dstF, err := os.Create(dst) if err != nil { return err } defer dstF.Close() _, err = io.Copy(dstF, srcF) return err } // toBackslash returns the result of replacing each slash character // in path with a backslash ('\') character. Multiple separators are // replaced by multiple backslashes. func toBackslash(path string) string { return strings.Replace(path, "/", "\\", -1) } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/get_git.go000066400000000000000000000134111333721501700252270ustar00rootroot00000000000000package getter import ( "encoding/base64" "fmt" "io/ioutil" "net/url" "os" "os/exec" "path/filepath" "strings" urlhelper "github.com/hashicorp/go-getter/helper/url" "github.com/hashicorp/go-safetemp" "github.com/hashicorp/go-version" ) // GitGetter is a Getter implementation that will download a module from // a git repository. type GitGetter struct{} func (g *GitGetter) ClientMode(_ *url.URL) (ClientMode, error) { return ClientModeDir, nil } func (g *GitGetter) Get(dst string, u *url.URL) error { if _, err := exec.LookPath("git"); err != nil { return fmt.Errorf("git must be available and on the PATH") } // Extract some query parameters we use var ref, sshKey string q := u.Query() if len(q) > 0 { ref = q.Get("ref") q.Del("ref") sshKey = q.Get("sshkey") q.Del("sshkey") // Copy the URL var newU url.URL = *u u = &newU u.RawQuery = q.Encode() } var sshKeyFile string if sshKey != "" { // Check that the git version is sufficiently new. if err := checkGitVersion("2.3"); err != nil { return fmt.Errorf("Error using ssh key: %v", err) } // We have an SSH key - decode it. raw, err := base64.StdEncoding.DecodeString(sshKey) if err != nil { return err } // Create a temp file for the key and ensure it is removed. fh, err := ioutil.TempFile("", "go-getter") if err != nil { return err } sshKeyFile = fh.Name() defer os.Remove(sshKeyFile) // Set the permissions prior to writing the key material. if err := os.Chmod(sshKeyFile, 0600); err != nil { return err } // Write the raw key into the temp file. _, err = fh.Write(raw) fh.Close() if err != nil { return err } } // Clone or update the repository _, err := os.Stat(dst) if err != nil && !os.IsNotExist(err) { return err } if err == nil { err = g.update(dst, sshKeyFile, ref) } else { err = g.clone(dst, sshKeyFile, u) } if err != nil { return err } // Next: check out the proper tag/branch if it is specified, and checkout if ref != "" { if err := g.checkout(dst, ref); err != nil { return err } } // Lastly, download any/all submodules. return g.fetchSubmodules(dst, sshKeyFile) } // GetFile for Git doesn't support updating at this time. It will download // the file every time. func (g *GitGetter) GetFile(dst string, u *url.URL) error { td, tdcloser, err := safetemp.Dir("", "getter") if err != nil { return err } defer tdcloser.Close() // Get the filename, and strip the filename from the URL so we can // just get the repository directly. filename := filepath.Base(u.Path) u.Path = filepath.Dir(u.Path) // Get the full repository if err := g.Get(td, u); err != nil { return err } // Copy the single file u, err = urlhelper.Parse(fmtFileURL(filepath.Join(td, filename))) if err != nil { return err } fg := &FileGetter{Copy: true} return fg.GetFile(dst, u) } func (g *GitGetter) checkout(dst string, ref string) error { cmd := exec.Command("git", "checkout", ref) cmd.Dir = dst return getRunCommand(cmd) } func (g *GitGetter) clone(dst, sshKeyFile string, u *url.URL) error { cmd := exec.Command("git", "clone", u.String(), dst) setupGitEnv(cmd, sshKeyFile) return getRunCommand(cmd) } func (g *GitGetter) update(dst, sshKeyFile, ref string) 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.Dir = dst if getRunCommand(cmd) != nil { // Not a branch, switch to master. This will also catch non-existent // branches, in which case we want to switch to master and then // checkout the proper branch later. ref = "master" } // We have to be on a branch to pull if err := g.checkout(dst, ref); err != nil { return err } 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") cmd.Dir = dst setupGitEnv(cmd, sshKeyFile) return getRunCommand(cmd) } // setupGitEnv sets up the environment for the given command. This is used to // pass configuration data to git and ssh and enables advanced cloning methods. func setupGitEnv(cmd *exec.Cmd, sshKeyFile string) { const gitSSHCommand = "GIT_SSH_COMMAND=" var sshCmd []string // If we have an existing GIT_SSH_COMMAND, we need to append our options. // We will also remove our old entry to make sure the behavior is the same // with versions of Go < 1.9. env := os.Environ() for i, v := range env { if strings.HasPrefix(v, gitSSHCommand) { sshCmd = []string{v} env[i], env[len(env)-1] = env[len(env)-1], env[i] env = env[:len(env)-1] break } } if len(sshCmd) == 0 { sshCmd = []string{gitSSHCommand + "ssh"} } if sshKeyFile != "" { // We have an SSH key temp file configured, tell ssh about this. sshCmd = append(sshCmd, "-i", sshKeyFile) } env = append(env, strings.Join(sshCmd, " ")) cmd.Env = env } // checkGitVersion is used to check the version of git installed on the system // against a known minimum version. Returns an error if the installed version // is older than the given minimum. func checkGitVersion(min string) error { want, err := version.NewVersion(min) if err != nil { return err } out, err := exec.Command("git", "version").Output() if err != nil { return err } fields := strings.Fields(string(out)) if len(fields) < 3 { return fmt.Errorf("Unexpected 'git version' output: %q", string(out)) } have, err := version.NewVersion(fields[2]) if err != nil { return err } if have.LessThan(want) { return fmt.Errorf("Required git version = %s, have %s", want, have) } return nil } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/get_git_test.go000066400000000000000000000242541333721501700262750ustar00rootroot00000000000000package getter import ( "encoding/base64" "io/ioutil" "net/url" "os" "os/exec" "path/filepath" "runtime" "strings" "testing" ) var testHasGit bool func init() { if _, err := exec.LookPath("git"); err == nil { testHasGit = true } } func TestGitGetter_impl(t *testing.T) { var _ Getter = new(GitGetter) } func TestGitGetter(t *testing.T) { if !testHasGit { t.Log("git not found, skipping") t.Skip() } g := new(GitGetter) dst := tempDir(t) repo := testGitRepo(t, "basic") repo.commitFile("foo.txt", "hello") // With a dir that doesn't exist if err := g.Get(dst, repo.url); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists mainPath := filepath.Join(dst, "foo.txt") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestGitGetter_branch(t *testing.T) { if !testHasGit { t.Log("git not found, skipping") t.Skip() } g := new(GitGetter) dst := tempDir(t) repo := testGitRepo(t, "branch") repo.git("checkout", "-b", "test-branch") repo.commitFile("branch.txt", "branch") q := repo.url.Query() q.Add("ref", "test-branch") repo.url.RawQuery = q.Encode() if err := g.Get(dst, repo.url); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists mainPath := filepath.Join(dst, "branch.txt") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } // Get again should work if err := g.Get(dst, repo.url); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists mainPath = filepath.Join(dst, "branch.txt") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestGitGetter_branchUpdate(t *testing.T) { if !testHasGit { t.Log("git not found, skipping") t.Skip() } g := new(GitGetter) dst := tempDir(t) // First setup the state with a fresh branch repo := testGitRepo(t, "branch-update") repo.git("checkout", "-b", "test-branch") repo.commitFile("branch.txt", "branch") // Get the "test-branch" branch q := repo.url.Query() q.Add("ref", "test-branch") repo.url.RawQuery = q.Encode() if err := g.Get(dst, repo.url); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists mainPath := filepath.Join(dst, "branch.txt") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } // Commit an update to the branch repo.commitFile("branch-update.txt", "branch-update") // Get again should work if err := g.Get(dst, repo.url); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists mainPath = filepath.Join(dst, "branch-update.txt") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestGitGetter_tag(t *testing.T) { if !testHasGit { t.Log("git not found, skipping") t.Skip() } g := new(GitGetter) dst := tempDir(t) repo := testGitRepo(t, "tag") repo.commitFile("tag.txt", "tag") repo.git("tag", "v1.0") q := repo.url.Query() q.Add("ref", "v1.0") repo.url.RawQuery = q.Encode() if err := g.Get(dst, repo.url); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists mainPath := filepath.Join(dst, "tag.txt") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } // Get again should work if err := g.Get(dst, repo.url); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists mainPath = filepath.Join(dst, "tag.txt") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestGitGetter_GetFile(t *testing.T) { if !testHasGit { t.Log("git not found, skipping") t.Skip() } g := new(GitGetter) dst := tempFile(t) repo := testGitRepo(t, "file") repo.commitFile("file.txt", "hello") // Download the file repo.url.Path = filepath.Join(repo.url.Path, "file.txt") if err := g.GetFile(dst, repo.url); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists if _, err := os.Stat(dst); err != nil { t.Fatalf("err: %s", err) } assertContents(t, dst, "hello") } func TestGitGetter_gitVersion(t *testing.T) { dir, err := ioutil.TempDir("", "go-getter") if err != nil { t.Fatal(err) } defer os.RemoveAll(dir) script := filepath.Join(dir, "git") err = ioutil.WriteFile( script, []byte("#!/bin/sh\necho \"git version 2.0 (Some Metadata Here)\n\""), 0700) if err != nil { t.Fatal(err) } defer func(v string) { os.Setenv("PATH", v) }(os.Getenv("PATH")) os.Setenv("PATH", dir) // Asking for a higher version throws an error if err := checkGitVersion("2.3"); err == nil { t.Fatal("expect git version error") } // Passes when version is satisfied if err := checkGitVersion("1.9"); err != nil { t.Fatal(err) } } func TestGitGetter_sshKey(t *testing.T) { if !testHasGit { t.Log("git not found, skipping") t.Skip() } g := new(GitGetter) dst := tempDir(t) encodedKey := base64.StdEncoding.EncodeToString([]byte(testGitToken)) u, err := url.Parse("ssh://git@github.com/hashicorp/test-private-repo" + "?sshkey=" + encodedKey) if err != nil { t.Fatal(err) } if err := g.Get(dst, u); err != nil { t.Fatalf("err: %s", err) } readmePath := filepath.Join(dst, "README.md") if _, err := os.Stat(readmePath); err != nil { t.Fatalf("err: %s", err) } } func TestGitGetter_submodule(t *testing.T) { if !testHasGit { t.Log("git not found, skipping") t.Skip() } g := new(GitGetter) dst := tempDir(t) // Set up the grandchild gc := testGitRepo(t, "grandchild") gc.commitFile("grandchild.txt", "grandchild") // Set up the child c := testGitRepo(t, "child") c.commitFile("child.txt", "child") c.git("submodule", "add", gc.dir) c.git("commit", "-m", "Add grandchild submodule") // Set up the parent p := testGitRepo(t, "parent") p.commitFile("parent.txt", "parent") p.git("submodule", "add", c.dir) p.git("commit", "-m", "Add child submodule") // Clone the root repository if err := g.Get(dst, p.url); err != nil { t.Fatalf("err: %s", err) } // Check that the files exist for _, path := range []string{ filepath.Join(dst, "parent.txt"), filepath.Join(dst, "child", "child.txt"), filepath.Join(dst, "child", "grandchild", "grandchild.txt"), } { if _, err := os.Stat(path); err != nil { t.Fatalf("err: %s", err) } } } func TestGitGetter_setupGitEnv_sshKey(t *testing.T) { if runtime.GOOS == "windows" { t.Skipf("skipping on windows since the test requires sh") return } cmd := exec.Command("/bin/sh", "-c", "echo $GIT_SSH_COMMAND") setupGitEnv(cmd, "/tmp/foo.pem") out, err := cmd.Output() if err != nil { t.Fatal(err) } actual := strings.TrimSpace(string(out)) if actual != "ssh -i /tmp/foo.pem" { t.Fatalf("unexpected GIT_SSH_COMMAND: %q", actual) } } func TestGitGetter_setupGitEnvWithExisting_sshKey(t *testing.T) { if runtime.GOOS == "windows" { t.Skipf("skipping on windows since the test requires sh") return } // start with an existing ssh command configuration os.Setenv("GIT_SSH_COMMAND", "ssh -o StrictHostKeyChecking=no") defer os.Setenv("GIT_SSH_COMMAND", "") cmd := exec.Command("/bin/sh", "-c", "echo $GIT_SSH_COMMAND") setupGitEnv(cmd, "/tmp/foo.pem") out, err := cmd.Output() if err != nil { t.Fatal(err) } actual := strings.TrimSpace(string(out)) if actual != "ssh -o StrictHostKeyChecking=no -i /tmp/foo.pem" { t.Fatalf("unexpected GIT_SSH_COMMAND: %q", actual) } } // gitRepo is a helper struct which controls a single temp git repo. type gitRepo struct { t *testing.T url *url.URL dir string } // testGitRepo creates a new test git repository. func testGitRepo(t *testing.T, name string) *gitRepo { dir, err := ioutil.TempDir("", "go-getter") if err != nil { t.Fatal(err) } dir = filepath.Join(dir, name) if err := os.Mkdir(dir, 0700); err != nil { t.Fatal(err) } r := &gitRepo{ t: t, dir: dir, } url, err := url.Parse("file://" + r.dir) if err != nil { t.Fatal(err) } r.url = url r.git("init") r.git("config", "user.name", "go-getter") r.git("config", "user.email", "go-getter@hashicorp.com") return r } // git runs a git command against the repo. func (r *gitRepo) git(args ...string) { cmd := exec.Command("git", args...) cmd.Dir = r.dir if err := cmd.Run(); err != nil { r.t.Fatal(err) } } // commitFile writes and commits a text file to the repo. func (r *gitRepo) commitFile(file, content string) { path := filepath.Join(r.dir, file) if err := ioutil.WriteFile(path, []byte(content), 0600); err != nil { r.t.Fatal(err) } r.git("add", file) r.git("commit", "-m", "Adding "+file) } // This is a read-only deploy key for an empty test repository. // Note: This is split over multiple lines to avoid being disabled by key // scanners automatically. var testGitToken = `-----BEGIN RSA PRIVATE KEY----- MIIEpAIBAAKCAQEA9cHsxCl3Jjgu9DHpwvmfFOl1XEdY+ShHDR/cMnzJ5ddk5/oV Wy6EWatvyHZfRSZMwzv4PtKeUPm6iXjqWp4xdWU9khlPzozyj+U9Fq70TRVUW9E5 T1XdQVwJE421yffr4VMMwu60wBqjI1epapH2i2inYvw9Zl9X2MXq0+jTvFvDerbT mDtfStDPljenELAIZtWVETSvbI46gALwbxbM2292ZUIL4D6jRz0aZMmyy/twYv8r 9WGJLwmYzU518Ie7zqKW/mCTdTrV0WRiDj0MeRaPgrGY9amuHE4r9iG/cJkwpKAO Ccz0Hs6i89u9vZnTqZU9V7weJqRAQcMjXXR6yQIDAQABAoIBAQDBzICKnGxiTlHw rd+6qqChnAy5jWYDbZjCJ8q8YZ3RS08+g/8NXZxvHftTqM0uOaq1FviHig3gq15H hHvCpBc6jXDFYoKFzq6FfO/0kFkE5HoWweIgxwRow0xBCDJAJ+ryUEyy+Ay/pQHb IAjwilRS0V+WdnVw4mTjBAhPvb4jPOo97Yfy3PYUyx2F3newkqXOZy+zx3G/ANoa ncypfMGyy76sfCWKqw4J1gVkVQLwbB6gQkXUFGYwY9sRrxbG93kQw76Flc/E/s52 62j4v1IM0fq0t/St+Y/+s6Lkw` + `aqt3ft1nsqWcRaVDdqvMfkzgJGXlw0bGzJG5MEQ AIBq3dHRAoGBAP8OeG/DKG2Z1VmSfzuz1pas1fbZ+F7venOBrjez3sKlb3Pyl2aH mt2wjaTUi5v10VrHgYtOEdqyhQeUSYydWXIBKNMag0NLLrfFUKZK+57wrHWFdFjn VgpsdkLSNTOZpC8gA5OaJ+36IcOPfGqyyP9wuuRoaYnVT1KEzqLa9FEFAoGBAPaq pglwhil2rxjJE4zq0afQLNpAfi7Xqcrepij+xvJIcIj7nawxXuPxqRFxONE/h3yX zkybO8wLdbHX9Iw/wc1j50Uf1Z5gHdLf7/hQJoWKpz1RnkWRy6CYON8v1tpVp0tb OAajR/kZnzebq2mfa7pyy5zDCX++2kp/dcFwHf31AoGAE8oupBVTZLWj7TBFuP8q LkS40U92Sv9v09iDCQVmylmFvUxcXPM2m+7f/qMTNgWrucxzC7kB/6MMWVszHbrz vrnCTibnemgx9sZTjKOSxHFOIEw7i85fSa3Cu0qOIDPSnmlwfZpfcMKQrhjLAYhf uhooFiLX1X78iZ2OXup4PHUCgYEAsmBrm83sp1V1gAYBBlnVbXakyNv0pCk/Vz61 iFXeRt1NzDGxLxGw3kQnED8BaIh5kQcyn8Fud7sdzJMv/LAqlT4Ww60mzNYTGyjo H3jOsqm3ESfRvduWFreeAQBWbiOczGjV1i8D4EbAFfWT+tjXjchwKBf+6Yt5zn/o Bw/uEHUCgYAFs+JPOR25oRyBs7ujrMo/OY1z/eXTVVgZxY+tYGe1FJqDeFyR7ytK +JBB1MuDwQKGm2wSIXdCzTNoIx2B9zTseiPTwT8G7vqNFhXoIaTBp4P2xIQb45mJ 7GkTsMBHwpSMOXgX9Weq3v5xOJ2WxVtjENmd6qzxcYCO5lP15O17hA== -----END RSA PRIVATE KEY-----` golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/get_hg.go000066400000000000000000000062611333721501700250470ustar00rootroot00000000000000package getter import ( "fmt" "net/url" "os" "os/exec" "path/filepath" "runtime" urlhelper "github.com/hashicorp/go-getter/helper/url" "github.com/hashicorp/go-safetemp" ) // HgGetter is a Getter implementation that will download a module from // a Mercurial repository. type HgGetter struct{} func (g *HgGetter) ClientMode(_ *url.URL) (ClientMode, error) { return ClientModeDir, nil } func (g *HgGetter) Get(dst string, u *url.URL) error { if _, err := exec.LookPath("hg"); err != nil { return fmt.Errorf("hg must be available and on the PATH") } newURL, err := urlhelper.Parse(u.String()) if err != nil { return err } if fixWindowsDrivePath(newURL) { // See valid file path form on http://www.selenic.com/hg/help/urls newURL.Path = fmt.Sprintf("/%s", newURL.Path) } // Extract some query parameters we use var rev string q := newURL.Query() if len(q) > 0 { rev = q.Get("rev") q.Del("rev") newURL.RawQuery = q.Encode() } _, err = os.Stat(dst) if err != nil && !os.IsNotExist(err) { return err } if err != nil { if err := g.clone(dst, newURL); err != nil { return err } } if err := g.pull(dst, newURL); err != nil { return err } return g.update(dst, newURL, rev) } // GetFile for Hg doesn't support updating at this time. It will download // the file every time. func (g *HgGetter) GetFile(dst string, u *url.URL) error { // Create a temporary directory to store the full source. This has to be // a non-existent directory. td, tdcloser, err := safetemp.Dir("", "getter") if err != nil { return err } defer tdcloser.Close() // Get the filename, and strip the filename from the URL so we can // just get the repository directly. filename := filepath.Base(u.Path) u.Path = filepath.ToSlash(filepath.Dir(u.Path)) // If we're on Windows, we need to set the host to "localhost" for hg if runtime.GOOS == "windows" { u.Host = "localhost" } // Get the full repository if err := g.Get(td, u); err != nil { return err } // Copy the single file u, err = urlhelper.Parse(fmtFileURL(filepath.Join(td, filename))) if err != nil { return err } fg := &FileGetter{Copy: true} return fg.GetFile(dst, u) } func (g *HgGetter) clone(dst string, u *url.URL) error { cmd := exec.Command("hg", "clone", "-U", u.String(), dst) return getRunCommand(cmd) } func (g *HgGetter) pull(dst string, u *url.URL) error { cmd := exec.Command("hg", "pull") cmd.Dir = dst return getRunCommand(cmd) } func (g *HgGetter) update(dst string, u *url.URL, rev string) error { args := []string{"update"} if rev != "" { args = append(args, rev) } cmd := exec.Command("hg", args...) cmd.Dir = dst return getRunCommand(cmd) } func fixWindowsDrivePath(u *url.URL) bool { // hg assumes a file:/// prefix for Windows drive letter file paths. // (e.g. file:///c:/foo/bar) // If the URL Path does not begin with a '/' character, the resulting URL // path will have a file:// prefix. (e.g. file://c:/foo/bar) // See http://www.selenic.com/hg/help/urls and the examples listed in // http://selenic.com/repo/hg-stable/file/1265a3a71d75/mercurial/util.py#l1936 return runtime.GOOS == "windows" && u.Scheme == "file" && len(u.Path) > 1 && u.Path[0] != '/' && u.Path[1] == ':' } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/get_hg_test.go000066400000000000000000000034431333721501700261050ustar00rootroot00000000000000package getter import ( "os" "os/exec" "path/filepath" "testing" ) var testHasHg bool func init() { if _, err := exec.LookPath("hg"); err == nil { testHasHg = true } } func TestHgGetter_impl(t *testing.T) { var _ Getter = new(HgGetter) } func TestHgGetter(t *testing.T) { if !testHasHg { t.Log("hg not found, skipping") t.Skip() } g := new(HgGetter) dst := tempDir(t) // With a dir that doesn't exist if err := g.Get(dst, testModuleURL("basic-hg")); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists mainPath := filepath.Join(dst, "main.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestHgGetter_branch(t *testing.T) { if !testHasHg { t.Log("hg not found, skipping") t.Skip() } g := new(HgGetter) dst := tempDir(t) url := testModuleURL("basic-hg") q := url.Query() q.Add("rev", "test-branch") url.RawQuery = q.Encode() if err := g.Get(dst, url); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists mainPath := filepath.Join(dst, "main_branch.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } // Get again should work if err := g.Get(dst, url); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists mainPath = filepath.Join(dst, "main_branch.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestHgGetter_GetFile(t *testing.T) { if !testHasHg { t.Log("hg not found, skipping") t.Skip() } g := new(HgGetter) dst := tempFile(t) // Download if err := g.GetFile(dst, testModuleURL("basic-hg/foo.txt")); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists if _, err := os.Stat(dst); err != nil { t.Fatalf("err: %s", err) } assertContents(t, dst, "Hello\n") } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/get_http.go000066400000000000000000000141411333721501700254240ustar00rootroot00000000000000package getter import ( "encoding/xml" "fmt" "io" "net/http" "net/url" "os" "path/filepath" "strings" "github.com/hashicorp/go-safetemp" ) // HttpGetter is a Getter implementation that will download from an HTTP // endpoint. // // For file downloads, HTTP is used directly. // // The protocol for downloading a directory from an HTTP endpoing 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 // wish. The response must be a 2xx. // // First, a header is looked for "X-Terraform-Get" which should contain // a source URL to download. // // If the header is not present, then a meta tag is searched for named // "terraform-get" and the content should be a source URL. // // The source URL, whether from the header or meta tag, must be a fully // formed URL. The shorthand syntax of "github.com/foo/bar" or relative // paths are not allowed. type HttpGetter struct { // Netrc, if true, will lookup and use auth information found // in the user's netrc file if available. Netrc bool // Client is the http.Client to use for Get requests. // This defaults to a cleanhttp.DefaultClient if left unset. Client *http.Client } func (g *HttpGetter) ClientMode(u *url.URL) (ClientMode, error) { if strings.HasSuffix(u.Path, "/") { return ClientModeDir, nil } return ClientModeFile, nil } func (g *HttpGetter) Get(dst string, u *url.URL) error { // Copy the URL so we can modify it var newU url.URL = *u u = &newU if g.Netrc { // Add auth from netrc if we can if err := addAuthFromNetrc(u); err != nil { return err } } if g.Client == nil { g.Client = httpClient } // Add terraform-get to the parameter. q := u.Query() q.Add("terraform-get", "1") u.RawQuery = q.Encode() // Get the URL resp, err := g.Client.Get(u.String()) 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) } // Extract the source URL var source string if v := resp.Header.Get("X-Terraform-Get"); v != "" { source = v } else { source, err = g.parseMeta(resp.Body) if err != nil { source = u.String() // xml parse errors are getting in the way of our downloads } } if source == "" { return fmt.Errorf("no source URL was returned") } // If there is a subdir component, then we download the root separately // into a temporary directory, then copy over the proper subdir. source, subDir := SourceDirSubdir(source) if subDir == "" { return Get(dst, source) } // We have a subdir, time to jump some hoops return g.getSubdir(dst, source, subDir) } func (g *HttpGetter) GetFile(dst string, u *url.URL) error { if g.Netrc { // Add auth from netrc if we can if err := addAuthFromNetrc(u); err != nil { return err } } if g.Client == nil { g.Client = httpClient } resp, err := g.Client.Get(u.String()) if err != nil { return err } defer resp.Body.Close() if resp.StatusCode != 200 { return fmt.Errorf("bad response code: %d", resp.StatusCode) } // 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 } n, err := io.Copy(f, resp.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 { // Create a temporary directory to store the full source. This has to be // a non-existent directory. td, tdcloser, err := safetemp.Dir("", "getter") if err != nil { return err } defer tdcloser.Close() // Download that into the given directory if err := Get(td, source); err != nil { return err } // Process any globbing sourcePath, err := SubdirGlob(td, subDir) if err != nil { return err } // Make sure the subdir path actually exists if _, err := os.Stat(sourcePath); err != nil { return fmt.Errorf( "Error downloading %s: %s", source, err) } // Copy the subdirectory into our actual destination. if err := os.RemoveAll(dst); err != nil { return err } // Make the final destination if err := os.MkdirAll(dst, 0755); err != nil { return err } return copyDir(dst, sourcePath, false) } // parseMeta looks for the first meta tag in the given reader that // will give us the source URL. func (g *HttpGetter) parseMeta(r io.Reader) (string, error) { d := xml.NewDecoder(r) d.CharsetReader = charsetReader d.Strict = false var err error var t xml.Token for { t, err = d.Token() if err != nil { if err == io.EOF { err = nil } return "", err } if e, ok := t.(xml.StartElement); ok && strings.EqualFold(e.Name.Local, "body") { return "", nil } if e, ok := t.(xml.EndElement); ok && strings.EqualFold(e.Name.Local, "head") { return "", nil } e, ok := t.(xml.StartElement) if !ok || !strings.EqualFold(e.Name.Local, "meta") { continue } if attrValue(e.Attr, "name") != "terraform-get" { continue } if f := attrValue(e.Attr, "content"); f != "" { return f, nil } } } // attrValue returns the attribute value for the case-insensitive key // `name', or the empty string if nothing is found. func attrValue(attrs []xml.Attr, name string) string { for _, a := range attrs { if strings.EqualFold(a.Name.Local, name) { return a.Value } } return "" } // charsetReader returns a reader for the given charset. Currently // it only supports UTF-8 and ASCII. Otherwise, it returns a meaningful // error which is printed by go get, so the user can find why the package // wasn't downloaded if the encoding is not supported. Note that, in // order to reduce potential errors, ASCII is treated as UTF-8 (i.e. characters // greater than 0x7f are not rejected). func charsetReader(charset string, input io.Reader) (io.Reader, error) { switch strings.ToLower(charset) { case "ascii": return input, nil default: return nil, fmt.Errorf("can't decode XML document using charset %q", charset) } } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/get_http_test.go000066400000000000000000000151371333721501700264710ustar00rootroot00000000000000package getter import ( "errors" "fmt" "net" "net/http" "net/url" "os" "path/filepath" "testing" ) func TestHttpGetter_impl(t *testing.T) { var _ Getter = new(HttpGetter) } func TestHttpGetter_header(t *testing.T) { ln := testHttpServer(t) defer ln.Close() g := new(HttpGetter) dst := tempDir(t) defer os.RemoveAll(dst) var u url.URL u.Scheme = "http" u.Host = ln.Addr().String() u.Path = "/header" // Get it! if err := g.Get(dst, &u); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists mainPath := filepath.Join(dst, "main.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestHttpGetter_meta(t *testing.T) { ln := testHttpServer(t) defer ln.Close() g := new(HttpGetter) dst := tempDir(t) defer os.RemoveAll(dst) var u url.URL u.Scheme = "http" u.Host = ln.Addr().String() u.Path = "/meta" // Get it! if err := g.Get(dst, &u); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists mainPath := filepath.Join(dst, "main.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestHttpGetter_metaSubdir(t *testing.T) { ln := testHttpServer(t) defer ln.Close() g := new(HttpGetter) dst := tempDir(t) defer os.RemoveAll(dst) var u url.URL u.Scheme = "http" u.Host = ln.Addr().String() u.Path = "/meta-subdir" // Get it! if err := g.Get(dst, &u); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists mainPath := filepath.Join(dst, "sub.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestHttpGetter_metaSubdirGlob(t *testing.T) { ln := testHttpServer(t) defer ln.Close() g := new(HttpGetter) dst := tempDir(t) defer os.RemoveAll(dst) var u url.URL u.Scheme = "http" u.Host = ln.Addr().String() u.Path = "/meta-subdir-glob" // Get it! if err := g.Get(dst, &u); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists mainPath := filepath.Join(dst, "sub.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestHttpGetter_none(t *testing.T) { ln := testHttpServer(t) defer ln.Close() g := new(HttpGetter) dst := tempDir(t) defer os.RemoveAll(dst) var u url.URL u.Scheme = "http" u.Host = ln.Addr().String() u.Path = "/none" // Get it! if err := g.Get(dst, &u); err == nil { t.Fatal("should error") } } func TestHttpGetter_file(t *testing.T) { ln := testHttpServer(t) defer ln.Close() g := new(HttpGetter) dst := tempFile(t) defer os.RemoveAll(dst) var u url.URL u.Scheme = "http" u.Host = ln.Addr().String() u.Path = "/file" // Get it! if err := g.GetFile(dst, &u); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists if _, err := os.Stat(dst); err != nil { t.Fatalf("err: %s", err) } assertContents(t, dst, "Hello\n") } func TestHttpGetter_auth(t *testing.T) { ln := testHttpServer(t) defer ln.Close() g := new(HttpGetter) dst := tempDir(t) defer os.RemoveAll(dst) var u url.URL u.Scheme = "http" u.Host = ln.Addr().String() u.Path = "/meta-auth" u.User = url.UserPassword("foo", "bar") // Get it! if err := g.Get(dst, &u); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists mainPath := filepath.Join(dst, "main.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestHttpGetter_authNetrc(t *testing.T) { ln := testHttpServer(t) defer ln.Close() g := new(HttpGetter) dst := tempDir(t) defer os.RemoveAll(dst) var u url.URL u.Scheme = "http" u.Host = ln.Addr().String() u.Path = "/meta" // Write the netrc file path, closer := tempFileContents(t, fmt.Sprintf(testHttpNetrc, ln.Addr().String())) defer closer() defer tempEnv(t, "NETRC", path)() // Get it! if err := g.Get(dst, &u); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists mainPath := filepath.Join(dst, "main.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } // test round tripper that only returns an error type errRoundTripper struct{} func (errRoundTripper) RoundTrip(r *http.Request) (*http.Response, error) { return nil, errors.New("test round tripper") } // verify that the default httpClient no longer comes from http.DefaultClient func TestHttpGetter_cleanhttp(t *testing.T) { ln := testHttpServer(t) defer ln.Close() // break the default http client http.DefaultClient.Transport = errRoundTripper{} defer func() { http.DefaultClient.Transport = http.DefaultTransport }() g := new(HttpGetter) dst := tempDir(t) defer os.RemoveAll(dst) var u url.URL u.Scheme = "http" u.Host = ln.Addr().String() u.Path = "/header" // Get it! if err := g.Get(dst, &u); err != nil { t.Fatalf("err: %s", err) } } func testHttpServer(t *testing.T) net.Listener { ln, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { t.Fatalf("err: %s", err) } mux := http.NewServeMux() mux.HandleFunc("/file", testHttpHandlerFile) mux.HandleFunc("/header", testHttpHandlerHeader) mux.HandleFunc("/meta", testHttpHandlerMeta) mux.HandleFunc("/meta-auth", testHttpHandlerMetaAuth) mux.HandleFunc("/meta-subdir", testHttpHandlerMetaSubdir) mux.HandleFunc("/meta-subdir-glob", testHttpHandlerMetaSubdirGlob) var server http.Server server.Handler = mux go server.Serve(ln) return ln } func testHttpHandlerFile(w http.ResponseWriter, r *http.Request) { w.Write([]byte("Hello\n")) } func testHttpHandlerHeader(w http.ResponseWriter, r *http.Request) { w.Header().Add("X-Terraform-Get", testModuleURL("basic").String()) w.WriteHeader(200) } func testHttpHandlerMeta(w http.ResponseWriter, r *http.Request) { w.Write([]byte(fmt.Sprintf(testHttpMetaStr, testModuleURL("basic").String()))) } func testHttpHandlerMetaAuth(w http.ResponseWriter, r *http.Request) { user, pass, ok := r.BasicAuth() if !ok { w.WriteHeader(401) return } if user != "foo" || pass != "bar" { w.WriteHeader(401) return } w.Write([]byte(fmt.Sprintf(testHttpMetaStr, testModuleURL("basic").String()))) } func testHttpHandlerMetaSubdir(w http.ResponseWriter, r *http.Request) { w.Write([]byte(fmt.Sprintf(testHttpMetaStr, testModuleURL("basic//subdir").String()))) } func testHttpHandlerMetaSubdirGlob(w http.ResponseWriter, r *http.Request) { w.Write([]byte(fmt.Sprintf(testHttpMetaStr, testModuleURL("basic//sub*").String()))) } func testHttpHandlerNone(w http.ResponseWriter, r *http.Request) { w.Write([]byte(testHttpNoneStr)) } const testHttpMetaStr = ` ` const testHttpNoneStr = ` ` const testHttpNetrc = ` machine %s login foo password bar ` golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/get_mock.go000066400000000000000000000017601333721501700254010ustar00rootroot00000000000000package getter import ( "net/url" ) // MockGetter is an implementation of Getter that can be used for tests. type MockGetter struct { // 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 GetCalled bool GetDst string GetURL *url.URL GetErr error GetFileCalled bool GetFileDst string GetFileURL *url.URL GetFileErr error } func (g *MockGetter) Get(dst string, u *url.URL) error { g.GetCalled = true g.GetDst = dst g.GetURL = u if g.Proxy != nil { return g.Proxy.Get(dst, u) } return g.GetErr } func (g *MockGetter) GetFile(dst string, u *url.URL) error { g.GetFileCalled = true g.GetFileDst = dst g.GetFileURL = u if g.Proxy != nil { return g.Proxy.GetFile(dst, u) } return g.GetFileErr } func (g *MockGetter) ClientMode(u *url.URL) (ClientMode, error) { if l := len(u.Path); l > 0 && u.Path[l-1:] == "/" { return ClientModeDir, nil } return ClientModeFile, nil } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/get_s3.go000066400000000000000000000144561333721501700250030ustar00rootroot00000000000000package getter import ( "fmt" "io" "net/url" "os" "path/filepath" "strings" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/credentials" "github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds" "github.com/aws/aws-sdk-go/aws/ec2metadata" "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/service/s3" ) // S3Getter is a Getter implementation that will download a module from // a S3 bucket. type S3Getter struct{} func (g *S3Getter) ClientMode(u *url.URL) (ClientMode, error) { // Parse URL region, bucket, path, _, creds, err := g.parseUrl(u) if err != nil { return 0, err } // Create client config config := g.getAWSConfig(region, u, creds) sess := session.New(config) client := s3.New(sess) // List the object(s) at the given prefix req := &s3.ListObjectsInput{ Bucket: aws.String(bucket), Prefix: aws.String(path), } resp, err := client.ListObjects(req) if err != nil { return 0, err } for _, o := range resp.Contents { // Use file mode on exact match. if *o.Key == path { return ClientModeFile, nil } // Use dir mode if child keys are found. if strings.HasPrefix(*o.Key, path+"/") { return ClientModeDir, nil } } // There was no match, so just return file mode. The download is going // to fail but we will let S3 return the proper error later. return ClientModeFile, nil } func (g *S3Getter) Get(dst string, u *url.URL) error { // Parse URL region, bucket, path, _, creds, 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 } config := g.getAWSConfig(region, u, creds) sess := session.New(config) client := s3.New(sess) // List files in path, keep listing until no more objects are found lastMarker := "" hasMore := true for hasMore { req := &s3.ListObjectsInput{ Bucket: aws.String(bucket), Prefix: aws.String(path), } if lastMarker != "" { req.Marker = aws.String(lastMarker) } resp, err := client.ListObjects(req) if err != nil { return err } hasMore = aws.BoolValue(resp.IsTruncated) // Get each object storing each file relative to the destination path for _, object := range resp.Contents { lastMarker = aws.StringValue(object.Key) objPath := aws.StringValue(object.Key) // If the key ends with a backslash assume it is a directory and ignore if strings.HasSuffix(objPath, "/") { continue } // Get the object destination path objDst, err := filepath.Rel(path, objPath) if err != nil { return err } objDst = filepath.Join(dst, objDst) if err := g.getObject(client, objDst, bucket, objPath, ""); err != nil { return err } } } return nil } func (g *S3Getter) GetFile(dst string, u *url.URL) error { region, bucket, path, version, creds, err := g.parseUrl(u) if err != nil { return err } config := g.getAWSConfig(region, u, creds) sess := session.New(config) client := s3.New(sess) return g.getObject(client, dst, bucket, path, version) } func (g *S3Getter) getObject(client *s3.S3, dst, bucket, key, version string) error { req := &s3.GetObjectInput{ Bucket: aws.String(bucket), Key: aws.String(key), } if version != "" { req.VersionId = aws.String(version) } resp, err := client.GetObject(req) if err != nil { return err } // 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 = io.Copy(f, resp.Body) return err } func (g *S3Getter) getAWSConfig(region string, url *url.URL, creds *credentials.Credentials) *aws.Config { conf := &aws.Config{} if creds == nil { // Grab the metadata URL metadataURL := os.Getenv("AWS_METADATA_URL") if metadataURL == "" { metadataURL = "http://169.254.169.254:80/latest" } creds = credentials.NewChainCredentials( []credentials.Provider{ &credentials.EnvProvider{}, &credentials.SharedCredentialsProvider{Filename: "", Profile: ""}, &ec2rolecreds.EC2RoleProvider{ Client: ec2metadata.New(session.New(&aws.Config{ Endpoint: aws.String(metadataURL), })), }, }) } if creds != nil { conf.Endpoint = &url.Host conf.S3ForcePathStyle = aws.Bool(true) if url.Scheme == "http" { conf.DisableSSL = aws.Bool(true) } } conf.Credentials = creds if region != "" { conf.Region = aws.String(region) } return conf } func (g *S3Getter) parseUrl(u *url.URL) (region, bucket, path, version string, creds *credentials.Credentials, err error) { // This just check whether we are dealing with S3 or // any other S3 compliant service. S3 has a predictable // url as others do not if strings.Contains(u.Host, "amazonaws.com") { // Expected host style: s3.amazonaws.com. They always have 3 parts, // although the first may differ if we're accessing a specific region. hostParts := strings.Split(u.Host, ".") if len(hostParts) != 3 { err = fmt.Errorf("URL is not a valid S3 URL") return } // Parse the region out of the first part of the host region = strings.TrimPrefix(strings.TrimPrefix(hostParts[0], "s3-"), "s3") if region == "" { region = "us-east-1" } pathParts := strings.SplitN(u.Path, "/", 3) if len(pathParts) != 3 { err = fmt.Errorf("URL is not a valid S3 URL") return } bucket = pathParts[1] path = pathParts[2] version = u.Query().Get("version") } else { pathParts := strings.SplitN(u.Path, "/", 3) if len(pathParts) != 3 { err = fmt.Errorf("URL is not a valid S3 complaint URL") return } bucket = pathParts[1] path = pathParts[2] version = u.Query().Get("version") region = u.Query().Get("region") if region == "" { region = "us-east-1" } } _, hasAwsId := u.Query()["aws_access_key_id"] _, hasAwsSecret := u.Query()["aws_access_key_secret"] _, hasAwsToken := u.Query()["aws_access_token"] if hasAwsId || hasAwsSecret || hasAwsToken { creds = credentials.NewStaticCredentials( u.Query().Get("aws_access_key_id"), u.Query().Get("aws_access_key_secret"), u.Query().Get("aws_access_token"), ) } return } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/get_s3_test.go000066400000000000000000000143721333721501700260370ustar00rootroot00000000000000package getter import ( "net/url" "os" "path/filepath" "testing" "github.com/aws/aws-sdk-go/aws/awserr" ) func init() { // These are well known restricted IAM keys to a HashiCorp-managed bucket // in a private AWS account that only has access to the open source test // resources. // // We do the string concat below to avoid AWS autodetection of a key. This // key is locked down an IAM policy that is read-only so we're purposely // exposing it. os.Setenv("AWS_ACCESS_KEY", "AKIAITTDR"+"WY2STXOZE2A") os.Setenv("AWS_SECRET_KEY", "oMwSyqdass2kPF"+"/7ORZA9dlb/iegz+89B0Cy01Ea") } func TestS3Getter_impl(t *testing.T) { var _ Getter = new(S3Getter) } func TestS3Getter(t *testing.T) { g := new(S3Getter) dst := tempDir(t) // With a dir that doesn't exist err := g.Get( dst, testURL("https://s3.amazonaws.com/hc-oss-test/go-getter/folder")) if err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists mainPath := filepath.Join(dst, "main.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestS3Getter_subdir(t *testing.T) { g := new(S3Getter) dst := tempDir(t) // With a dir that doesn't exist err := g.Get( dst, testURL("https://s3.amazonaws.com/hc-oss-test/go-getter/folder/subfolder")) if err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists subPath := filepath.Join(dst, "sub.tf") if _, err := os.Stat(subPath); err != nil { t.Fatalf("err: %s", err) } } func TestS3Getter_GetFile(t *testing.T) { g := new(S3Getter) dst := tempFile(t) // Download err := g.GetFile( dst, testURL("https://s3.amazonaws.com/hc-oss-test/go-getter/folder/main.tf")) if err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists if _, err := os.Stat(dst); err != nil { t.Fatalf("err: %s", err) } assertContents(t, dst, "# Main\n") } func TestS3Getter_GetFile_badParams(t *testing.T) { g := new(S3Getter) dst := tempFile(t) // Download err := g.GetFile( dst, testURL("https://s3.amazonaws.com/hc-oss-test/go-getter/folder/main.tf?aws_access_key_id=foo&aws_access_key_secret=bar&aws_access_token=baz")) if err == nil { t.Fatalf("expected error, got none") } if reqerr, ok := err.(awserr.RequestFailure); !ok || reqerr.StatusCode() != 403 { t.Fatalf("expected InvalidAccessKeyId error") } } func TestS3Getter_GetFile_notfound(t *testing.T) { g := new(S3Getter) dst := tempFile(t) // Download err := g.GetFile( dst, testURL("https://s3.amazonaws.com/hc-oss-test/go-getter/folder/404.tf")) if err == nil { t.Fatalf("expected error, got none") } } func TestS3Getter_ClientMode_dir(t *testing.T) { g := new(S3Getter) // Check client mode on a key prefix with only a single key. mode, err := g.ClientMode( testURL("https://s3.amazonaws.com/hc-oss-test/go-getter/folder")) if err != nil { t.Fatalf("err: %s", err) } if mode != ClientModeDir { t.Fatal("expect ClientModeDir") } } func TestS3Getter_ClientMode_file(t *testing.T) { g := new(S3Getter) // Check client mode on a key prefix which contains sub-keys. mode, err := g.ClientMode( testURL("https://s3.amazonaws.com/hc-oss-test/go-getter/folder/main.tf")) if err != nil { t.Fatalf("err: %s", err) } if mode != ClientModeFile { t.Fatal("expect ClientModeFile") } } func TestS3Getter_ClientMode_notfound(t *testing.T) { g := new(S3Getter) // Check the client mode when a non-existent key is looked up. This does not // return an error, but rather should just return the file mode so that S3 // can return an appropriate error later on. This also checks that the // prefix is handled properly (e.g., "/fold" and "/folder" don't put the // client mode into "dir". mode, err := g.ClientMode( testURL("https://s3.amazonaws.com/hc-oss-test/go-getter/fold")) if err != nil { t.Fatalf("err: %s", err) } if mode != ClientModeFile { t.Fatal("expect ClientModeFile") } } func TestS3Getter_ClientMode_collision(t *testing.T) { g := new(S3Getter) // Check that the client mode is "file" if there is both an object and a // folder with a common prefix (i.e., a "collision" in the namespace). mode, err := g.ClientMode( testURL("https://s3.amazonaws.com/hc-oss-test/go-getter/collision/foo")) if err != nil { t.Fatalf("err: %s", err) } if mode != ClientModeFile { t.Fatal("expect ClientModeFile") } } func TestS3Getter_Url(t *testing.T) { var s3tests = []struct { name string url string region string bucket string path string version string }{ { name: "AWSv1234", url: "s3::https://s3-eu-west-1.amazonaws.com/bucket/foo/bar.baz?version=1234", region: "eu-west-1", bucket: "bucket", path: "foo/bar.baz", version: "1234", }, { name: "localhost-1", url: "s3::http://127.0.0.1:9000/test-bucket/hello.txt?aws_access_key_id=TESTID&aws_access_key_secret=TestSecret®ion=us-east-2&version=1", region: "us-east-2", bucket: "test-bucket", path: "hello.txt", version: "1", }, { name: "localhost-2", url: "s3::http://127.0.0.1:9000/test-bucket/hello.txt?aws_access_key_id=TESTID&aws_access_key_secret=TestSecret&version=1", region: "us-east-1", bucket: "test-bucket", path: "hello.txt", version: "1", }, { name: "localhost-3", url: "s3::http://127.0.0.1:9000/test-bucket/hello.txt?aws_access_key_id=TESTID&aws_access_key_secret=TestSecret", region: "us-east-1", bucket: "test-bucket", path: "hello.txt", version: "", }, } for i, pt := range s3tests { t.Run(pt.name, func(t *testing.T) { g := new(S3Getter) forced, src := getForcedGetter(pt.url) u, err := url.Parse(src) if err != nil { t.Errorf("test %d: unexpected error: %s", i, err) } if forced != "s3" { t.Fatalf("expected forced protocol to be s3") } region, bucket, path, version, creds, err := g.parseUrl(u) if err != nil { t.Fatalf("err: %s", err) } if region != pt.region { t.Fatalf("expected %s, got %s", pt.region, region) } if bucket != pt.bucket { t.Fatalf("expected %s, got %s", pt.bucket, bucket) } if path != pt.path { t.Fatalf("expected %s, got %s", pt.path, path) } if version != pt.version { t.Fatalf("expected %s, got %s", pt.version, version) } if &creds == nil { t.Fatalf("expected to not be nil") } }) } } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/get_test.go000066400000000000000000000173261333721501700254340ustar00rootroot00000000000000package getter import ( "os" "path/filepath" "strings" "testing" ) func TestGet_badSchema(t *testing.T) { dst := tempDir(t) u := testModule("basic") u = strings.Replace(u, "file", "nope", -1) if err := Get(dst, u); err == nil { t.Fatal("should error") } } func TestGet_file(t *testing.T) { dst := tempDir(t) u := testModule("basic") if err := Get(dst, u); err != nil { t.Fatalf("err: %s", err) } mainPath := filepath.Join(dst, "main.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } // https://github.com/hashicorp/terraform/issues/11438 func TestGet_fileDecompressorExt(t *testing.T) { dst := tempDir(t) u := testModule("basic-tgz") if err := Get(dst, u); err != nil { t.Fatalf("err: %s", err) } mainPath := filepath.Join(dst, "main.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } // https://github.com/hashicorp/terraform/issues/8418 func TestGet_filePercent2F(t *testing.T) { dst := tempDir(t) u := testModule("basic%2Ftest") if err := Get(dst, u); err != nil { t.Fatalf("err: %s", err) } mainPath := filepath.Join(dst, "main.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestGet_fileDetect(t *testing.T) { dst := tempDir(t) u := filepath.Join("./test-fixtures", "basic") pwd, err := os.Getwd() if err != nil { t.Fatalf("err: %s", err) } client := &Client{ Src: u, Dst: dst, Pwd: pwd, Dir: true, } if err := client.Get(); err != nil { t.Fatalf("err: %s", err) } mainPath := filepath.Join(dst, "main.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestGet_fileForced(t *testing.T) { dst := tempDir(t) u := testModule("basic") u = "file::" + u if err := Get(dst, u); err != nil { t.Fatalf("err: %s", err) } mainPath := filepath.Join(dst, "main.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestGet_fileSubdir(t *testing.T) { dst := tempDir(t) u := testModule("basic//subdir") if err := Get(dst, u); err != nil { t.Fatalf("err: %s", err) } mainPath := filepath.Join(dst, "sub.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestGet_archive(t *testing.T) { dst := tempDir(t) u := filepath.Join("./test-fixtures", "archive.tar.gz") u, _ = filepath.Abs(u) if err := Get(dst, u); err != nil { t.Fatalf("err: %s", err) } mainPath := filepath.Join(dst, "main.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestGetAny_archive(t *testing.T) { dst := tempDir(t) u := filepath.Join("./test-fixtures", "archive.tar.gz") u, _ = filepath.Abs(u) if err := GetAny(dst, u); err != nil { t.Fatalf("err: %s", err) } mainPath := filepath.Join(dst, "main.tf") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestGet_archiveRooted(t *testing.T) { dst := tempDir(t) u := testModule("archive-rooted/archive.tar.gz") if err := Get(dst, u); err != nil { t.Fatalf("err: %s", err) } mainPath := filepath.Join(dst, "root", "hello.txt") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestGet_archiveSubdirWild(t *testing.T) { dst := tempDir(t) u := testModule("archive-rooted/archive.tar.gz") u += "//*" if err := Get(dst, u); err != nil { t.Fatalf("err: %s", err) } mainPath := filepath.Join(dst, "hello.txt") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestGet_archiveSubdirWildMultiMatch(t *testing.T) { dst := tempDir(t) u := testModule("archive-rooted-multi/archive.tar.gz") u += "//*" if err := Get(dst, u); err == nil { t.Fatal("should error") } else if !strings.Contains(err.Error(), "multiple") { t.Fatalf("err: %s", err) } } func TestGetAny_file(t *testing.T) { dst := tempDir(t) u := testModule("basic-file/foo.txt") if err := GetAny(dst, u); err != nil { t.Fatalf("err: %s", err) } mainPath := filepath.Join(dst, "foo.txt") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } func TestGetAny_dir(t *testing.T) { dst := tempDir(t) u := filepath.Join("./test-fixtures", "basic") u, _ = filepath.Abs(u) if err := GetAny(dst, u); err != nil { t.Fatalf("err: %s", err) } check := []string{ "main.tf", "foo/main.tf", } for _, name := range check { mainPath := filepath.Join(dst, name) if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } } func TestGetFile(t *testing.T) { dst := tempFile(t) u := testModule("basic-file/foo.txt") if err := GetFile(dst, u); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists assertContents(t, dst, "Hello\n") } func TestGetFile_archive(t *testing.T) { dst := tempFile(t) u := testModule("basic-file-archive/archive.tar.gz") if err := GetFile(dst, u); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists assertContents(t, dst, "Hello\n") } func TestGetFile_archiveChecksum(t *testing.T) { dst := tempFile(t) u := testModule( "basic-file-archive/archive.tar.gz?checksum=md5:fbd90037dacc4b1ab40811d610dde2f0") if err := GetFile(dst, u); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists assertContents(t, dst, "Hello\n") } func TestGetFile_archiveNoUnarchive(t *testing.T) { dst := tempFile(t) u := testModule("basic-file-archive/archive.tar.gz") u += "?archive=false" if err := GetFile(dst, u); err != nil { t.Fatalf("err: %s", err) } // Verify the main file exists actual := testMD5(t, dst) expected := "fbd90037dacc4b1ab40811d610dde2f0" if actual != expected { t.Fatalf("bad: %s", actual) } } func TestGetFile_checksum(t *testing.T) { cases := []struct { Append string Err bool }{ { "", false, }, // MD5 { "?checksum=md5:09f7e02f1290be211da707a266f153b3", false, }, { "?checksum=md5:09f7e02f1290be211da707a266f153b4", true, }, // SHA1 { "?checksum=sha1:1d229271928d3f9e2bb0375bd6ce5db6c6d348d9", false, }, { "?checksum=sha1:1d229271928d3f9e2bb0375bd6ce5db6c6d348d0", true, }, // SHA256 { "?checksum=sha256:66a045b452102c59d840ec097d59d9467e13a3f34f6494e539ffd32c1bb35f18", false, }, { "?checksum=sha256:66a045b452102c59d840ec097d59d9467e13a3f34f6494e539ffd32c1bb35f19", true, }, // SHA512 { "?checksum=sha512:c2bad2223811194582af4d1508ac02cd69eeeeedeeb98d54fcae4dcefb13cc882e7640328206603d3fb9cd5f949a9be0db054dd34fbfa190c498a5fe09750cef", false, }, { "?checksum=sha512:c2bad2223811194582af4d1508ac02cd69eeeeedeeb98d54fcae4dcefb13cc882e7640328206603d3fb9cd5f949a9be0db054dd34fbfa190c498a5fe09750ced", true, }, } for _, tc := range cases { u := testModule("basic-file/foo.txt") + tc.Append func() { dst := tempFile(t) defer os.Remove(dst) if err := GetFile(dst, u); (err != nil) != tc.Err { t.Fatalf("append: %s\n\nerr: %s", tc.Append, err) } // Verify the main file exists assertContents(t, dst, "Hello\n") }() } } func TestGetFile_checksumURL(t *testing.T) { dst := tempFile(t) u := testModule("basic-file/foo.txt") + "?checksum=md5:09f7e02f1290be211da707a266f153b3" getter := &MockGetter{Proxy: new(FileGetter)} client := &Client{ Src: u, Dst: dst, Dir: false, Getters: map[string]Getter{ "file": getter, }, } if err := client.Get(); err != nil { t.Fatalf("err: %s", err) } if v := getter.GetFileURL.Query().Get("checksum"); v != "" { t.Fatalf("bad: %s", v) } } func TestGetFile_filename(t *testing.T) { dst := tempDir(t) u := testModule("basic-file/foo.txt") u += "?filename=bar.txt" if err := GetAny(dst, u); err != nil { t.Fatalf("err: %s", err) } mainPath := filepath.Join(dst, "bar.txt") if _, err := os.Stat(mainPath); err != nil { t.Fatalf("err: %s", err) } } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/helper/000077500000000000000000000000001333721501700245355ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/helper/url/000077500000000000000000000000001333721501700253375ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/helper/url/url.go000066400000000000000000000004761333721501700264770ustar00rootroot00000000000000package url import ( "net/url" ) // Parse parses rawURL into a URL structure. // The rawURL may be relative or absolute. // // Parse is a wrapper for the Go stdlib net/url Parse function, but returns // Windows "safe" URLs on Windows platforms. func Parse(rawURL string) (*url.URL, error) { return parse(rawURL) } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/helper/url/url_test.go000066400000000000000000000031141333721501700275260ustar00rootroot00000000000000package url import ( "runtime" "testing" ) type parseTest struct { rawURL string scheme string host string path string str string err bool } var parseTests = []parseTest{ { rawURL: "/foo/bar", scheme: "", host: "", path: "/foo/bar", str: "/foo/bar", err: false, }, { rawURL: "file:///dir/", scheme: "file", host: "", path: "/dir/", str: "file:///dir/", err: false, }, } var winParseTests = []parseTest{ { rawURL: `C:\`, scheme: ``, host: ``, path: `C:/`, str: `C:/`, err: false, }, { rawURL: `file://C:\`, scheme: `file`, host: ``, path: `C:/`, str: `file://C:/`, err: false, }, { rawURL: `file:///C:\`, scheme: `file`, host: ``, path: `C:/`, str: `file://C:/`, err: false, }, } func TestParse(t *testing.T) { if runtime.GOOS == "windows" { parseTests = append(parseTests, winParseTests...) } for i, pt := range parseTests { url, err := Parse(pt.rawURL) if err != nil && !pt.err { t.Errorf("test %d: unexpected error: %s", i, err) } if err == nil && pt.err { t.Errorf("test %d: expected an error", i) } if url.Scheme != pt.scheme { t.Errorf("test %d: expected Scheme = %q, got %q", i, pt.scheme, url.Scheme) } if url.Host != pt.host { t.Errorf("test %d: expected Host = %q, got %q", i, pt.host, url.Host) } if url.Path != pt.path { t.Errorf("test %d: expected Path = %q, got %q", i, pt.path, url.Path) } if url.String() != pt.str { t.Errorf("test %d: expected url.String() = %q, got %q", i, pt.str, url.String()) } } } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/helper/url/url_unix.go000066400000000000000000000002021333721501700275250ustar00rootroot00000000000000// +build !windows package url import ( "net/url" ) func parse(rawURL string) (*url.URL, error) { return url.Parse(rawURL) } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/helper/url/url_windows.go000066400000000000000000000020171333721501700302420ustar00rootroot00000000000000package url import ( "fmt" "net/url" "path/filepath" "strings" ) func parse(rawURL string) (*url.URL, error) { // Make sure we're using "/" since URLs are "/"-based. rawURL = filepath.ToSlash(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. u.Path = fmt.Sprintf("%s%s", u.Host, u.Path) u.Host = "" } // Remove leading slash for absolute file paths. if len(u.Path) > 2 && u.Path[0] == '/' && u.Path[2] == ':' { u.Path = u.Path[1:] } return u, err } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/module_test.go000066400000000000000000000025171333721501700261360ustar00rootroot00000000000000package getter import ( "io/ioutil" "net/url" "os" "path/filepath" "reflect" "testing" urlhelper "github.com/hashicorp/go-getter/helper/url" ) const fixtureDir = "./test-fixtures" func tempDir(t *testing.T) string { dir, err := ioutil.TempDir("", "tf") if err != nil { t.Fatalf("err: %s", err) } if err := os.RemoveAll(dir); err != nil { t.Fatalf("err: %s", err) } return dir } func tempFile(t *testing.T) string { dir := tempDir(t) return filepath.Join(dir, "foo") } func testModule(n string) string { p := filepath.Join(fixtureDir, n) p, err := filepath.Abs(p) if err != nil { panic(err) } return fmtFileURL(p) } func testModuleURL(n string) *url.URL { n, subDir := SourceDirSubdir(n) u, err := urlhelper.Parse(testModule(n)) if err != nil { panic(err) } if subDir != "" { u.Path += "//" + subDir u.RawPath = u.Path } return u } func testURL(s string) *url.URL { u, err := urlhelper.Parse(s) if err != nil { panic(err) } return u } func testStorage(t *testing.T) Storage { return &FolderStorage{StorageDir: tempDir(t)} } func assertContents(t *testing.T, path string, contents string) { data, err := ioutil.ReadFile(path) if err != nil { t.Fatalf("err: %s", err) } if !reflect.DeepEqual(data, []byte(contents)) { t.Fatalf("bad. expected:\n\n%s\n\nGot:\n\n%s", contents, string(data)) } } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/netrc.go000066400000000000000000000026121333721501700247210ustar00rootroot00000000000000package getter import ( "fmt" "net/url" "os" "runtime" "github.com/bgentry/go-netrc/netrc" "github.com/mitchellh/go-homedir" ) // addAuthFromNetrc adds auth information to the URL from the user's // netrc file if it can be found. This will only add the auth info // if the URL doesn't already have auth info specified and the // the username is blank. func addAuthFromNetrc(u *url.URL) error { // If the URL already has auth information, do nothing if u.User != nil && u.User.Username() != "" { return nil } // Get the netrc file path path := os.Getenv("NETRC") if path == "" { filename := ".netrc" if runtime.GOOS == "windows" { filename = "_netrc" } var err error path, err = homedir.Expand("~/" + filename) if err != nil { return err } } // If the file is not a file, then do nothing if fi, err := os.Stat(path); err != nil { // File doesn't exist, do nothing if os.IsNotExist(err) { return nil } // Some other error! return err } else if fi.IsDir() { // File is directory, ignore return nil } // Load up the netrc file net, err := netrc.ParseFile(path) if err != nil { return fmt.Errorf("Error parsing netrc file at %q: %s", path, err) } machine := net.FindMachine(u.Host) if machine == nil { // Machine not found, no problem return nil } // Set the user info u.User = url.UserPassword(machine.Login, machine.Password) return nil } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/netrc_test.go000066400000000000000000000024341333721501700257620ustar00rootroot00000000000000package getter import ( "net/url" "testing" ) func TestAddAuthFromNetrc(t *testing.T) { defer tempEnv(t, "NETRC", "./test-fixtures/netrc/basic")() u, err := url.Parse("http://example.com") if err != nil { t.Fatalf("err: %s", err) } if err := addAuthFromNetrc(u); err != nil { t.Fatalf("err: %s", err) } expected := "http://foo:bar@example.com" actual := u.String() if expected != actual { t.Fatalf("Mismatch: %q != %q", actual, expected) } } func TestAddAuthFromNetrc_hasAuth(t *testing.T) { defer tempEnv(t, "NETRC", "./test-fixtures/netrc/basic")() u, err := url.Parse("http://username:password@example.com") if err != nil { t.Fatalf("err: %s", err) } expected := u.String() if err := addAuthFromNetrc(u); err != nil { t.Fatalf("err: %s", err) } actual := u.String() if expected != actual { t.Fatalf("Mismatch: %q != %q", actual, expected) } } func TestAddAuthFromNetrc_hasUsername(t *testing.T) { defer tempEnv(t, "NETRC", "./test-fixtures/netrc/basic")() u, err := url.Parse("http://username@example.com") if err != nil { t.Fatalf("err: %s", err) } expected := u.String() if err := addAuthFromNetrc(u); err != nil { t.Fatalf("err: %s", err) } actual := u.String() if expected != actual { t.Fatalf("Mismatch: %q != %q", actual, expected) } } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/source.go000066400000000000000000000026771333721501700251210ustar00rootroot00000000000000package getter import ( "fmt" "path/filepath" "strings" ) // SourceDirSubdir takes a source and returns a tuple of the URL without // the subdir and the URL with the subdir. func SourceDirSubdir(src string) (string, string) { // Calcaulate an offset to avoid accidentally marking the scheme // as the dir. var offset int if idx := strings.Index(src, "://"); idx > -1 { offset = idx + 3 } // First see if we even have an explicit subdir idx := strings.Index(src[offset:], "//") if idx == -1 { return src, "" } idx += offset subdir := src[idx+2:] src = src[:idx] // Next, check if we have query parameters and push them onto the // URL. if idx = strings.Index(subdir, "?"); idx > -1 { query := subdir[idx:] subdir = subdir[:idx] src += query } return src, subdir } // SubdirGlob returns the actual subdir with globbing processed. // // dst should be a destination directory that is already populated (the // download is complete) and subDir should be the set subDir. If subDir // is an empty string, this returns an empty string. // // The returned path is the full absolute path. func SubdirGlob(dst, subDir string) (string, error) { matches, err := filepath.Glob(filepath.Join(dst, subDir)) if err != nil { return "", err } if len(matches) == 0 { return "", fmt.Errorf("subdir %q not found", subDir) } if len(matches) > 1 { return "", fmt.Errorf("subdir %q matches multiple paths", subDir) } return matches[0], nil } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/source_test.go000066400000000000000000000034171333721501700261510ustar00rootroot00000000000000package getter import ( "io/ioutil" "os" "path/filepath" "testing" ) func TestSourceDirSubdir(t *testing.T) { cases := []struct { Input string Dir, Sub string }{ { "hashicorp.com", "hashicorp.com", "", }, { "hashicorp.com//foo", "hashicorp.com", "foo", }, { "hashicorp.com//foo?bar=baz", "hashicorp.com?bar=baz", "foo", }, { "https://hashicorp.com/path//*?archive=foo", "https://hashicorp.com/path?archive=foo", "*", }, { "file://foo//bar", "file://foo", "bar", }, } for i, tc := range cases { adir, asub := SourceDirSubdir(tc.Input) if adir != tc.Dir { t.Fatalf("%d: bad dir: %#v", i, adir) } if asub != tc.Sub { t.Fatalf("%d: bad sub: %#v", i, asub) } } } func TestSourceSubdirGlob(t *testing.T) { td, err := ioutil.TempDir("", "subdir-glob") if err != nil { t.Fatal(err) } defer os.RemoveAll(td) if err := os.Mkdir(filepath.Join(td, "subdir"), 0755); err != nil { t.Fatal(err) } if err := os.Mkdir(filepath.Join(td, "subdir/one"), 0755); err != nil { t.Fatal(err) } if err := os.Mkdir(filepath.Join(td, "subdir/two"), 0755); err != nil { t.Fatal(err) } subdir := filepath.Join(td, "subdir") // match the exact directory res, err := SubdirGlob(td, "subdir") if err != nil { t.Fatal(err) } if res != subdir { t.Fatalf(`expected "subdir", got: %q`, subdir) } // single match from a wildcard res, err = SubdirGlob(td, "*") if err != nil { t.Fatal(err) } if res != subdir { t.Fatalf(`expected "subdir", got: %q`, subdir) } // multiple matches res, err = SubdirGlob(td, "subdir/*") if err == nil { t.Fatalf("expected multiple matches, got %q", res) } // non-existent res, err = SubdirGlob(td, "foo") if err == nil { t.Fatalf("expected no matches, got %q", res) } } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/storage.go000066400000000000000000000006711333721501700252550ustar00rootroot00000000000000package getter // Storage is an interface that knows how to lookup downloaded directories // as well as download and update directories from their sources into the // proper location. type Storage interface { // Dir returns the directory on local disk where the directory source // can be loaded from. Dir(string) (string, bool, error) // Get will download and optionally update the given directory. Get(string, string, bool) error } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/000077500000000000000000000000001333721501700261045ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/archive-rooted-multi/000077500000000000000000000000001333721501700321475ustar00rootroot00000000000000archive.tar.gz000066400000000000000000000003221333721501700346350ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/archive-rooted-multib(Y @]\ο!M79HHp1 > z)ʾByIJY9'S.QN[m6B*c<N}lz n}ۅ|Jd4">yWg=KYN٘ܟ?ܻ %:X12~S9?"`o (golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/archive-rooted/000077500000000000000000000000001333721501700310175ustar00rootroot00000000000000archive.tar.gz000066400000000000000000000002551333721501700335120ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/archive-rooted &YK 0]EV<]H!BP#|cS@%1uMM"^3fYhqƊJ"US-tr)c? þ[aG IhKϗmwmV{rR#ڟ?u x(golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/archive.tar.gz000066400000000000000000000002151333721501700306520ustar00rootroot00000000000000BVA @ a=ENP2c9HЎWk )<Yd5LdW杉*o(JXj7=sX ]n[߷oM!rHxuf9(golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic%2Ftest/000077500000000000000000000000001333721501700303225ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic%2Ftest/foo/000077500000000000000000000000001333721501700311055ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic%2Ftest/foo/main.tf000066400000000000000000000000101333721501700323530ustar00rootroot00000000000000# Hello golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic%2Ftest/main.tf000066400000000000000000000000571333721501700316030ustar00rootroot00000000000000# Hello module "foo" { source = "./foo" } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic%2Ftest/subdir/000077500000000000000000000000001333721501700316125ustar00rootroot00000000000000sub.tf000066400000000000000000000000001333721501700326450ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic%2Ftest/subdirgolang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-dot/000077500000000000000000000000001333721501700277515ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-dot/.test/000077500000000000000000000000001333721501700310065ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-dot/.test/foo.tf000066400000000000000000000000051333721501700321170ustar00rootroot00000000000000# Hi golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-dot/main.tf000066400000000000000000000000571333721501700312320ustar00rootroot00000000000000# Hello module "foo" { source = "./foo" } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-file-archive/000077500000000000000000000000001333721501700315215ustar00rootroot00000000000000archive.tar.gz000066400000000000000000000002151333721501700342100ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-file-archiveCVA @ a=Ecz^)X] ]HoV;SU79޼S2\Btkw ZD.6{u(Utڜ{e-/wGd˃v'(golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-file/000077500000000000000000000000001333721501700301025ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-file/foo.txt000066400000000000000000000000061333721501700314220ustar00rootroot00000000000000Hello golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/000077500000000000000000000000001333721501700275615ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/000077500000000000000000000000001333721501700302355ustar00rootroot0000000000000000changelog.i000066400000000000000000000000711333721501700324150ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg dummy changelog to prevent using the old repo layoutgolang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/branch000066400000000000000000000000101333721501700314040ustar00rootroot00000000000000default golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/cache/000077500000000000000000000000001333721501700313005ustar00rootroot00000000000000branch2-served000066400000000000000000000002251333721501700337500ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/cache992604507bcd66370bf91a0c9d526ccd833412bf 2 992604507bcd66370bf91a0c9d526ccd833412bf o default c65e998d747ffbb1fe3b1c067a50664bb3fb5da4 o test-branch rbc-names-v1000066400000000000000000000000071333721501700333340ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/cachedefaultrbc-revs-v1000066400000000000000000000000101333721501700332020ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/cache&Pgolang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/cache/tags000066400000000000000000000000541333721501700321600ustar00rootroot000000000000001 c65e998d747ffbb1fe3b1c067a50664bb3fb5da4 golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/dirstate000066400000000000000000000001301333721501700317710ustar00rootroot00000000000000&P{f7  Rl̓4nV+foo.txtn/Vzmain.tflast-message.txt000066400000000000000000000000121333721501700332750ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hgadd file golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/requires000066400000000000000000000000411333721501700320120ustar00rootroot00000000000000dotencode fncache revlogv1 store golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/store/000077500000000000000000000000001333721501700313715ustar00rootroot0000000000000000changelog.i000066400000000000000000000010201333721501700335440ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/storep{ܮuMX&LbD#w0{x5A ! @ѽhRJ)tM1ZSt31w$bp%LB'ͫ/ie ~\^0NtԛABzfO_1%Lps^t;zPfK]xc`MNL3I4647OJ20KH4J6K212I01NLLH211* 66414057U02520PH*JKΰ*I-.хr3!l4R b6'(u Ymr&P{f7  Rl̓4x;!~N 6Ę-m<qI Rp|+_H1VGUR2QoNSB" Imn^{14=ψy'8Dakxւyb)F[? "00manifest.i000066400000000000000000000005701333721501700334340ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/store21=lLD_ $;umain.tfba28a773d865976e9ddad6453e890f76524d3356 2Di7{,kBK;G118main_branch.tfb80de5d138758541c5f05265ad144ab9fa86d1db vBbJ^X}ė/cE_kxc`ô|DdKdD$sC$T3$SK 44H1iLn6*golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/store/data/000077500000000000000000000000001333721501700323025ustar00rootroot00000000000000foo.txt.i000066400000000000000000000001071333721501700337740ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/store/dataF̨ɏŠq-YYQuHello main.tf.i000066400000000000000000000001601333721501700337260ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/store/data0/(senE>vRM3Vu# Hello module "foo" { source = "./foo" } main__branch.tf.i000066400000000000000000000001001333721501700353740ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/store/data 8uAReJfncache000066400000000000000000000000641333721501700326240ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/storedata/main.tf.i data/foo.txt.i data/main_branch.tf.i phaseroots000066400000000000000000000000531333721501700334220ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/store1 dcaed7754d58264cb9a5916215a5442377307bd1 golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/store/undo000066400000000000000000000000641333721501700322610ustar00rootroot00000000000000data/foo.txt.i0 00manifest.i246 00changelog.i355 undo.backup.fncache000066400000000000000000000000451333721501700350330ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/storedata/main.tf.i data/main_branch.tf.i undo.backupfiles000066400000000000000000000000411333721501700344640ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/store2 fncacheundo.backup.fncache0 undo.phaseroots000066400000000000000000000000531333721501700343660ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/store1 dcaed7754d58264cb9a5916215a5442377307bd1 undo.bookmarks000066400000000000000000000000001333721501700330230ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hggolang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/undo.branch000066400000000000000000000000071333721501700323560ustar00rootroot00000000000000defaultgolang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hg/undo.desc000066400000000000000000000000111333721501700320320ustar00rootroot000000000000002 commit undo.dirstate000066400000000000000000000001301333721501700326560ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/.hgܮuMX&LbD#w0{afoo.txtn/Vzmain.tfgolang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/foo.txt000066400000000000000000000000061333721501700311010ustar00rootroot00000000000000Hello golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-hg/main.tf000066400000000000000000000000571333721501700310420ustar00rootroot00000000000000# Hello module "foo" { source = "./foo" } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-parent/000077500000000000000000000000001333721501700304545ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-parent/a/000077500000000000000000000000001333721501700306745ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-parent/a/a.tf000066400000000000000000000000431333721501700314440ustar00rootroot00000000000000module "b" { source = "../c" } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-parent/c/000077500000000000000000000000001333721501700306765ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-parent/c/c.tf000066400000000000000000000000101333721501700314420ustar00rootroot00000000000000# Hello golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-parent/main.tf000066400000000000000000000000421333721501700317270ustar00rootroot00000000000000module "a" { source = "./a" } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-subdir/000077500000000000000000000000001333721501700304535ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-subdir/foo/000077500000000000000000000000001333721501700312365ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-subdir/foo/sub/000077500000000000000000000000001333721501700320275ustar00rootroot00000000000000baz/000077500000000000000000000000001333721501700325245ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-subdir/foo/submain.tf000066400000000000000000000000001333721501700337710ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-subdir/foo/sub/bazmain.tf000066400000000000000000000000461333721501700332270ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-subdir/foo/submodule "bar" { source = "./baz" } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-subdir/main.tf000066400000000000000000000000531333721501700317300ustar00rootroot00000000000000module "foo" { source = "./foo//sub" } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-tgz/000077500000000000000000000000001333721501700277675ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic-tgz/main.tf000066400000000000000000000000101333721501700312350ustar00rootroot00000000000000# Hello golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic/000077500000000000000000000000001333721501700271655ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic/foo/000077500000000000000000000000001333721501700277505ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic/foo/main.tf000066400000000000000000000000101333721501700312160ustar00rootroot00000000000000# Hello golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic/main.tf000066400000000000000000000000571333721501700304460ustar00rootroot00000000000000# Hello module "foo" { source = "./foo" } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic/subdir/000077500000000000000000000000001333721501700304555ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/basic/subdir/sub.tf000066400000000000000000000000001333721501700315670ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/child/000077500000000000000000000000001333721501700271675ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/child/foo/000077500000000000000000000000001333721501700277525ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/child/foo/bar/000077500000000000000000000000001333721501700305165ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/child/foo/bar/main.tf000066400000000000000000000000111333721501700317650ustar00rootroot00000000000000# Hello golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/child/foo/main.tf000066400000000000000000000000571333721501700312330ustar00rootroot00000000000000# Hello module "bar" { source = "./bar" } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/child/main.tf000066400000000000000000000000571333721501700304500ustar00rootroot00000000000000# Hello module "foo" { source = "./foo" } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-bz2/000077500000000000000000000000001333721501700307435ustar00rootroot00000000000000single.bz2000066400000000000000000000000501333721501700325570ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-bz2BZh91AY&SYv!]BAϔgolang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-gz/000077500000000000000000000000001333721501700306665ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-gz/single.gz000066400000000000000000000000351333721501700325070ustar00rootroot00000000000000NVfileKe2~golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-tar/000077500000000000000000000000001333721501700310345ustar00rootroot00000000000000extended_header.tar000066400000000000000000000070001333721501700345720ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-tarpax_global_header0000666000000000000000000000006300000000000012642 gustar000000000000000052 comment=7c927eb0c3e261a14e8bfbd365d14e89f8e78cb1directory0000755000000000000000000000000000000000000011132 5ustar0000000000000000directory/a0000644000000000000000000000000000000000000011262 ustar0000000000000000directory/b0000644000000000000000000000000000000000000011263 ustar0000000000000000implied_dir.tar000066400000000000000000000040001333721501700337400ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-tardirectory/sub/a000644 000765 000024 00000000000 00000000000 014521 0ustar00jbardinstaff000000 000000 directory/sub/b000644 000765 000024 00000000000 00000000000 014522 0ustar00jbardinstaff000000 000000 unix_time_0.tar000066400000000000000000000240001333721501700337010ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-tardirectory/0000755000175000017500000000000000000000000013513 5ustar alexandrealexandredirectory/sub/0000755000175000017500000000000000000000000014304 5ustar alexandrealexandredirectory/sub/a0000644000175000017500000000000000000000000014435 0ustar alexandrealexandredirectory/sub/b0000644000175000017500000000000000000000000014436 0ustar alexandrealexandregolang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-tbz2/000077500000000000000000000000001333721501700311275ustar00rootroot00000000000000empty.tar.bz2000066400000000000000000000000561333721501700334130ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-tbz2BZh91AY&SYY{P 0)b'"(H,rmultiple.tar.bz2000066400000000000000000000002461333721501700341110ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-tbz2BZh91AY&SYX@kf(0F4a`Ƙ#LR543F'M/4`@S(aBXfF)d"5IF d:|%ū4V ) JZYQf<컢 ػ)„j/ordering.tar.bz2000066400000000000000000000003701333721501700340650ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-tbz2BZh91AY&SY#=ѐB@@(0CLi a&biCF)=L 44hirϋnp R*k-l !BM'6nLxm`w9dX4rV&20cP!fؕahc&^:M1mW8'7{W1LAoxt5Ǝ]BB3 single.tar.bz2000066400000000000000000000002071333721501700335340ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-tbz2BZh91AY&SYj{@kf t 544P@4 Ka!T$$ZwCMVE8# IG'=f$84t]hThjtisj" "(HQ5lgolang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-tgz/000077500000000000000000000000001333721501700310525ustar00rootroot00000000000000empty.tar.gz000066400000000000000000000000551333721501700332600ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-tgz4V  Om77'(multiple.tar.gz000066400000000000000000000002351333721501700337550ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-tgz8VM 0=E0yD:)hw\RxG`H&O<خ-I!W))߂.|pXo4k/[Y:-qyܘ+c_1<;`?Z[H(multiple_dir.tar.gz000066400000000000000000000003021333721501700346060ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-tgzVM 0=ENg^kPxc[D .bg3L1ɋS7YRZ,T\.WUNDi㌕Liۚ]pb+.ۺ7ⲦYgǣ|?cΈE/1'>^ۺ l%f$=w;o`}7,F(ordering.tar.gz000066400000000000000000000002731333721501700337350ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-tgzX 0E+1Y$ZH  Es۸ 1c}shR XctSBjN!iH+x)m$+]ȱ=~돰!./6wt꿡b&yK& jΟa$ outside_parent.tar.gz000066400000000000000000000003001333721501700351400ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-tgz5Zpoc.tarӽ0\E;-xOJ޿] &Y_rr8N͗b/*JyJg\#Rs f(_pbR\܇^5ƒ?xHL.K9?vU$u7Yj`R(single.tar.gz000066400000000000000000000002111333721501700333750ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-tgzg6VA 0a=aLbz7qBJ6axwN|fM5e8w6hm՚Jbgj߹k>OGd?ftl(golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-txz/000077500000000000000000000000001333721501700310735ustar00rootroot00000000000000empty.tar.xz000066400000000000000000000001541333721501700333220ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-txz7zXZִF!t/',]oG>Hr9aQ(棆/:<K~Ɋ\2d/U3HPZgYZmultiple.tar.xz000066400000000000000000000003141333721501700340150ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-txz7zXZִF!t/']3IָJ^R:Xr0+sNk3vJoUQJ{FWf>EӂoJh{}82c,͠䡒a )r?l)? _:S=sz?1j,:.m؅j=B\=-7+cZ2tj`OB$)V[8>Jq PdgYZordering.tar.xz000066400000000000000000000003341333721501700337750ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-txz7zXZִF!t/ ];ʫ_̉'G'@[Kٶ`|+p.ǔmT@SˍcLP~vnbI !+[Ϩ1Q 1#Iƈvl'24h8FQƵsk]XL<fO9T|9g_O:X;^KgYZsingle.tar.xz000066400000000000000000000003001333721501700334360ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-txz7zXZִF!t/'}]3Iֶ8!ٯU?pJɄy7}BϖrΗ^ H!U=)O/>֦xqƤU+tֽ3=3s"p[ CѪt?Lm?{MCPm"EgYZgolang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-xz/000077500000000000000000000000001333721501700307075ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-xz/single.xz000066400000000000000000000000741333721501700325540ustar00rootroot000000000000007zXZִF!t/foo ׬Z01o,}YZgolang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-zip/000077500000000000000000000000001333721501700310505ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-zip/empty.zip000066400000000000000000000000261333721501700327300ustar00rootroot00000000000000PKmultiple.zip000066400000000000000000000004621333721501700333520ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-zipPK T,He2~file1UT GVGVux foo PK T,He2~file2UT GVGVux foo PK T,He2~file1UTGVux PK T,He2~Cfile2UTGVux PKoutside_parent.zip000066400000000000000000000003551333721501700345450ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-zipPKYzL&H ../demo.poc#!/bin/sh echo Hello World PKYzLmain.tfPKYzL&H ../demo.pocPKYzLDmain.tfPKnisingle.zip000066400000000000000000000002421333721501700327740ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-zipPK LT,He2~fileUT 0GV3GVux foo PK LT,He2~fileUT0GVux PKJBsubdir.zip000066400000000000000000000007221333721501700330060ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-zipPK ruH 0:6file1UT eVeVux hello PK ruHsubdir/UT ifVifVux PK ruH 0:6 subdir/childUT eVeVux hello PK ruH 0:6file1UTeVux PK ruHAEsubdir/UTifVux PK ruH 0:6 subdir/childUTeVux PKsubdir_empty.zip000066400000000000000000000004641333721501700342270ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-zipPK ruH 0:6file1UT eVlfVux hello PK ruHsubdir/UT ifVsfVux PK ruH 0:6file1UTeVux PK ruHAEsubdir/UTifVux PKsubdir_missing_dir.zip000066400000000000000000000005041333721501700353730ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/decompress-zipPK ruH 0:6file1UT eVzfVux hello PK suH 0:6 subdir/childUT fVfVux hello PK ruH 0:6file1UTeVux PK suH 0:6 Esubdir/childUTfVux PKgolang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/detect-file-symlink-pwd/000077500000000000000000000000001333721501700325455ustar00rootroot00000000000000real/000077500000000000000000000000001333721501700334115ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/detect-file-symlink-pwdhello.txt000066400000000000000000000000001333721501700352430ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/detect-file-symlink-pwd/realsyml/000077500000000000000000000000001333721501700334525ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/detect-file-symlink-pwdpwd000077700000000000000000000000001333721501700352432../realustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/detect-file-symlink-pwd/symlgolang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/dup/000077500000000000000000000000001333721501700266745ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/dup/foo/000077500000000000000000000000001333721501700274575ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/dup/foo/main.tf000066400000000000000000000000001333721501700307240ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/dup/main.tf000066400000000000000000000001151333721501700301500ustar00rootroot00000000000000module "foo" { source = "./foo" } module "foo" { source = "./foo" } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/netrc/000077500000000000000000000000001333721501700272175ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/netrc/basic000066400000000000000000000000531333721501700302210ustar00rootroot00000000000000machine example.com login foo password bar validate-bad-output-to-module/000077500000000000000000000000001333721501700336035ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtureschild/000077500000000000000000000000001333721501700346665ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-bad-output-to-modulemain.tf000066400000000000000000000000461333721501700361450ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-bad-output-to-module/childvariable "memory" { default = "foo" } main.tf000066400000000000000000000002001333721501700350520ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-bad-output-to-modulemodule "child" { source = "./child" } module "child2" { source = "./child" memory = "${module.child.memory_max}" } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-bad-output/000077500000000000000000000000001333721501700317575ustar00rootroot00000000000000child/000077500000000000000000000000001333721501700327635ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-bad-outputmain.tf000066400000000000000000000000001333721501700342300ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-bad-output/childmain.tf000066400000000000000000000001631333721501700331570ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-bad-outputmodule "child" { source = "./child" } resource "aws_instance" "foo" { memory = "${module.child.memory}" } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-bad-var/000077500000000000000000000000001333721501700312075ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-bad-var/child/000077500000000000000000000000001333721501700322725ustar00rootroot00000000000000main.tf000066400000000000000000000000001333721501700334600ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-bad-var/childgolang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-bad-var/main.tf000066400000000000000000000000761333721501700324710ustar00rootroot00000000000000module "child" { source = "./child" memory = "foo" } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-child-bad/000077500000000000000000000000001333721501700315025ustar00rootroot00000000000000child/000077500000000000000000000000001333721501700325065ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-child-badmain.tf000066400000000000000000000001301333721501700337570ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-child-bad/child# Duplicate resources resource "aws_instance" "foo" {} resource "aws_instance" "foo" {} main.tf000066400000000000000000000000501333721501700326750ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-child-badmodule "foo" { source = "./child" } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-child-good/000077500000000000000000000000001333721501700317045ustar00rootroot00000000000000child/000077500000000000000000000000001333721501700327105ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-child-goodmain.tf000066400000000000000000000000511333721501700341630ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-child-good/childvariable "memory" {} output "result" {} main.tf000066400000000000000000000002051333721501700331010ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-child-goodmodule "child" { source = "./child" memory = "1G" } resource "aws_instance" "foo" { memory = "${module.child.result}" } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-required-var/000077500000000000000000000000001333721501700323015ustar00rootroot00000000000000child/000077500000000000000000000000001333721501700333055ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-required-varmain.tf000066400000000000000000000000251333721501700345610ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-required-var/childvariable "memory" {} main.tf000066400000000000000000000000521333721501700334760ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-required-varmodule "child" { source = "./child" } golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-root-bad/000077500000000000000000000000001333721501700314025ustar00rootroot00000000000000main.tf000066400000000000000000000001301333721501700325740ustar00rootroot00000000000000golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/test-fixtures/validate-root-bad# Duplicate resources resource "aws_instance" "foo" {} resource "aws_instance" "foo" {} golang-github-jesseduffield-go-getter-0.0~git20180822.906e156/util_test.go000066400000000000000000000016631333721501700256270ustar00rootroot00000000000000package getter import ( "io" "io/ioutil" "os" "strings" "testing" ) // tempEnv sets the env var temporarily and returns a function that should // be deferred to clean it up. func tempEnv(t *testing.T, k, v string) func() { old := os.Getenv(k) // Set env if err := os.Setenv(k, v); err != nil { t.Fatalf("err: %s", err) } // Easy cleanup return func() { if err := os.Setenv(k, old); err != nil { t.Fatalf("err: %s", err) } } } // tempFileContents writes a temporary file and returns the path and a function // to clean it up. func tempFileContents(t *testing.T, contents string) (string, func()) { tf, err := ioutil.TempFile("", "getter") if err != nil { t.Fatalf("err: %s", err) } if _, err := io.Copy(tf, strings.NewReader(contents)); err != nil { t.Fatalf("err: %s", err) } tf.Close() path := tf.Name() return path, func() { if err := os.Remove(path); err != nil { t.Fatalf("err: %s", err) } } }