├── .github ├── CODE_OF_CONDUCT.md ├── ISSUE_TEMPLATE.md └── SUPPORT.md ├── .gitignore ├── .travis.yml ├── CHANGELOG.md ├── GNUmakefile ├── Gopkg.lock ├── Gopkg.toml ├── LICENSE ├── README.md ├── examples ├── README.md └── auth │ ├── README.md │ └── main.tf ├── firebase ├── config.go ├── provider.go ├── provider_test.go ├── resource_firebase_user.go ├── resource_firebase_user_migrate.go ├── resource_firebase_user_test.go └── validators.go ├── main.go ├── scripts ├── changelog-links.sh ├── errcheck.sh ├── gofmtcheck.sh └── gogetcookie.sh ├── vendor ├── cloud.google.com │ └── go │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── LICENSE │ │ ├── compute │ │ └── metadata │ │ │ └── metadata.go │ │ ├── firestore │ │ ├── Makefile │ │ ├── apiv1beta1 │ │ │ ├── doc.go │ │ │ ├── firestore_client.go │ │ │ └── path_funcs.go │ │ ├── client.go │ │ ├── collref.go │ │ ├── doc.go │ │ ├── docref.go │ │ ├── document.go │ │ ├── fieldpath.go │ │ ├── from_value.go │ │ ├── options.go │ │ ├── order.go │ │ ├── query.go │ │ ├── to_value.go │ │ ├── transaction.go │ │ ├── watch.go │ │ └── writebatch.go │ │ ├── iam │ │ └── iam.go │ │ ├── internal │ │ ├── annotate.go │ │ ├── atomiccache │ │ │ └── atomiccache.go │ │ ├── btree │ │ │ ├── README.md │ │ │ ├── btree.go │ │ │ └── debug.go │ │ ├── fields │ │ │ ├── fields.go │ │ │ └── fold.go │ │ ├── optional │ │ │ └── optional.go │ │ ├── retry.go │ │ ├── trace │ │ │ ├── go18.go │ │ │ └── not_go18.go │ │ └── version │ │ │ ├── update_version.sh │ │ │ └── version.go │ │ └── storage │ │ ├── acl.go │ │ ├── bucket.go │ │ ├── copy.go │ │ ├── doc.go │ │ ├── go110.go │ │ ├── go17.go │ │ ├── iam.go │ │ ├── invoke.go │ │ ├── not_go110.go │ │ ├── not_go17.go │ │ ├── notifications.go │ │ ├── reader.go │ │ ├── storage.go │ │ ├── storage.replay │ │ └── writer.go ├── firebase.google.com │ └── go │ │ ├── .gitignore │ │ ├── .travis.gofmt.sh │ │ ├── .travis.yml │ │ ├── CHANGELOG.md │ │ ├── CONTRIBUTING.md │ │ ├── ISSUE_TEMPLATE.md │ │ ├── LICENSE │ │ ├── PULL_REQUEST_TEMPLATE.md │ │ ├── README.md │ │ ├── auth │ │ ├── auth.go │ │ ├── auth_appengine.go │ │ ├── auth_std.go │ │ ├── crypto.go │ │ ├── jwt.go │ │ └── user_mgt.go │ │ ├── db │ │ ├── db.go │ │ ├── query.go │ │ └── ref.go │ │ ├── firebase.go │ │ ├── iid │ │ └── iid.go │ │ ├── internal │ │ ├── http_client.go │ │ └── internal.go │ │ ├── messaging │ │ ├── messaging.go │ │ └── messaging_utils.go │ │ └── storage │ │ └── storage.go ├── github.com │ ├── agext │ │ └── levenshtein │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── DCO │ │ │ ├── LICENSE │ │ │ ├── MAINTAINERS │ │ │ ├── NOTICE │ │ │ ├── README.md │ │ │ ├── levenshtein.go │ │ │ └── params.go │ ├── apparentlymart │ │ ├── go-cidr │ │ │ ├── LICENSE │ │ │ └── cidr │ │ │ │ ├── cidr.go │ │ │ │ └── wrangling.go │ │ └── go-textseg │ │ │ ├── LICENSE │ │ │ └── textseg │ │ │ ├── all_tokens.go │ │ │ ├── generate.go │ │ │ ├── grapheme_clusters.go │ │ │ ├── grapheme_clusters.rl │ │ │ ├── grapheme_clusters_table.rl │ │ │ ├── make_tables.go │ │ │ ├── make_test_tables.go │ │ │ ├── tables.go │ │ │ ├── unicode2ragel.rb │ │ │ └── utf8_seqs.go │ ├── armon │ │ └── go-radix │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ └── radix.go │ ├── aws │ │ └── aws-sdk-go │ │ │ ├── LICENSE.txt │ │ │ ├── NOTICE.txt │ │ │ ├── aws │ │ │ ├── awserr │ │ │ │ ├── error.go │ │ │ │ └── types.go │ │ │ ├── awsutil │ │ │ │ ├── copy.go │ │ │ │ ├── equal.go │ │ │ │ ├── path_value.go │ │ │ │ ├── prettify.go │ │ │ │ └── string_value.go │ │ │ ├── client │ │ │ │ ├── client.go │ │ │ │ ├── default_retryer.go │ │ │ │ ├── logger.go │ │ │ │ └── metadata │ │ │ │ │ └── client_info.go │ │ │ ├── config.go │ │ │ ├── context.go │ │ │ ├── context_1_6.go │ │ │ ├── context_1_7.go │ │ │ ├── convert_types.go │ │ │ ├── corehandlers │ │ │ │ ├── handlers.go │ │ │ │ ├── param_validator.go │ │ │ │ └── user_agent.go │ │ │ ├── credentials │ │ │ │ ├── chain_provider.go │ │ │ │ ├── credentials.go │ │ │ │ ├── ec2rolecreds │ │ │ │ │ └── ec2_role_provider.go │ │ │ │ ├── endpointcreds │ │ │ │ │ └── provider.go │ │ │ │ ├── env_provider.go │ │ │ │ ├── example.ini │ │ │ │ ├── shared_credentials_provider.go │ │ │ │ ├── static_provider.go │ │ │ │ └── stscreds │ │ │ │ │ └── assume_role_provider.go │ │ │ ├── csm │ │ │ │ ├── doc.go │ │ │ │ ├── enable.go │ │ │ │ ├── metric.go │ │ │ │ ├── metric_chan.go │ │ │ │ └── reporter.go │ │ │ ├── defaults │ │ │ │ ├── defaults.go │ │ │ │ └── shared_config.go │ │ │ ├── doc.go │ │ │ ├── ec2metadata │ │ │ │ ├── api.go │ │ │ │ └── service.go │ │ │ ├── endpoints │ │ │ │ ├── decode.go │ │ │ │ ├── defaults.go │ │ │ │ ├── doc.go │ │ │ │ ├── endpoints.go │ │ │ │ ├── v3model.go │ │ │ │ └── v3model_codegen.go │ │ │ ├── errors.go │ │ │ ├── jsonvalue.go │ │ │ ├── logger.go │ │ │ ├── request │ │ │ │ ├── connection_reset_error.go │ │ │ │ ├── connection_reset_error_other.go │ │ │ │ ├── handlers.go │ │ │ │ ├── http_request.go │ │ │ │ ├── offset_reader.go │ │ │ │ ├── request.go │ │ │ │ ├── request_1_7.go │ │ │ │ ├── request_1_8.go │ │ │ │ ├── request_context.go │ │ │ │ ├── request_context_1_6.go │ │ │ │ ├── request_pagination.go │ │ │ │ ├── retryer.go │ │ │ │ ├── timeout_read_closer.go │ │ │ │ ├── validation.go │ │ │ │ └── waiter.go │ │ │ ├── session │ │ │ │ ├── doc.go │ │ │ │ ├── env_config.go │ │ │ │ ├── session.go │ │ │ │ └── shared_config.go │ │ │ ├── signer │ │ │ │ └── v4 │ │ │ │ │ ├── header_rules.go │ │ │ │ │ ├── options.go │ │ │ │ │ ├── uri_path.go │ │ │ │ │ └── v4.go │ │ │ ├── types.go │ │ │ ├── url.go │ │ │ ├── url_1_7.go │ │ │ └── version.go │ │ │ ├── internal │ │ │ ├── sdkio │ │ │ │ ├── io_go1.6.go │ │ │ │ └── io_go1.7.go │ │ │ ├── sdkrand │ │ │ │ └── locked_source.go │ │ │ ├── sdkuri │ │ │ │ └── path.go │ │ │ └── shareddefaults │ │ │ │ └── shared_config.go │ │ │ ├── private │ │ │ └── protocol │ │ │ │ ├── ec2query │ │ │ │ ├── build.go │ │ │ │ └── unmarshal.go │ │ │ │ ├── eventstream │ │ │ │ ├── debug.go │ │ │ │ ├── decode.go │ │ │ │ ├── encode.go │ │ │ │ ├── error.go │ │ │ │ ├── eventstreamapi │ │ │ │ │ ├── api.go │ │ │ │ │ └── error.go │ │ │ │ ├── header.go │ │ │ │ ├── header_value.go │ │ │ │ └── message.go │ │ │ │ ├── idempotency.go │ │ │ │ ├── jsonvalue.go │ │ │ │ ├── payload.go │ │ │ │ ├── query │ │ │ │ ├── build.go │ │ │ │ ├── queryutil │ │ │ │ │ └── queryutil.go │ │ │ │ ├── unmarshal.go │ │ │ │ └── unmarshal_error.go │ │ │ │ ├── rest │ │ │ │ ├── build.go │ │ │ │ ├── payload.go │ │ │ │ └── unmarshal.go │ │ │ │ ├── restxml │ │ │ │ └── restxml.go │ │ │ │ ├── unmarshal.go │ │ │ │ └── xml │ │ │ │ └── xmlutil │ │ │ │ ├── build.go │ │ │ │ ├── unmarshal.go │ │ │ │ └── xml_to_struct.go │ │ │ └── service │ │ │ ├── ec2 │ │ │ ├── api.go │ │ │ ├── customizations.go │ │ │ ├── doc.go │ │ │ ├── errors.go │ │ │ ├── service.go │ │ │ └── waiters.go │ │ │ ├── s3 │ │ │ ├── api.go │ │ │ ├── body_hash.go │ │ │ ├── bucket_location.go │ │ │ ├── customizations.go │ │ │ ├── doc.go │ │ │ ├── doc_custom.go │ │ │ ├── errors.go │ │ │ ├── host_style_bucket.go │ │ │ ├── platform_handlers.go │ │ │ ├── platform_handlers_go1.6.go │ │ │ ├── service.go │ │ │ ├── sse.go │ │ │ ├── statusok_error.go │ │ │ ├── unmarshal_error.go │ │ │ └── waiters.go │ │ │ └── sts │ │ │ ├── api.go │ │ │ ├── customizations.go │ │ │ ├── doc.go │ │ │ ├── errors.go │ │ │ └── service.go │ ├── bgentry │ │ ├── go-netrc │ │ │ ├── LICENSE │ │ │ └── netrc │ │ │ │ └── netrc.go │ │ └── speakeasy │ │ │ ├── .gitignore │ │ │ ├── LICENSE │ │ │ ├── LICENSE_WINDOWS │ │ │ ├── Readme.md │ │ │ ├── speakeasy.go │ │ │ ├── speakeasy_unix.go │ │ │ └── speakeasy_windows.go │ ├── blang │ │ └── semver │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── json.go │ │ │ ├── package.json │ │ │ ├── range.go │ │ │ ├── semver.go │ │ │ ├── sort.go │ │ │ └── sql.go │ ├── davecgh │ │ └── go-spew │ │ │ ├── LICENSE │ │ │ └── spew │ │ │ ├── bypass.go │ │ │ ├── bypasssafe.go │ │ │ ├── common.go │ │ │ ├── config.go │ │ │ ├── doc.go │ │ │ ├── dump.go │ │ │ ├── format.go │ │ │ └── spew.go │ ├── fatih │ │ └── color │ │ │ ├── .travis.yml │ │ │ ├── Gopkg.lock │ │ │ ├── Gopkg.toml │ │ │ ├── LICENSE.md │ │ │ ├── README.md │ │ │ ├── color.go │ │ │ └── doc.go │ ├── go-ini │ │ └── ini │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── error.go │ │ │ ├── file.go │ │ │ ├── ini.go │ │ │ ├── key.go │ │ │ ├── parser.go │ │ │ ├── section.go │ │ │ └── struct.go │ ├── golang │ │ └── protobuf │ │ │ ├── AUTHORS │ │ │ ├── CONTRIBUTORS │ │ │ ├── LICENSE │ │ │ ├── proto │ │ │ ├── clone.go │ │ │ ├── decode.go │ │ │ ├── discard.go │ │ │ ├── encode.go │ │ │ ├── equal.go │ │ │ ├── extensions.go │ │ │ ├── lib.go │ │ │ ├── message_set.go │ │ │ ├── pointer_reflect.go │ │ │ ├── pointer_unsafe.go │ │ │ ├── properties.go │ │ │ ├── table_marshal.go │ │ │ ├── table_merge.go │ │ │ ├── table_unmarshal.go │ │ │ ├── text.go │ │ │ └── text_parser.go │ │ │ ├── protoc-gen-go │ │ │ └── descriptor │ │ │ │ ├── descriptor.pb.go │ │ │ │ └── descriptor.proto │ │ │ └── ptypes │ │ │ ├── any.go │ │ │ ├── any │ │ │ ├── any.pb.go │ │ │ └── any.proto │ │ │ ├── doc.go │ │ │ ├── duration.go │ │ │ ├── duration │ │ │ ├── duration.pb.go │ │ │ └── duration.proto │ │ │ ├── empty │ │ │ ├── empty.pb.go │ │ │ └── empty.proto │ │ │ ├── struct │ │ │ ├── struct.pb.go │ │ │ └── struct.proto │ │ │ ├── timestamp.go │ │ │ ├── timestamp │ │ │ ├── timestamp.pb.go │ │ │ └── timestamp.proto │ │ │ └── wrappers │ │ │ ├── wrappers.pb.go │ │ │ └── wrappers.proto │ ├── googleapis │ │ └── gax-go │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── CONTRIBUTING.md │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── call_option.go │ │ │ ├── gax.go │ │ │ ├── header.go │ │ │ └── invoke.go │ ├── hashicorp │ │ ├── errwrap │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ └── errwrap.go │ │ ├── go-cleanhttp │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── cleanhttp.go │ │ │ ├── doc.go │ │ │ └── handlers.go │ │ ├── go-getter │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── appveyor.yml │ │ │ ├── client.go │ │ │ ├── client_mode.go │ │ │ ├── copy_dir.go │ │ │ ├── decompress.go │ │ │ ├── decompress_bzip2.go │ │ │ ├── decompress_gzip.go │ │ │ ├── decompress_tar.go │ │ │ ├── decompress_tbz2.go │ │ │ ├── decompress_testing.go │ │ │ ├── decompress_tgz.go │ │ │ ├── decompress_txz.go │ │ │ ├── decompress_xz.go │ │ │ ├── decompress_zip.go │ │ │ ├── detect.go │ │ │ ├── detect_bitbucket.go │ │ │ ├── detect_file.go │ │ │ ├── detect_github.go │ │ │ ├── detect_s3.go │ │ │ ├── folder_storage.go │ │ │ ├── get.go │ │ │ ├── get_file.go │ │ │ ├── get_file_unix.go │ │ │ ├── get_file_windows.go │ │ │ ├── get_git.go │ │ │ ├── get_hg.go │ │ │ ├── get_http.go │ │ │ ├── get_mock.go │ │ │ ├── get_s3.go │ │ │ ├── helper │ │ │ │ └── url │ │ │ │ │ ├── url.go │ │ │ │ │ ├── url_unix.go │ │ │ │ │ └── url_windows.go │ │ │ ├── netrc.go │ │ │ ├── source.go │ │ │ ├── storage.go │ │ │ └── test-fixtures │ │ │ │ └── detect-file-symlink-pwd │ │ │ │ └── syml │ │ │ │ └── pwd │ │ ├── go-hclog │ │ │ ├── .gitignore │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── global.go │ │ │ ├── int.go │ │ │ ├── log.go │ │ │ ├── nulllogger.go │ │ │ ├── stacktrace.go │ │ │ └── stdlog.go │ │ ├── go-multierror │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── append.go │ │ │ ├── flatten.go │ │ │ ├── format.go │ │ │ ├── multierror.go │ │ │ ├── prefix.go │ │ │ └── sort.go │ │ ├── go-plugin │ │ │ ├── .gitignore │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── client.go │ │ │ ├── discover.go │ │ │ ├── error.go │ │ │ ├── grpc_broker.go │ │ │ ├── grpc_broker.pb.go │ │ │ ├── grpc_broker.proto │ │ │ ├── grpc_client.go │ │ │ ├── grpc_server.go │ │ │ ├── log_entry.go │ │ │ ├── mux_broker.go │ │ │ ├── plugin.go │ │ │ ├── process.go │ │ │ ├── process_posix.go │ │ │ ├── process_windows.go │ │ │ ├── protocol.go │ │ │ ├── rpc_client.go │ │ │ ├── rpc_server.go │ │ │ ├── server.go │ │ │ ├── server_mux.go │ │ │ ├── stream.go │ │ │ └── testing.go │ │ ├── go-safetemp │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ └── safetemp.go │ │ ├── go-uuid │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ └── uuid.go │ │ ├── go-version │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── constraint.go │ │ │ ├── version.go │ │ │ └── version_collection.go │ │ ├── hcl │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── appveyor.yml │ │ │ ├── decoder.go │ │ │ ├── hcl.go │ │ │ ├── hcl │ │ │ │ ├── ast │ │ │ │ │ ├── ast.go │ │ │ │ │ └── walk.go │ │ │ │ ├── parser │ │ │ │ │ ├── error.go │ │ │ │ │ └── parser.go │ │ │ │ ├── scanner │ │ │ │ │ └── scanner.go │ │ │ │ ├── strconv │ │ │ │ │ └── quote.go │ │ │ │ └── token │ │ │ │ │ ├── position.go │ │ │ │ │ └── token.go │ │ │ ├── json │ │ │ │ ├── parser │ │ │ │ │ ├── flatten.go │ │ │ │ │ └── parser.go │ │ │ │ ├── scanner │ │ │ │ │ └── scanner.go │ │ │ │ └── token │ │ │ │ │ ├── position.go │ │ │ │ │ └── token.go │ │ │ ├── lex.go │ │ │ └── parse.go │ │ ├── hcl2 │ │ │ ├── LICENSE │ │ │ ├── gohcl │ │ │ │ ├── decode.go │ │ │ │ ├── doc.go │ │ │ │ ├── schema.go │ │ │ │ └── types.go │ │ │ ├── hcl │ │ │ │ ├── diagnostic.go │ │ │ │ ├── diagnostic_text.go │ │ │ │ ├── didyoumean.go │ │ │ │ ├── doc.go │ │ │ │ ├── eval_context.go │ │ │ │ ├── expr_call.go │ │ │ │ ├── expr_list.go │ │ │ │ ├── expr_map.go │ │ │ │ ├── expr_unwrap.go │ │ │ │ ├── hclsyntax │ │ │ │ │ ├── didyoumean.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── expression.go │ │ │ │ │ ├── expression_ops.go │ │ │ │ │ ├── expression_template.go │ │ │ │ │ ├── expression_vars.go │ │ │ │ │ ├── expression_vars_gen.go │ │ │ │ │ ├── file.go │ │ │ │ │ ├── generate.go │ │ │ │ │ ├── keywords.go │ │ │ │ │ ├── navigation.go │ │ │ │ │ ├── node.go │ │ │ │ │ ├── parser.go │ │ │ │ │ ├── parser_template.go │ │ │ │ │ ├── parser_traversal.go │ │ │ │ │ ├── peeker.go │ │ │ │ │ ├── public.go │ │ │ │ │ ├── scan_string_lit.go │ │ │ │ │ ├── scan_string_lit.rl │ │ │ │ │ ├── scan_tokens.go │ │ │ │ │ ├── scan_tokens.rl │ │ │ │ │ ├── spec.md │ │ │ │ │ ├── structure.go │ │ │ │ │ ├── token.go │ │ │ │ │ ├── token_type_string.go │ │ │ │ │ ├── unicode2ragel.rb │ │ │ │ │ ├── unicode_derived.rl │ │ │ │ │ ├── variables.go │ │ │ │ │ └── walk.go │ │ │ │ ├── json │ │ │ │ │ ├── ast.go │ │ │ │ │ ├── didyoumean.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── navigation.go │ │ │ │ │ ├── parser.go │ │ │ │ │ ├── peeker.go │ │ │ │ │ ├── public.go │ │ │ │ │ ├── scanner.go │ │ │ │ │ ├── spec.md │ │ │ │ │ ├── structure.go │ │ │ │ │ └── tokentype_string.go │ │ │ │ ├── merged.go │ │ │ │ ├── ops.go │ │ │ │ ├── pos.go │ │ │ │ ├── pos_scanner.go │ │ │ │ ├── schema.go │ │ │ │ ├── spec.md │ │ │ │ ├── static_expr.go │ │ │ │ ├── structure.go │ │ │ │ ├── traversal.go │ │ │ │ └── traversal_for_expr.go │ │ │ ├── hcldec │ │ │ │ ├── block_labels.go │ │ │ │ ├── decode.go │ │ │ │ ├── doc.go │ │ │ │ ├── gob.go │ │ │ │ ├── public.go │ │ │ │ ├── schema.go │ │ │ │ ├── spec.go │ │ │ │ └── variables.go │ │ │ └── hclparse │ │ │ │ └── parser.go │ │ ├── hil │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── appveyor.yml │ │ │ ├── ast │ │ │ │ ├── arithmetic.go │ │ │ │ ├── arithmetic_op.go │ │ │ │ ├── ast.go │ │ │ │ ├── call.go │ │ │ │ ├── conditional.go │ │ │ │ ├── index.go │ │ │ │ ├── literal.go │ │ │ │ ├── output.go │ │ │ │ ├── scope.go │ │ │ │ ├── stack.go │ │ │ │ ├── type_string.go │ │ │ │ ├── unknown.go │ │ │ │ ├── variable_access.go │ │ │ │ └── variables_helper.go │ │ │ ├── builtins.go │ │ │ ├── check_identifier.go │ │ │ ├── check_types.go │ │ │ ├── convert.go │ │ │ ├── eval.go │ │ │ ├── eval_type.go │ │ │ ├── evaltype_string.go │ │ │ ├── parse.go │ │ │ ├── parser │ │ │ │ ├── binary_op.go │ │ │ │ ├── error.go │ │ │ │ ├── fuzz.go │ │ │ │ └── parser.go │ │ │ ├── scanner │ │ │ │ ├── peeker.go │ │ │ │ ├── scanner.go │ │ │ │ ├── token.go │ │ │ │ └── tokentype_string.go │ │ │ ├── transform_fixed.go │ │ │ └── walk.go │ │ ├── logutils │ │ │ ├── .gitignore │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ └── level.go │ │ ├── terraform │ │ │ ├── LICENSE │ │ │ ├── config │ │ │ │ ├── append.go │ │ │ │ ├── config.go │ │ │ │ ├── config_string.go │ │ │ │ ├── config_terraform.go │ │ │ │ ├── config_tree.go │ │ │ │ ├── configschema │ │ │ │ │ ├── decoder_spec.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── implied_type.go │ │ │ │ │ ├── internal_validate.go │ │ │ │ │ ├── nestingmode_string.go │ │ │ │ │ └── schema.go │ │ │ │ ├── hcl2_shim_util.go │ │ │ │ ├── hcl2shim │ │ │ │ │ ├── single_attr_body.go │ │ │ │ │ └── values.go │ │ │ │ ├── import_tree.go │ │ │ │ ├── interpolate.go │ │ │ │ ├── interpolate_funcs.go │ │ │ │ ├── interpolate_walk.go │ │ │ │ ├── lang.go │ │ │ │ ├── loader.go │ │ │ │ ├── loader_hcl.go │ │ │ │ ├── loader_hcl2.go │ │ │ │ ├── merge.go │ │ │ │ ├── module │ │ │ │ │ ├── copy_dir.go │ │ │ │ │ ├── get.go │ │ │ │ │ ├── inode.go │ │ │ │ │ ├── inode_freebsd.go │ │ │ │ │ ├── inode_windows.go │ │ │ │ │ ├── module.go │ │ │ │ │ ├── storage.go │ │ │ │ │ ├── testing.go │ │ │ │ │ ├── tree.go │ │ │ │ │ ├── tree_gob.go │ │ │ │ │ ├── validate_provider_alias.go │ │ │ │ │ └── versions.go │ │ │ │ ├── providers.go │ │ │ │ ├── provisioner_enums.go │ │ │ │ ├── raw_config.go │ │ │ │ ├── resource_mode.go │ │ │ │ ├── resource_mode_string.go │ │ │ │ └── testing.go │ │ │ ├── dag │ │ │ │ ├── dag.go │ │ │ │ ├── dot.go │ │ │ │ ├── edge.go │ │ │ │ ├── graph.go │ │ │ │ ├── marshal.go │ │ │ │ ├── set.go │ │ │ │ ├── tarjan.go │ │ │ │ └── walk.go │ │ │ ├── flatmap │ │ │ │ ├── expand.go │ │ │ │ ├── flatten.go │ │ │ │ └── map.go │ │ │ ├── helper │ │ │ │ ├── acctest │ │ │ │ │ ├── acctest.go │ │ │ │ │ ├── random.go │ │ │ │ │ └── remotetests.go │ │ │ │ ├── config │ │ │ │ │ ├── decode.go │ │ │ │ │ └── validator.go │ │ │ │ ├── hashcode │ │ │ │ │ └── hashcode.go │ │ │ │ ├── hilmapstructure │ │ │ │ │ └── hilmapstructure.go │ │ │ │ ├── logging │ │ │ │ │ ├── logging.go │ │ │ │ │ └── transport.go │ │ │ │ ├── pathorcontents │ │ │ │ │ └── read.go │ │ │ │ ├── resource │ │ │ │ │ ├── error.go │ │ │ │ │ ├── id.go │ │ │ │ │ ├── map.go │ │ │ │ │ ├── resource.go │ │ │ │ │ ├── state.go │ │ │ │ │ ├── testing.go │ │ │ │ │ ├── testing_config.go │ │ │ │ │ ├── testing_import_state.go │ │ │ │ │ └── wait.go │ │ │ │ ├── schema │ │ │ │ │ ├── README.md │ │ │ │ │ ├── backend.go │ │ │ │ │ ├── core_schema.go │ │ │ │ │ ├── data_source_resource_shim.go │ │ │ │ │ ├── equal.go │ │ │ │ │ ├── field_reader.go │ │ │ │ │ ├── field_reader_config.go │ │ │ │ │ ├── field_reader_diff.go │ │ │ │ │ ├── field_reader_map.go │ │ │ │ │ ├── field_reader_multi.go │ │ │ │ │ ├── field_writer.go │ │ │ │ │ ├── field_writer_map.go │ │ │ │ │ ├── getsource_string.go │ │ │ │ │ ├── provider.go │ │ │ │ │ ├── provisioner.go │ │ │ │ │ ├── resource.go │ │ │ │ │ ├── resource_data.go │ │ │ │ │ ├── resource_data_get_source.go │ │ │ │ │ ├── resource_diff.go │ │ │ │ │ ├── resource_importer.go │ │ │ │ │ ├── resource_timeout.go │ │ │ │ │ ├── schema.go │ │ │ │ │ ├── serialize.go │ │ │ │ │ ├── set.go │ │ │ │ │ ├── testing.go │ │ │ │ │ ├── valuetype.go │ │ │ │ │ └── valuetype_string.go │ │ │ │ ├── structure │ │ │ │ │ ├── expand_json.go │ │ │ │ │ ├── flatten_json.go │ │ │ │ │ ├── normalize_json.go │ │ │ │ │ └── suppress_json_diff.go │ │ │ │ └── validation │ │ │ │ │ └── validation.go │ │ │ ├── httpclient │ │ │ │ ├── client.go │ │ │ │ └── useragent.go │ │ │ ├── moduledeps │ │ │ │ ├── dependencies.go │ │ │ │ ├── doc.go │ │ │ │ ├── module.go │ │ │ │ └── provider.go │ │ │ ├── plugin │ │ │ │ ├── client.go │ │ │ │ ├── discovery │ │ │ │ │ ├── error.go │ │ │ │ │ ├── find.go │ │ │ │ │ ├── get.go │ │ │ │ │ ├── get_cache.go │ │ │ │ │ ├── meta.go │ │ │ │ │ ├── meta_set.go │ │ │ │ │ ├── requirements.go │ │ │ │ │ ├── signature.go │ │ │ │ │ ├── version.go │ │ │ │ │ └── version_set.go │ │ │ │ ├── plugin.go │ │ │ │ ├── resource_provider.go │ │ │ │ ├── resource_provisioner.go │ │ │ │ ├── serve.go │ │ │ │ ├── ui_input.go │ │ │ │ └── ui_output.go │ │ │ ├── registry │ │ │ │ ├── client.go │ │ │ │ ├── errors.go │ │ │ │ ├── regsrc │ │ │ │ │ ├── friendly_host.go │ │ │ │ │ ├── module.go │ │ │ │ │ └── regsrc.go │ │ │ │ └── response │ │ │ │ │ ├── module.go │ │ │ │ │ ├── module_list.go │ │ │ │ │ ├── module_provider.go │ │ │ │ │ ├── module_versions.go │ │ │ │ │ ├── pagination.go │ │ │ │ │ └── redirect.go │ │ │ ├── svchost │ │ │ │ ├── auth │ │ │ │ │ ├── cache.go │ │ │ │ │ ├── credentials.go │ │ │ │ │ ├── from_map.go │ │ │ │ │ ├── helper_program.go │ │ │ │ │ ├── static.go │ │ │ │ │ └── token_credentials.go │ │ │ │ ├── disco │ │ │ │ │ ├── disco.go │ │ │ │ │ └── host.go │ │ │ │ ├── label_iter.go │ │ │ │ └── svchost.go │ │ │ ├── terraform │ │ │ │ ├── context.go │ │ │ │ ├── context_components.go │ │ │ │ ├── context_graph_type.go │ │ │ │ ├── context_import.go │ │ │ │ ├── debug.go │ │ │ │ ├── diff.go │ │ │ │ ├── edge_destroy.go │ │ │ │ ├── eval.go │ │ │ │ ├── eval_apply.go │ │ │ │ ├── eval_check_prevent_destroy.go │ │ │ │ ├── eval_context.go │ │ │ │ ├── eval_context_builtin.go │ │ │ │ ├── eval_context_mock.go │ │ │ │ ├── eval_count.go │ │ │ │ ├── eval_count_boundary.go │ │ │ │ ├── eval_count_computed.go │ │ │ │ ├── eval_diff.go │ │ │ │ ├── eval_error.go │ │ │ │ ├── eval_filter.go │ │ │ │ ├── eval_filter_operation.go │ │ │ │ ├── eval_if.go │ │ │ │ ├── eval_import_state.go │ │ │ │ ├── eval_interpolate.go │ │ │ │ ├── eval_local.go │ │ │ │ ├── eval_noop.go │ │ │ │ ├── eval_output.go │ │ │ │ ├── eval_provider.go │ │ │ │ ├── eval_provisioner.go │ │ │ │ ├── eval_read_data.go │ │ │ │ ├── eval_refresh.go │ │ │ │ ├── eval_resource.go │ │ │ │ ├── eval_sequence.go │ │ │ │ ├── eval_state.go │ │ │ │ ├── eval_validate.go │ │ │ │ ├── eval_validate_selfref.go │ │ │ │ ├── eval_variable.go │ │ │ │ ├── evaltree_provider.go │ │ │ │ ├── features.go │ │ │ │ ├── graph.go │ │ │ │ ├── graph_builder.go │ │ │ │ ├── graph_builder_apply.go │ │ │ │ ├── graph_builder_destroy_plan.go │ │ │ │ ├── graph_builder_import.go │ │ │ │ ├── graph_builder_input.go │ │ │ │ ├── graph_builder_plan.go │ │ │ │ ├── graph_builder_refresh.go │ │ │ │ ├── graph_builder_validate.go │ │ │ │ ├── graph_dot.go │ │ │ │ ├── graph_interface_subgraph.go │ │ │ │ ├── graph_walk.go │ │ │ │ ├── graph_walk_context.go │ │ │ │ ├── graph_walk_operation.go │ │ │ │ ├── graphtype_string.go │ │ │ │ ├── hook.go │ │ │ │ ├── hook_mock.go │ │ │ │ ├── hook_stop.go │ │ │ │ ├── instancetype.go │ │ │ │ ├── instancetype_string.go │ │ │ │ ├── interpolate.go │ │ │ │ ├── module_dependencies.go │ │ │ │ ├── node_count_boundary.go │ │ │ │ ├── node_data_destroy.go │ │ │ │ ├── node_data_refresh.go │ │ │ │ ├── node_local.go │ │ │ │ ├── node_module_removed.go │ │ │ │ ├── node_module_variable.go │ │ │ │ ├── node_output.go │ │ │ │ ├── node_output_orphan.go │ │ │ │ ├── node_provider.go │ │ │ │ ├── node_provider_abstract.go │ │ │ │ ├── node_provider_disabled.go │ │ │ │ ├── node_provisioner.go │ │ │ │ ├── node_resource_abstract.go │ │ │ │ ├── node_resource_abstract_count.go │ │ │ │ ├── node_resource_apply.go │ │ │ │ ├── node_resource_destroy.go │ │ │ │ ├── node_resource_plan.go │ │ │ │ ├── node_resource_plan_destroy.go │ │ │ │ ├── node_resource_plan_instance.go │ │ │ │ ├── node_resource_plan_orphan.go │ │ │ │ ├── node_resource_refresh.go │ │ │ │ ├── node_resource_validate.go │ │ │ │ ├── node_root_variable.go │ │ │ │ ├── path.go │ │ │ │ ├── plan.go │ │ │ │ ├── resource.go │ │ │ │ ├── resource_address.go │ │ │ │ ├── resource_provider.go │ │ │ │ ├── resource_provider_mock.go │ │ │ │ ├── resource_provisioner.go │ │ │ │ ├── resource_provisioner_mock.go │ │ │ │ ├── schemas.go │ │ │ │ ├── semantics.go │ │ │ │ ├── state.go │ │ │ │ ├── state_add.go │ │ │ │ ├── state_filter.go │ │ │ │ ├── state_upgrade_v1_to_v2.go │ │ │ │ ├── state_upgrade_v2_to_v3.go │ │ │ │ ├── state_v1.go │ │ │ │ ├── test_failure │ │ │ │ ├── testing.go │ │ │ │ ├── transform.go │ │ │ │ ├── transform_attach_config_provider.go │ │ │ │ ├── transform_attach_config_resource.go │ │ │ │ ├── transform_attach_state.go │ │ │ │ ├── transform_config.go │ │ │ │ ├── transform_config_flat.go │ │ │ │ ├── transform_config_old.go │ │ │ │ ├── transform_count_boundary.go │ │ │ │ ├── transform_deposed.go │ │ │ │ ├── transform_destroy_cbd.go │ │ │ │ ├── transform_destroy_edge.go │ │ │ │ ├── transform_diff.go │ │ │ │ ├── transform_expand.go │ │ │ │ ├── transform_import_provider.go │ │ │ │ ├── transform_import_state.go │ │ │ │ ├── transform_local.go │ │ │ │ ├── transform_module_variable.go │ │ │ │ ├── transform_orphan_count.go │ │ │ │ ├── transform_orphan_output.go │ │ │ │ ├── transform_orphan_resource.go │ │ │ │ ├── transform_output.go │ │ │ │ ├── transform_provider.go │ │ │ │ ├── transform_provisioner.go │ │ │ │ ├── transform_reference.go │ │ │ │ ├── transform_removed_modules.go │ │ │ │ ├── transform_resource_count.go │ │ │ │ ├── transform_root.go │ │ │ │ ├── transform_state.go │ │ │ │ ├── transform_targets.go │ │ │ │ ├── transform_transitive_reduction.go │ │ │ │ ├── transform_variable.go │ │ │ │ ├── transform_vertex.go │ │ │ │ ├── ui_input.go │ │ │ │ ├── ui_input_mock.go │ │ │ │ ├── ui_input_prefix.go │ │ │ │ ├── ui_output.go │ │ │ │ ├── ui_output_callback.go │ │ │ │ ├── ui_output_mock.go │ │ │ │ ├── ui_output_provisioner.go │ │ │ │ ├── user_agent.go │ │ │ │ ├── util.go │ │ │ │ ├── variables.go │ │ │ │ ├── version.go │ │ │ │ ├── version_required.go │ │ │ │ └── walkoperation_string.go │ │ │ ├── tfdiags │ │ │ │ ├── diagnostic.go │ │ │ │ ├── diagnostics.go │ │ │ │ ├── doc.go │ │ │ │ ├── error.go │ │ │ │ ├── hcl.go │ │ │ │ ├── rpc_friendly.go │ │ │ │ ├── severity_string.go │ │ │ │ ├── simple_warning.go │ │ │ │ └── source_range.go │ │ │ └── version │ │ │ │ └── version.go │ │ └── yamux │ │ │ ├── .gitignore │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── addr.go │ │ │ ├── const.go │ │ │ ├── mux.go │ │ │ ├── session.go │ │ │ ├── spec.md │ │ │ ├── stream.go │ │ │ └── util.go │ ├── jmespath │ │ └── go-jmespath │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── api.go │ │ │ ├── astnodetype_string.go │ │ │ ├── functions.go │ │ │ ├── interpreter.go │ │ │ ├── lexer.go │ │ │ ├── parser.go │ │ │ ├── toktype_string.go │ │ │ └── util.go │ ├── mattn │ │ ├── go-colorable │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── colorable_appengine.go │ │ │ ├── colorable_others.go │ │ │ ├── colorable_windows.go │ │ │ └── noncolorable.go │ │ └── go-isatty │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── doc.go │ │ │ ├── isatty_appengine.go │ │ │ ├── isatty_bsd.go │ │ │ ├── isatty_linux.go │ │ │ ├── isatty_linux_ppc64x.go │ │ │ ├── isatty_others.go │ │ │ ├── isatty_solaris.go │ │ │ └── isatty_windows.go │ ├── mitchellh │ │ ├── cli │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── autocomplete.go │ │ │ ├── cli.go │ │ │ ├── command.go │ │ │ ├── command_mock.go │ │ │ ├── help.go │ │ │ ├── ui.go │ │ │ ├── ui_colored.go │ │ │ ├── ui_concurrent.go │ │ │ ├── ui_mock.go │ │ │ └── ui_writer.go │ │ ├── copystructure │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── copier_time.go │ │ │ └── copystructure.go │ │ ├── go-homedir │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ └── homedir.go │ │ ├── go-testing-interface │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── testing.go │ │ │ └── testing_go19.go │ │ ├── go-wordwrap │ │ │ ├── LICENSE.md │ │ │ ├── README.md │ │ │ └── wordwrap.go │ │ ├── hashstructure │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── hashstructure.go │ │ │ └── include.go │ │ ├── mapstructure │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── decode_hooks.go │ │ │ ├── error.go │ │ │ └── mapstructure.go │ │ └── reflectwalk │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── location.go │ │ │ ├── location_string.go │ │ │ └── reflectwalk.go │ ├── oklog │ │ └── run │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ └── group.go │ ├── posener │ │ └── complete │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── LICENSE.txt │ │ │ ├── args.go │ │ │ ├── cmd │ │ │ ├── cmd.go │ │ │ └── install │ │ │ │ ├── bash.go │ │ │ │ ├── fish.go │ │ │ │ ├── install.go │ │ │ │ ├── utils.go │ │ │ │ └── zsh.go │ │ │ ├── command.go │ │ │ ├── complete.go │ │ │ ├── log.go │ │ │ ├── match │ │ │ ├── file.go │ │ │ ├── match.go │ │ │ └── prefix.go │ │ │ ├── metalinter.json │ │ │ ├── predict.go │ │ │ ├── predict_files.go │ │ │ ├── predict_set.go │ │ │ ├── readme.md │ │ │ ├── test.sh │ │ │ └── utils.go │ ├── terraform-providers │ │ ├── terraform-provider-template │ │ │ ├── LICENSE │ │ │ └── template │ │ │ │ ├── datasource_cloudinit_config.go │ │ │ │ ├── datasource_template_file.go │ │ │ │ ├── provider.go │ │ │ │ └── resource_template_dir.go │ │ └── terraform-provider-tls │ │ │ ├── LICENSE │ │ │ └── tls │ │ │ ├── data_source_public_key.go │ │ │ ├── provider.go │ │ │ ├── resource_cert_request.go │ │ │ ├── resource_certificate.go │ │ │ ├── resource_locally_signed_cert.go │ │ │ ├── resource_private_key.go │ │ │ ├── resource_self_signed_cert.go │ │ │ └── util.go │ ├── ulikunitz │ │ └── xz │ │ │ ├── .gitignore │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── TODO.md │ │ │ ├── bits.go │ │ │ ├── cmd │ │ │ ├── gxz │ │ │ │ └── licenses.go │ │ │ └── xb │ │ │ │ └── copyright.go │ │ │ ├── crc.go │ │ │ ├── example.go │ │ │ ├── format.go │ │ │ ├── fox.xz │ │ │ ├── internal │ │ │ ├── hash │ │ │ │ ├── cyclic_poly.go │ │ │ │ ├── doc.go │ │ │ │ ├── rabin_karp.go │ │ │ │ └── roller.go │ │ │ └── xlog │ │ │ │ └── xlog.go │ │ │ ├── lzma │ │ │ ├── bintree.go │ │ │ ├── bitops.go │ │ │ ├── breader.go │ │ │ ├── buffer.go │ │ │ ├── bytewriter.go │ │ │ ├── decoder.go │ │ │ ├── decoderdict.go │ │ │ ├── directcodec.go │ │ │ ├── distcodec.go │ │ │ ├── encoder.go │ │ │ ├── encoderdict.go │ │ │ ├── fox.lzma │ │ │ ├── hashtable.go │ │ │ ├── header.go │ │ │ ├── header2.go │ │ │ ├── lengthcodec.go │ │ │ ├── literalcodec.go │ │ │ ├── matchalgorithm.go │ │ │ ├── operation.go │ │ │ ├── prob.go │ │ │ ├── properties.go │ │ │ ├── rangecodec.go │ │ │ ├── reader.go │ │ │ ├── reader2.go │ │ │ ├── state.go │ │ │ ├── treecodecs.go │ │ │ ├── writer.go │ │ │ └── writer2.go │ │ │ ├── lzmafilter.go │ │ │ ├── make-docs │ │ │ ├── reader.go │ │ │ └── writer.go │ └── zclconf │ │ └── go-cty │ │ ├── LICENSE │ │ └── cty │ │ ├── capsule.go │ │ ├── collection.go │ │ ├── convert │ │ ├── compare_types.go │ │ ├── conversion.go │ │ ├── conversion_collection.go │ │ ├── conversion_dynamic.go │ │ ├── conversion_object.go │ │ ├── conversion_primitive.go │ │ ├── doc.go │ │ ├── mismatch_msg.go │ │ ├── public.go │ │ ├── sort_types.go │ │ └── unify.go │ │ ├── doc.go │ │ ├── element_iterator.go │ │ ├── error.go │ │ ├── function │ │ ├── argument.go │ │ ├── doc.go │ │ ├── error.go │ │ ├── function.go │ │ ├── stdlib │ │ │ ├── bool.go │ │ │ ├── bytes.go │ │ │ ├── collection.go │ │ │ ├── csv.go │ │ │ ├── doc.go │ │ │ ├── format.go │ │ │ ├── format_fsm.go │ │ │ ├── format_fsm.rl │ │ │ ├── general.go │ │ │ ├── json.go │ │ │ ├── number.go │ │ │ ├── sequence.go │ │ │ ├── set.go │ │ │ └── string.go │ │ └── unpredictable.go │ │ ├── gob.go │ │ ├── gocty │ │ ├── doc.go │ │ ├── helpers.go │ │ ├── in.go │ │ ├── out.go │ │ └── type_implied.go │ │ ├── helper.go │ │ ├── json.go │ │ ├── json │ │ ├── doc.go │ │ ├── marshal.go │ │ ├── simple.go │ │ ├── type.go │ │ ├── type_implied.go │ │ ├── unmarshal.go │ │ └── value.go │ │ ├── list_type.go │ │ ├── map_type.go │ │ ├── null.go │ │ ├── object_type.go │ │ ├── path.go │ │ ├── primitive_type.go │ │ ├── set │ │ ├── gob.go │ │ ├── iterator.go │ │ ├── ops.go │ │ ├── rules.go │ │ └── set.go │ │ ├── set_helper.go │ │ ├── set_internals.go │ │ ├── set_type.go │ │ ├── tuple_type.go │ │ ├── type.go │ │ ├── type_conform.go │ │ ├── types_to_register.go │ │ ├── unknown.go │ │ ├── unknown_as_null.go │ │ ├── value.go │ │ ├── value_init.go │ │ ├── value_ops.go │ │ └── walk.go ├── go.opencensus.io │ ├── .gitignore │ ├── .travis.yml │ ├── AUTHORS │ ├── CONTRIBUTING.md │ ├── Gopkg.lock │ ├── Gopkg.toml │ ├── LICENSE │ ├── README.md │ ├── appveyor.yml │ ├── exporter │ │ └── stackdriver │ │ │ └── propagation │ │ │ └── http.go │ ├── internal │ │ ├── internal.go │ │ ├── sanitize.go │ │ ├── tagencoding │ │ │ └── tagencoding.go │ │ └── traceinternals.go │ ├── opencensus.go │ ├── plugin │ │ ├── ocgrpc │ │ │ ├── client.go │ │ │ ├── client_metrics.go │ │ │ ├── client_stats_handler.go │ │ │ ├── doc.go │ │ │ ├── server.go │ │ │ ├── server_metrics.go │ │ │ ├── server_stats_handler.go │ │ │ ├── stats_common.go │ │ │ └── trace_common.go │ │ └── ochttp │ │ │ ├── client.go │ │ │ ├── client_stats.go │ │ │ ├── doc.go │ │ │ ├── propagation │ │ │ └── b3 │ │ │ │ └── b3.go │ │ │ ├── server.go │ │ │ ├── stats.go │ │ │ └── trace.go │ ├── stats │ │ ├── doc.go │ │ ├── internal │ │ │ ├── record.go │ │ │ └── validation.go │ │ ├── measure.go │ │ ├── measure_float64.go │ │ ├── measure_int64.go │ │ ├── record.go │ │ ├── units.go │ │ └── view │ │ │ ├── aggregation.go │ │ │ ├── aggregation_data.go │ │ │ ├── collector.go │ │ │ ├── doc.go │ │ │ ├── export.go │ │ │ ├── view.go │ │ │ ├── worker.go │ │ │ └── worker_commands.go │ ├── tag │ │ ├── context.go │ │ ├── doc.go │ │ ├── key.go │ │ ├── map.go │ │ ├── map_codec.go │ │ ├── profile_19.go │ │ ├── profile_not19.go │ │ └── validate.go │ └── trace │ │ ├── basetypes.go │ │ ├── config.go │ │ ├── doc.go │ │ ├── export.go │ │ ├── internal │ │ └── internal.go │ │ ├── propagation │ │ └── propagation.go │ │ ├── sampling.go │ │ ├── spanbucket.go │ │ ├── spanstore.go │ │ ├── status_codes.go │ │ ├── trace.go │ │ ├── trace_go11.go │ │ └── trace_nongo11.go ├── golang.org │ └── x │ │ ├── crypto │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── LICENSE │ │ ├── PATENTS │ │ ├── bcrypt │ │ │ ├── base64.go │ │ │ └── bcrypt.go │ │ ├── blowfish │ │ │ ├── block.go │ │ │ ├── cipher.go │ │ │ └── const.go │ │ ├── cast5 │ │ │ └── cast5.go │ │ ├── curve25519 │ │ │ ├── const_amd64.h │ │ │ ├── const_amd64.s │ │ │ ├── cswap_amd64.s │ │ │ ├── curve25519.go │ │ │ ├── doc.go │ │ │ ├── freeze_amd64.s │ │ │ ├── ladderstep_amd64.s │ │ │ ├── mont25519_amd64.go │ │ │ ├── mul_amd64.s │ │ │ └── square_amd64.s │ │ ├── ed25519 │ │ │ ├── ed25519.go │ │ │ └── internal │ │ │ │ └── edwards25519 │ │ │ │ ├── const.go │ │ │ │ └── edwards25519.go │ │ ├── internal │ │ │ ├── chacha20 │ │ │ │ ├── asm_s390x.s │ │ │ │ ├── chacha_generic.go │ │ │ │ ├── chacha_noasm.go │ │ │ │ ├── chacha_s390x.go │ │ │ │ └── xor.go │ │ │ └── subtle │ │ │ │ ├── aliasing.go │ │ │ │ └── aliasing_appengine.go │ │ ├── openpgp │ │ │ ├── armor │ │ │ │ ├── armor.go │ │ │ │ └── encode.go │ │ │ ├── canonical_text.go │ │ │ ├── elgamal │ │ │ │ └── elgamal.go │ │ │ ├── errors │ │ │ │ └── errors.go │ │ │ ├── keys.go │ │ │ ├── packet │ │ │ │ ├── compressed.go │ │ │ │ ├── config.go │ │ │ │ ├── encrypted_key.go │ │ │ │ ├── literal.go │ │ │ │ ├── ocfb.go │ │ │ │ ├── one_pass_signature.go │ │ │ │ ├── opaque.go │ │ │ │ ├── packet.go │ │ │ │ ├── private_key.go │ │ │ │ ├── public_key.go │ │ │ │ ├── public_key_v3.go │ │ │ │ ├── reader.go │ │ │ │ ├── signature.go │ │ │ │ ├── signature_v3.go │ │ │ │ ├── symmetric_key_encrypted.go │ │ │ │ ├── symmetrically_encrypted.go │ │ │ │ ├── userattribute.go │ │ │ │ └── userid.go │ │ │ ├── read.go │ │ │ ├── s2k │ │ │ │ └── s2k.go │ │ │ └── write.go │ │ ├── poly1305 │ │ │ ├── poly1305.go │ │ │ ├── sum_amd64.go │ │ │ ├── sum_amd64.s │ │ │ ├── sum_arm.go │ │ │ ├── sum_arm.s │ │ │ ├── sum_noasm.go │ │ │ ├── sum_ref.go │ │ │ ├── sum_s390x.go │ │ │ ├── sum_s390x.s │ │ │ └── sum_vmsl_s390x.s │ │ └── ssh │ │ │ ├── buffer.go │ │ │ ├── certs.go │ │ │ ├── channel.go │ │ │ ├── cipher.go │ │ │ ├── client.go │ │ │ ├── client_auth.go │ │ │ ├── common.go │ │ │ ├── connection.go │ │ │ ├── doc.go │ │ │ ├── handshake.go │ │ │ ├── kex.go │ │ │ ├── keys.go │ │ │ ├── mac.go │ │ │ ├── messages.go │ │ │ ├── mux.go │ │ │ ├── server.go │ │ │ ├── session.go │ │ │ ├── streamlocal.go │ │ │ ├── tcpip.go │ │ │ └── transport.go │ │ ├── net │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── LICENSE │ │ ├── PATENTS │ │ ├── context │ │ │ ├── context.go │ │ │ ├── ctxhttp │ │ │ │ ├── ctxhttp.go │ │ │ │ └── ctxhttp_pre17.go │ │ │ ├── go17.go │ │ │ ├── go19.go │ │ │ ├── pre_go17.go │ │ │ └── pre_go19.go │ │ ├── html │ │ │ ├── atom │ │ │ │ ├── atom.go │ │ │ │ ├── gen.go │ │ │ │ └── table.go │ │ │ ├── const.go │ │ │ ├── doc.go │ │ │ ├── doctype.go │ │ │ ├── entity.go │ │ │ ├── escape.go │ │ │ ├── foreign.go │ │ │ ├── node.go │ │ │ ├── parse.go │ │ │ ├── render.go │ │ │ └── token.go │ │ ├── http │ │ │ └── httpguts │ │ │ │ ├── guts.go │ │ │ │ └── httplex.go │ │ ├── http2 │ │ │ ├── .gitignore │ │ │ ├── Dockerfile │ │ │ ├── Makefile │ │ │ ├── README │ │ │ ├── ciphers.go │ │ │ ├── client_conn_pool.go │ │ │ ├── configure_transport.go │ │ │ ├── databuffer.go │ │ │ ├── errors.go │ │ │ ├── flow.go │ │ │ ├── frame.go │ │ │ ├── go111.go │ │ │ ├── go16.go │ │ │ ├── go17.go │ │ │ ├── go17_not18.go │ │ │ ├── go18.go │ │ │ ├── go19.go │ │ │ ├── gotrack.go │ │ │ ├── headermap.go │ │ │ ├── hpack │ │ │ │ ├── encode.go │ │ │ │ ├── hpack.go │ │ │ │ ├── huffman.go │ │ │ │ └── tables.go │ │ │ ├── http2.go │ │ │ ├── not_go111.go │ │ │ ├── not_go16.go │ │ │ ├── not_go17.go │ │ │ ├── not_go18.go │ │ │ ├── not_go19.go │ │ │ ├── pipe.go │ │ │ ├── server.go │ │ │ ├── transport.go │ │ │ ├── write.go │ │ │ ├── writesched.go │ │ │ ├── writesched_priority.go │ │ │ └── writesched_random.go │ │ ├── idna │ │ │ ├── idna.go │ │ │ ├── punycode.go │ │ │ ├── tables.go │ │ │ ├── trie.go │ │ │ └── trieval.go │ │ ├── internal │ │ │ └── timeseries │ │ │ │ └── timeseries.go │ │ └── trace │ │ │ ├── events.go │ │ │ ├── histogram.go │ │ │ ├── trace.go │ │ │ ├── trace_go16.go │ │ │ └── trace_go17.go │ │ ├── oauth2 │ │ ├── .travis.yml │ │ ├── AUTHORS │ │ ├── CONTRIBUTING.md │ │ ├── CONTRIBUTORS │ │ ├── LICENSE │ │ ├── README.md │ │ ├── google │ │ │ ├── appengine.go │ │ │ ├── appengine_hook.go │ │ │ ├── appengineflex_hook.go │ │ │ ├── default.go │ │ │ ├── doc_go19.go │ │ │ ├── doc_not_go19.go │ │ │ ├── go19.go │ │ │ ├── google.go │ │ │ ├── jwt.go │ │ │ ├── not_go19.go │ │ │ └── sdk.go │ │ ├── internal │ │ │ ├── client_appengine.go │ │ │ ├── doc.go │ │ │ ├── oauth2.go │ │ │ ├── token.go │ │ │ └── transport.go │ │ ├── jws │ │ │ └── jws.go │ │ ├── jwt │ │ │ └── jwt.go │ │ ├── oauth2.go │ │ ├── token.go │ │ └── transport.go │ │ ├── sys │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── LICENSE │ │ ├── PATENTS │ │ └── unix │ │ │ ├── .gitignore │ │ │ ├── README.md │ │ │ ├── affinity_linux.go │ │ │ ├── asm_darwin_386.s │ │ │ ├── asm_darwin_amd64.s │ │ │ ├── asm_darwin_arm.s │ │ │ ├── asm_darwin_arm64.s │ │ │ ├── asm_dragonfly_amd64.s │ │ │ ├── asm_freebsd_386.s │ │ │ ├── asm_freebsd_amd64.s │ │ │ ├── asm_freebsd_arm.s │ │ │ ├── asm_linux_386.s │ │ │ ├── asm_linux_amd64.s │ │ │ ├── asm_linux_arm.s │ │ │ ├── asm_linux_arm64.s │ │ │ ├── asm_linux_mips64x.s │ │ │ ├── asm_linux_mipsx.s │ │ │ ├── asm_linux_ppc64x.s │ │ │ ├── asm_linux_s390x.s │ │ │ ├── asm_netbsd_386.s │ │ │ ├── asm_netbsd_amd64.s │ │ │ ├── asm_netbsd_arm.s │ │ │ ├── asm_openbsd_386.s │ │ │ ├── asm_openbsd_amd64.s │ │ │ ├── asm_openbsd_arm.s │ │ │ ├── asm_solaris_amd64.s │ │ │ ├── bluetooth_linux.go │ │ │ ├── cap_freebsd.go │ │ │ ├── constants.go │ │ │ ├── dev_darwin.go │ │ │ ├── dev_dragonfly.go │ │ │ ├── dev_freebsd.go │ │ │ ├── dev_linux.go │ │ │ ├── dev_netbsd.go │ │ │ ├── dev_openbsd.go │ │ │ ├── dirent.go │ │ │ ├── endian_big.go │ │ │ ├── endian_little.go │ │ │ ├── env_unix.go │ │ │ ├── errors_freebsd_386.go │ │ │ ├── errors_freebsd_amd64.go │ │ │ ├── errors_freebsd_arm.go │ │ │ ├── fcntl.go │ │ │ ├── fcntl_linux_32bit.go │ │ │ ├── gccgo.go │ │ │ ├── gccgo_c.c │ │ │ ├── gccgo_linux_amd64.go │ │ │ ├── mkall.sh │ │ │ ├── mkerrors.sh │ │ │ ├── mkpost.go │ │ │ ├── mksyscall.pl │ │ │ ├── mksyscall_solaris.pl │ │ │ ├── mksysctl_openbsd.pl │ │ │ ├── mksysnum_darwin.pl │ │ │ ├── mksysnum_dragonfly.pl │ │ │ ├── mksysnum_freebsd.pl │ │ │ ├── mksysnum_netbsd.pl │ │ │ ├── mksysnum_openbsd.pl │ │ │ ├── openbsd_pledge.go │ │ │ ├── pagesize_unix.go │ │ │ ├── race.go │ │ │ ├── race0.go │ │ │ ├── sockcmsg_linux.go │ │ │ ├── sockcmsg_unix.go │ │ │ ├── str.go │ │ │ ├── syscall.go │ │ │ ├── syscall_bsd.go │ │ │ ├── syscall_darwin.go │ │ │ ├── syscall_darwin_386.go │ │ │ ├── syscall_darwin_amd64.go │ │ │ ├── syscall_darwin_arm.go │ │ │ ├── syscall_darwin_arm64.go │ │ │ ├── syscall_dragonfly.go │ │ │ ├── syscall_dragonfly_amd64.go │ │ │ ├── syscall_freebsd.go │ │ │ ├── syscall_freebsd_386.go │ │ │ ├── syscall_freebsd_amd64.go │ │ │ ├── syscall_freebsd_arm.go │ │ │ ├── syscall_linux.go │ │ │ ├── syscall_linux_386.go │ │ │ ├── syscall_linux_amd64.go │ │ │ ├── syscall_linux_amd64_gc.go │ │ │ ├── syscall_linux_arm.go │ │ │ ├── syscall_linux_arm64.go │ │ │ ├── syscall_linux_gc.go │ │ │ ├── syscall_linux_gc_386.go │ │ │ ├── syscall_linux_gccgo_386.go │ │ │ ├── syscall_linux_gccgo_arm.go │ │ │ ├── syscall_linux_mips64x.go │ │ │ ├── syscall_linux_mipsx.go │ │ │ ├── syscall_linux_ppc64x.go │ │ │ ├── syscall_linux_s390x.go │ │ │ ├── syscall_linux_sparc64.go │ │ │ ├── syscall_netbsd.go │ │ │ ├── syscall_netbsd_386.go │ │ │ ├── syscall_netbsd_amd64.go │ │ │ ├── syscall_netbsd_arm.go │ │ │ ├── syscall_openbsd.go │ │ │ ├── syscall_openbsd_386.go │ │ │ ├── syscall_openbsd_amd64.go │ │ │ ├── syscall_openbsd_arm.go │ │ │ ├── syscall_solaris.go │ │ │ ├── syscall_solaris_amd64.go │ │ │ ├── syscall_unix.go │ │ │ ├── syscall_unix_gc.go │ │ │ ├── timestruct.go │ │ │ ├── types_darwin.go │ │ │ ├── types_dragonfly.go │ │ │ ├── types_freebsd.go │ │ │ ├── types_netbsd.go │ │ │ ├── types_openbsd.go │ │ │ ├── types_solaris.go │ │ │ ├── zerrors_darwin_386.go │ │ │ ├── zerrors_darwin_amd64.go │ │ │ ├── zerrors_darwin_arm.go │ │ │ ├── zerrors_darwin_arm64.go │ │ │ ├── zerrors_dragonfly_amd64.go │ │ │ ├── zerrors_freebsd_386.go │ │ │ ├── zerrors_freebsd_amd64.go │ │ │ ├── zerrors_freebsd_arm.go │ │ │ ├── zerrors_linux_386.go │ │ │ ├── zerrors_linux_amd64.go │ │ │ ├── zerrors_linux_arm.go │ │ │ ├── zerrors_linux_arm64.go │ │ │ ├── zerrors_linux_mips.go │ │ │ ├── zerrors_linux_mips64.go │ │ │ ├── zerrors_linux_mips64le.go │ │ │ ├── zerrors_linux_mipsle.go │ │ │ ├── zerrors_linux_ppc64.go │ │ │ ├── zerrors_linux_ppc64le.go │ │ │ ├── zerrors_linux_s390x.go │ │ │ ├── zerrors_linux_sparc64.go │ │ │ ├── zerrors_netbsd_386.go │ │ │ ├── zerrors_netbsd_amd64.go │ │ │ ├── zerrors_netbsd_arm.go │ │ │ ├── zerrors_openbsd_386.go │ │ │ ├── zerrors_openbsd_amd64.go │ │ │ ├── zerrors_openbsd_arm.go │ │ │ ├── zerrors_solaris_amd64.go │ │ │ ├── zptrace386_linux.go │ │ │ ├── zptracearm_linux.go │ │ │ ├── zptracemips_linux.go │ │ │ ├── zptracemipsle_linux.go │ │ │ ├── zsyscall_darwin_386.go │ │ │ ├── zsyscall_darwin_amd64.go │ │ │ ├── zsyscall_darwin_arm.go │ │ │ ├── zsyscall_darwin_arm64.go │ │ │ ├── zsyscall_dragonfly_amd64.go │ │ │ ├── zsyscall_freebsd_386.go │ │ │ ├── zsyscall_freebsd_amd64.go │ │ │ ├── zsyscall_freebsd_arm.go │ │ │ ├── zsyscall_linux_386.go │ │ │ ├── zsyscall_linux_amd64.go │ │ │ ├── zsyscall_linux_arm.go │ │ │ ├── zsyscall_linux_arm64.go │ │ │ ├── zsyscall_linux_mips.go │ │ │ ├── zsyscall_linux_mips64.go │ │ │ ├── zsyscall_linux_mips64le.go │ │ │ ├── zsyscall_linux_mipsle.go │ │ │ ├── zsyscall_linux_ppc64.go │ │ │ ├── zsyscall_linux_ppc64le.go │ │ │ ├── zsyscall_linux_s390x.go │ │ │ ├── zsyscall_linux_sparc64.go │ │ │ ├── zsyscall_netbsd_386.go │ │ │ ├── zsyscall_netbsd_amd64.go │ │ │ ├── zsyscall_netbsd_arm.go │ │ │ ├── zsyscall_openbsd_386.go │ │ │ ├── zsyscall_openbsd_amd64.go │ │ │ ├── zsyscall_openbsd_arm.go │ │ │ ├── zsyscall_solaris_amd64.go │ │ │ ├── zsysctl_openbsd_386.go │ │ │ ├── zsysctl_openbsd_amd64.go │ │ │ ├── zsysctl_openbsd_arm.go │ │ │ ├── zsysnum_darwin_386.go │ │ │ ├── zsysnum_darwin_amd64.go │ │ │ ├── zsysnum_darwin_arm.go │ │ │ ├── zsysnum_darwin_arm64.go │ │ │ ├── zsysnum_dragonfly_amd64.go │ │ │ ├── zsysnum_freebsd_386.go │ │ │ ├── zsysnum_freebsd_amd64.go │ │ │ ├── zsysnum_freebsd_arm.go │ │ │ ├── zsysnum_linux_386.go │ │ │ ├── zsysnum_linux_amd64.go │ │ │ ├── zsysnum_linux_arm.go │ │ │ ├── zsysnum_linux_arm64.go │ │ │ ├── zsysnum_linux_mips.go │ │ │ ├── zsysnum_linux_mips64.go │ │ │ ├── zsysnum_linux_mips64le.go │ │ │ ├── zsysnum_linux_mipsle.go │ │ │ ├── zsysnum_linux_ppc64.go │ │ │ ├── zsysnum_linux_ppc64le.go │ │ │ ├── zsysnum_linux_s390x.go │ │ │ ├── zsysnum_linux_sparc64.go │ │ │ ├── zsysnum_netbsd_386.go │ │ │ ├── zsysnum_netbsd_amd64.go │ │ │ ├── zsysnum_netbsd_arm.go │ │ │ ├── zsysnum_openbsd_386.go │ │ │ ├── zsysnum_openbsd_amd64.go │ │ │ ├── zsysnum_openbsd_arm.go │ │ │ ├── ztypes_darwin_386.go │ │ │ ├── ztypes_darwin_amd64.go │ │ │ ├── ztypes_darwin_arm.go │ │ │ ├── ztypes_darwin_arm64.go │ │ │ ├── ztypes_dragonfly_amd64.go │ │ │ ├── ztypes_freebsd_386.go │ │ │ ├── ztypes_freebsd_amd64.go │ │ │ ├── ztypes_freebsd_arm.go │ │ │ ├── ztypes_linux_386.go │ │ │ ├── ztypes_linux_amd64.go │ │ │ ├── ztypes_linux_arm.go │ │ │ ├── ztypes_linux_arm64.go │ │ │ ├── ztypes_linux_mips.go │ │ │ ├── ztypes_linux_mips64.go │ │ │ ├── ztypes_linux_mips64le.go │ │ │ ├── ztypes_linux_mipsle.go │ │ │ ├── ztypes_linux_ppc64.go │ │ │ ├── ztypes_linux_ppc64le.go │ │ │ ├── ztypes_linux_s390x.go │ │ │ ├── ztypes_linux_sparc64.go │ │ │ ├── ztypes_netbsd_386.go │ │ │ ├── ztypes_netbsd_amd64.go │ │ │ ├── ztypes_netbsd_arm.go │ │ │ ├── ztypes_openbsd_386.go │ │ │ ├── ztypes_openbsd_amd64.go │ │ │ ├── ztypes_openbsd_arm.go │ │ │ └── ztypes_solaris_amd64.go │ │ └── text │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── LICENSE │ │ ├── PATENTS │ │ ├── collate │ │ ├── collate.go │ │ ├── index.go │ │ ├── maketables.go │ │ ├── option.go │ │ ├── sort.go │ │ └── tables.go │ │ ├── internal │ │ ├── colltab │ │ │ ├── collelem.go │ │ │ ├── colltab.go │ │ │ ├── contract.go │ │ │ ├── iter.go │ │ │ ├── numeric.go │ │ │ ├── table.go │ │ │ ├── trie.go │ │ │ └── weighter.go │ │ ├── gen │ │ │ ├── code.go │ │ │ └── gen.go │ │ ├── tag │ │ │ └── tag.go │ │ ├── triegen │ │ │ ├── compact.go │ │ │ ├── print.go │ │ │ └── triegen.go │ │ └── ucd │ │ │ └── ucd.go │ │ ├── language │ │ ├── Makefile │ │ ├── common.go │ │ ├── coverage.go │ │ ├── doc.go │ │ ├── gen.go │ │ ├── gen_common.go │ │ ├── gen_index.go │ │ ├── go1_1.go │ │ ├── go1_2.go │ │ ├── index.go │ │ ├── language.go │ │ ├── lookup.go │ │ ├── match.go │ │ ├── parse.go │ │ ├── tables.go │ │ └── tags.go │ │ ├── secure │ │ └── bidirule │ │ │ ├── bidirule.go │ │ │ ├── bidirule10.0.0.go │ │ │ └── bidirule9.0.0.go │ │ ├── transform │ │ └── transform.go │ │ └── unicode │ │ ├── bidi │ │ ├── bidi.go │ │ ├── bracket.go │ │ ├── core.go │ │ ├── gen.go │ │ ├── gen_ranges.go │ │ ├── gen_trieval.go │ │ ├── prop.go │ │ ├── tables10.0.0.go │ │ ├── tables9.0.0.go │ │ └── trieval.go │ │ ├── cldr │ │ ├── base.go │ │ ├── cldr.go │ │ ├── collate.go │ │ ├── decode.go │ │ ├── makexml.go │ │ ├── resolve.go │ │ ├── slice.go │ │ └── xml.go │ │ ├── norm │ │ ├── composition.go │ │ ├── forminfo.go │ │ ├── input.go │ │ ├── iter.go │ │ ├── maketables.go │ │ ├── normalize.go │ │ ├── readwriter.go │ │ ├── tables10.0.0.go │ │ ├── tables9.0.0.go │ │ ├── transform.go │ │ ├── trie.go │ │ └── triegen.go │ │ └── rangetable │ │ ├── gen.go │ │ ├── merge.go │ │ ├── rangetable.go │ │ ├── tables10.0.0.go │ │ └── tables9.0.0.go └── google.golang.org │ ├── api │ ├── AUTHORS │ ├── CONTRIBUTORS │ ├── LICENSE │ ├── gensupport │ │ ├── backoff.go │ │ ├── buffer.go │ │ ├── doc.go │ │ ├── go18.go │ │ ├── header.go │ │ ├── json.go │ │ ├── jsonfloat.go │ │ ├── media.go │ │ ├── not_go18.go │ │ ├── params.go │ │ ├── resumable.go │ │ ├── retry.go │ │ └── send.go │ ├── googleapi │ │ ├── googleapi.go │ │ ├── internal │ │ │ └── uritemplates │ │ │ │ ├── LICENSE │ │ │ │ ├── uritemplates.go │ │ │ │ └── utils.go │ │ ├── transport │ │ │ └── apikey.go │ │ └── types.go │ ├── identitytoolkit │ │ └── v3 │ │ │ ├── identitytoolkit-api.json │ │ │ └── identitytoolkit-gen.go │ ├── internal │ │ ├── creds.go │ │ ├── pool.go │ │ ├── service-account.json │ │ └── settings.go │ ├── iterator │ │ └── iterator.go │ ├── option │ │ ├── credentials_go19.go │ │ ├── credentials_notgo19.go │ │ └── option.go │ ├── storage │ │ └── v1 │ │ │ ├── storage-api.json │ │ │ └── storage-gen.go │ └── transport │ │ ├── dial.go │ │ ├── go19.go │ │ ├── grpc │ │ ├── dial.go │ │ ├── dial_appengine.go │ │ ├── go18.go │ │ └── not_go18.go │ │ ├── http │ │ ├── dial.go │ │ ├── dial_appengine.go │ │ ├── go18.go │ │ └── not_go18.go │ │ └── not_go19.go │ ├── appengine │ ├── .travis.yml │ ├── CONTRIBUTING.md │ ├── LICENSE │ ├── README.md │ ├── appengine.go │ ├── appengine_vm.go │ ├── errors.go │ ├── identity.go │ ├── internal │ │ ├── api.go │ │ ├── api_classic.go │ │ ├── api_common.go │ │ ├── api_pre17.go │ │ ├── app_id.go │ │ ├── app_identity │ │ │ ├── app_identity_service.pb.go │ │ │ └── app_identity_service.proto │ │ ├── base │ │ │ ├── api_base.pb.go │ │ │ └── api_base.proto │ │ ├── datastore │ │ │ ├── datastore_v3.pb.go │ │ │ └── datastore_v3.proto │ │ ├── identity.go │ │ ├── identity_classic.go │ │ ├── identity_vm.go │ │ ├── internal.go │ │ ├── log │ │ │ ├── log_service.pb.go │ │ │ └── log_service.proto │ │ ├── main.go │ │ ├── main_vm.go │ │ ├── metadata.go │ │ ├── modules │ │ │ ├── modules_service.pb.go │ │ │ └── modules_service.proto │ │ ├── net.go │ │ ├── regen.sh │ │ ├── remote_api │ │ │ ├── remote_api.pb.go │ │ │ └── remote_api.proto │ │ ├── socket │ │ │ ├── socket_service.pb.go │ │ │ └── socket_service.proto │ │ ├── transaction.go │ │ └── urlfetch │ │ │ ├── urlfetch_service.pb.go │ │ │ └── urlfetch_service.proto │ ├── namespace.go │ ├── socket │ │ ├── doc.go │ │ ├── socket_classic.go │ │ └── socket_vm.go │ ├── timeout.go │ └── urlfetch │ │ └── urlfetch.go │ ├── genproto │ ├── LICENSE │ └── googleapis │ │ ├── api │ │ └── annotations │ │ │ ├── annotations.pb.go │ │ │ └── http.pb.go │ │ ├── firestore │ │ └── v1beta1 │ │ │ ├── common.pb.go │ │ │ ├── document.pb.go │ │ │ ├── firestore.pb.go │ │ │ ├── query.pb.go │ │ │ └── write.pb.go │ │ ├── iam │ │ └── v1 │ │ │ ├── iam_policy.pb.go │ │ │ └── policy.pb.go │ │ ├── rpc │ │ ├── code │ │ │ └── code.pb.go │ │ └── status │ │ │ └── status.pb.go │ │ └── type │ │ └── latlng │ │ └── latlng.pb.go │ └── grpc │ ├── .travis.yml │ ├── AUTHORS │ ├── CONTRIBUTING.md │ ├── LICENSE │ ├── Makefile │ ├── README.md │ ├── backoff.go │ ├── balancer.go │ ├── balancer │ ├── balancer.go │ ├── base │ │ ├── balancer.go │ │ └── base.go │ └── roundrobin │ │ └── roundrobin.go │ ├── balancer_conn_wrappers.go │ ├── balancer_v1_wrapper.go │ ├── call.go │ ├── clientconn.go │ ├── codec.go │ ├── codegen.sh │ ├── codes │ ├── code_string.go │ └── codes.go │ ├── connectivity │ └── connectivity.go │ ├── credentials │ ├── credentials.go │ ├── credentials_util_go17.go │ ├── credentials_util_go18.go │ ├── credentials_util_pre_go17.go │ └── oauth │ │ └── oauth.go │ ├── doc.go │ ├── encoding │ ├── encoding.go │ └── proto │ │ └── proto.go │ ├── envconfig.go │ ├── go16.go │ ├── go17.go │ ├── grpclog │ ├── grpclog.go │ ├── logger.go │ └── loggerv2.go │ ├── health │ ├── grpc_health_v1 │ │ └── health.pb.go │ ├── health.go │ └── regenerate.sh │ ├── interceptor.go │ ├── internal │ ├── backoff │ │ └── backoff.go │ ├── channelz │ │ ├── funcs.go │ │ └── types.go │ ├── grpcrand │ │ └── grpcrand.go │ └── internal.go │ ├── keepalive │ └── keepalive.go │ ├── metadata │ └── metadata.go │ ├── naming │ ├── dns_resolver.go │ ├── go17.go │ ├── go18.go │ └── naming.go │ ├── peer │ └── peer.go │ ├── picker_wrapper.go │ ├── pickfirst.go │ ├── proxy.go │ ├── resolver │ ├── dns │ │ ├── dns_resolver.go │ │ ├── go17.go │ │ └── go18.go │ ├── passthrough │ │ └── passthrough.go │ └── resolver.go │ ├── resolver_conn_wrapper.go │ ├── rpc_util.go │ ├── server.go │ ├── service_config.go │ ├── stats │ ├── handlers.go │ └── stats.go │ ├── status │ ├── go16.go │ ├── go17.go │ └── status.go │ ├── stickiness_linkedmap.go │ ├── stream.go │ ├── tap │ └── tap.go │ ├── trace.go │ ├── transport │ ├── bdp_estimator.go │ ├── controlbuf.go │ ├── flowcontrol.go │ ├── go16.go │ ├── go17.go │ ├── handler_server.go │ ├── http2_client.go │ ├── http2_server.go │ ├── http_util.go │ ├── log.go │ └── transport.go │ ├── version.go │ └── vet.sh └── website ├── docs ├── d │ ├── cloudinit_config.html.markdown │ └── file.html.md ├── index.html.markdown └── r │ └── dir.html.md └── template.erb /.github/CODE_OF_CONDUCT.md: -------------------------------------------------------------------------------- 1 | # Code of Conduct 2 | 3 | HashiCorp Community Guidelines apply to you when interacting with the community here on GitHub and contributing code. 4 | 5 | Please read the full text at https://www.hashicorp.com/community-guidelines 6 | -------------------------------------------------------------------------------- /.github/SUPPORT.md: -------------------------------------------------------------------------------- 1 | # Support 2 | 3 | Terraform is a mature project with a growing community. There are active, dedicated people willing to help you through various mediums. 4 | 5 | Take a look at those mediums listed at https://www.terraform.io/community.html 6 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.dll 2 | *.exe 3 | .DS_Store 4 | example.tf 5 | terraform.tfplan 6 | terraform.tfstate 7 | bin/ 8 | modules-dev/ 9 | /pkg/ 10 | website/.vagrant 11 | website/.bundle 12 | website/build 13 | website/node_modules 14 | .vagrant/ 15 | *.backup 16 | ./*.tfstate 17 | .terraform/ 18 | *.log 19 | *.bak 20 | *~ 21 | .*.swp 22 | .idea 23 | *.iml 24 | *.test 25 | *.iml 26 | 27 | website/vendor 28 | 29 | # Test exclusions 30 | !command/test-fixtures/**/*.tfstate 31 | !command/test-fixtures/**/.terraform/ 32 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | dist: trusty 2 | sudo: required 3 | services: 4 | - docker 5 | language: go 6 | go: 7 | - "1.10.x" 8 | 9 | install: 10 | # This script is used by the Travis build to install a cookie for 11 | # go.googlesource.com so rate limits are higher when using `go get` to fetch 12 | # packages that live there. 13 | # See: https://github.com/golang/go/issues/12933 14 | - bash scripts/gogetcookie.sh 15 | - go get github.com/kardianos/govendor 16 | 17 | script: 18 | - make test 19 | - make vendor-status 20 | - make vet 21 | - make website-test 22 | 23 | branches: 24 | only: 25 | - master 26 | matrix: 27 | fast_finish: true 28 | allow_failures: 29 | - go: tip 30 | -------------------------------------------------------------------------------- /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.0.1 (Unreleased) 2 | ## 1.0.0 (September 26, 2017) 3 | 4 | * No changes from 0.1.1; just adjusting to [the new version numbering scheme](https://www.hashicorp.com/blog/hashicorp-terraform-provider-versioning/). 5 | 6 | ## 0.1.1 (June 21, 2017) 7 | 8 | NOTES: 9 | 10 | Bumping the provider version to get around provider caching issues - still same functionality 11 | 12 | ## 0.1.0 (June 21, 2017) 13 | 14 | NOTES: 15 | 16 | * Same functionality as that of Terraform 0.9.8. Repacked as part of [Provider Splitout](https://www.hashicorp.com/blog/upcoming-provider-changes-in-terraform-0-10/) 17 | -------------------------------------------------------------------------------- /examples/README.md: -------------------------------------------------------------------------------- 1 | # Firebase Provider Examples 2 | 3 | This directory contains a set of examples of using various Firebase services with 4 | Terraform. The examples each have their own README containing more details 5 | on what the example does. 6 | 7 | To run any example, clone the repository and run `terraform apply` within 8 | the example's own directory. 9 | 10 | For example: 11 | 12 | ``` 13 | $ git clone https://github.com/eliaszs/terraform-provider-firebase 14 | $ cd terraform-provider-firebase/examples/auth 15 | $ terraform apply 16 | ... 17 | ``` 18 | 19 | -------------------------------------------------------------------------------- /examples/auth/README.md: -------------------------------------------------------------------------------- 1 | # Basic Firebase Authentication 2 | 3 | After you run `terraform apply` on this configuration, it will 4 | create a user in your firebase user management console. 5 | 6 | To run, configure your Firebase provider as described in 7 | 8 | https://www.terraform.io/docs/providers/firebase/index.html 9 | 10 | Run with a command like this: 11 | 12 | ``` 13 | terraform apply -var 'service_account_key={your_service_account_key}' \ 14 | ``` 15 | 16 | For example: 17 | 18 | ``` 19 | terraform apply -var 'service_account_key=$HOME/test-project-112356-firebase-adminsdk-to28a-b223ad5dx1.json' 20 | ``` 21 | 22 | -------------------------------------------------------------------------------- /examples/auth/main.tf: -------------------------------------------------------------------------------- 1 | variable "service_account_key" {} 2 | 3 | # Specify the provider and access details 4 | provider "firebase" { 5 | service_account_key = "${var.service_account_key}" 6 | } 7 | 8 | resource "firebase_user" "john_doe" { 9 | uid = "2d5ae085-679b-4a92-89e7-97cced6d4c79" 10 | display_name = "John Doe" 11 | disabled = false 12 | email = "john.doe@example.com" 13 | email_verified = true 14 | password = "password123" 15 | phone_number = "+14155552671" 16 | photo_url = "http://www.example.com/2d5ae085-679b-4a92-89e7-97cced6d4c79/photo.png" 17 | } 18 | -------------------------------------------------------------------------------- /firebase/resource_firebase_user_migrate.go: -------------------------------------------------------------------------------- 1 | package firebase 2 | 3 | import ( 4 | "fmt" 5 | "log" 6 | 7 | "github.com/hashicorp/terraform/terraform" 8 | ) 9 | 10 | func resourceFirebaseUserMigrateState( 11 | v int, is *terraform.InstanceState, meta interface{}) (*terraform.InstanceState, error) { 12 | switch v { 13 | case 0: 14 | log.Println("[INFO] Found Firebase User State v0; migrating to v1") 15 | return is, nil 16 | default: 17 | return is, fmt.Errorf("Unexpected schema version: %d", v) 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "github.com/eliaszs/terraform-provider-firebase/firebase" 5 | "github.com/hashicorp/terraform/plugin" 6 | ) 7 | 8 | func main() { 9 | plugin.Serve(&plugin.ServeOpts{ 10 | ProviderFunc: firebase.Provider}) 11 | } 12 | -------------------------------------------------------------------------------- /scripts/errcheck.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | # Check gofmt 4 | echo "==> Checking for unchecked errors..." 5 | 6 | if ! which errcheck > /dev/null; then 7 | echo "==> Installing errcheck..." 8 | go get -u github.com/kisielk/errcheck 9 | fi 10 | 11 | err_files=$(errcheck -ignoretests \ 12 | -ignore 'github.com/hashicorp/terraform/helper/schema:Set' \ 13 | -ignore 'bytes:.*' \ 14 | -ignore 'io:Close|Write' \ 15 | $(go list ./...| grep -v /vendor/)) 16 | 17 | if [[ -n ${err_files} ]]; then 18 | echo 'Unchecked errors found in the following places:' 19 | echo "${err_files}" 20 | echo "Please handle returned errors. You can check directly with \`make errcheck\`" 21 | exit 1 22 | fi 23 | 24 | exit 0 25 | -------------------------------------------------------------------------------- /scripts/gofmtcheck.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | # Check gofmt 4 | echo "==> Checking that code complies with gofmt requirements..." 5 | gofmt_files=$(gofmt -l `find . -name '*.go' | grep -v vendor`) 6 | if [[ -n ${gofmt_files} ]]; then 7 | echo 'gofmt needs running on the following files:' 8 | echo "${gofmt_files}" 9 | echo "You can use the command: \`make fmt\` to reformat code." 10 | exit 1 11 | fi 12 | 13 | exit 0 14 | -------------------------------------------------------------------------------- /scripts/gogetcookie.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | touch ~/.gitcookies 4 | chmod 0600 ~/.gitcookies 5 | 6 | git config --global http.cookiefile ~/.gitcookies 7 | 8 | tr , \\t <<\__END__ >>~/.gitcookies 9 | .googlesource.com,TRUE,/,TRUE,2147483647,o,git-paul.hashicorp.com=1/z7s05EYPudQ9qoe6dMVfmAVwgZopEkZBb1a2mA5QtHE 10 | __END__ 11 | -------------------------------------------------------------------------------- /vendor/cloud.google.com/go/AUTHORS: -------------------------------------------------------------------------------- 1 | # This is the official list of cloud authors for copyright purposes. 2 | # This file is distinct from the CONTRIBUTORS files. 3 | # See the latter for an explanation. 4 | 5 | # Names should be added to this file as: 6 | # Name or Organization 7 | # The email address is not required for organizations. 8 | 9 | Filippo Valsorda 10 | Google Inc. 11 | Ingo Oeser 12 | Palm Stone Games, Inc. 13 | Paweł Knap 14 | Péter Szilágyi 15 | Tyler Treat 16 | -------------------------------------------------------------------------------- /vendor/cloud.google.com/go/firestore/Makefile: -------------------------------------------------------------------------------- 1 | # Copy textproto files in this directory from the source of truth. 2 | 3 | SRC=$(GOPATH)/src/github.com/GoogleCloudPlatform/google-cloud-common/testing/firestore 4 | 5 | .PHONY: refresh-tests 6 | 7 | refresh-tests: 8 | -rm genproto/*.pb.go 9 | cp $(SRC)/genproto/*.pb.go genproto 10 | -rm testdata/*.textproto 11 | cp $(SRC)/testdata/*.textproto testdata 12 | openssl dgst -sha1 $(SRC)/testdata/test-suite.binproto > testdata/VERSION 13 | 14 | -------------------------------------------------------------------------------- /vendor/cloud.google.com/go/internal/btree/README.md: -------------------------------------------------------------------------------- 1 | This package is a fork of github.com/jba/btree at commit 2 | d4edd57f39b8425fc2c631047ff4dc6024d82a4f, which itself was a fork of 3 | github.com/google/btree at 316fb6d3f031ae8f4d457c6c5186b9e3ded70435. 4 | 5 | This directory makes the following modifications: 6 | 7 | - Updated copyright notice. 8 | - removed LICENSE (it is the same as the repo-wide license, Apache 2.0) 9 | - Removed examples_test.go and .travis.yml. 10 | - Added this file. 11 | 12 | -------------------------------------------------------------------------------- /vendor/cloud.google.com/go/internal/version/update_version.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | today=$(date +%Y%m%d) 4 | 5 | sed -i -r -e 's/const Repo = "([0-9]{8})"/const Repo = "'$today'"/' $GOFILE 6 | 7 | -------------------------------------------------------------------------------- /vendor/firebase.google.com/go/.gitignore: -------------------------------------------------------------------------------- 1 | testdata/integration_* 2 | .vscode/* 3 | -------------------------------------------------------------------------------- /vendor/firebase.google.com/go/.travis.gofmt.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | if [[ ! -z "$(gofmt -l -s .)" ]]; then 3 | echo "Go code is not formatted:" 4 | gofmt -d -s . 5 | exit 1 6 | fi 7 | -------------------------------------------------------------------------------- /vendor/firebase.google.com/go/PULL_REQUEST_TEMPLATE.md: -------------------------------------------------------------------------------- 1 | Hey there! So you want to contribute to a Firebase SDK? 2 | Before you file this pull request, please read these guidelines: 3 | 4 | ### Discussion 5 | 6 | * Read the contribution guidelines (CONTRIBUTING.md). 7 | * If this has been discussed in an issue, make sure to link to the issue here. 8 | If not, go file an issue about this **before creating a pull request** to discuss. 9 | 10 | ### Testing 11 | 12 | * Make sure all existing tests in the repository pass after your change. 13 | * If you fixed a bug or added a feature, add a new test to cover your code. 14 | 15 | ### API Changes 16 | 17 | * At this time we cannot accept changes that affect the public API. If you'd like to help 18 | us make Firebase APIs better, please propose your change in an issue so that we 19 | can discuss it together. 20 | -------------------------------------------------------------------------------- /vendor/github.com/agext/levenshtein/.gitignore: -------------------------------------------------------------------------------- 1 | README.html 2 | coverage.out 3 | -------------------------------------------------------------------------------- /vendor/github.com/agext/levenshtein/MAINTAINERS: -------------------------------------------------------------------------------- 1 | Alex Bucataru (@AlexBucataru) 2 | -------------------------------------------------------------------------------- /vendor/github.com/agext/levenshtein/NOTICE: -------------------------------------------------------------------------------- 1 | Alrux Go EXTensions (AGExt) - package levenshtein 2 | Copyright 2016 ALRUX Inc. 3 | 4 | This product includes software developed at ALRUX Inc. 5 | (http://www.alrux.com/). 6 | -------------------------------------------------------------------------------- /vendor/github.com/apparentlymart/go-textseg/textseg/generate.go: -------------------------------------------------------------------------------- 1 | package textseg 2 | 3 | //go:generate go run make_tables.go -output tables.go 4 | //go:generate go run make_test_tables.go -output tables_test.go 5 | //go:generate ruby unicode2ragel.rb --url=http://www.unicode.org/Public/9.0.0/ucd/auxiliary/GraphemeBreakProperty.txt -m GraphemeCluster -p "Prepend,CR,LF,Control,Extend,Regional_Indicator,SpacingMark,L,V,T,LV,LVT,E_Base,E_Modifier,ZWJ,Glue_After_Zwj,E_Base_GAZ" -o grapheme_clusters_table.rl 6 | //go:generate ragel -Z grapheme_clusters.rl 7 | //go:generate gofmt -w grapheme_clusters.go 8 | -------------------------------------------------------------------------------- /vendor/github.com/apparentlymart/go-textseg/textseg/utf8_seqs.go: -------------------------------------------------------------------------------- 1 | package textseg 2 | 3 | import "unicode/utf8" 4 | 5 | // ScanGraphemeClusters is a split function for bufio.Scanner that splits 6 | // on UTF8 sequence boundaries. 7 | // 8 | // This is included largely for completeness, since this behavior is already 9 | // built in to Go when ranging over a string. 10 | func ScanUTF8Sequences(data []byte, atEOF bool) (int, []byte, error) { 11 | if len(data) == 0 { 12 | return 0, nil, nil 13 | } 14 | r, seqLen := utf8.DecodeRune(data) 15 | if r == utf8.RuneError && !atEOF { 16 | return 0, nil, nil 17 | } 18 | return seqLen, data[:seqLen], nil 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/armon/go-radix/.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects) 2 | *.o 3 | *.a 4 | *.so 5 | 6 | # Folders 7 | _obj 8 | _test 9 | 10 | # Architecture specific extensions/prefixes 11 | *.[568vq] 12 | [568vq].out 13 | 14 | *.cgo1.go 15 | *.cgo2.c 16 | _cgo_defun.c 17 | _cgo_gotypes.go 18 | _cgo_export.* 19 | 20 | _testmain.go 21 | 22 | *.exe 23 | -------------------------------------------------------------------------------- /vendor/github.com/armon/go-radix/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | go: 3 | - tip 4 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/NOTICE.txt: -------------------------------------------------------------------------------- 1 | AWS SDK for Go 2 | Copyright 2015 Amazon.com, Inc. or its affiliates. All Rights Reserved. 3 | Copyright 2014-2015 Stripe, Inc. 4 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/client/metadata/client_info.go: -------------------------------------------------------------------------------- 1 | package metadata 2 | 3 | // ClientInfo wraps immutable data from the client.Client structure. 4 | type ClientInfo struct { 5 | ServiceName string 6 | ServiceID string 7 | APIVersion string 8 | Endpoint string 9 | SigningName string 10 | SigningRegion string 11 | JSONVersion string 12 | TargetPrefix string 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/context_1_7.go: -------------------------------------------------------------------------------- 1 | // +build go1.7 2 | 3 | package aws 4 | 5 | import "context" 6 | 7 | var ( 8 | backgroundCtx = context.Background() 9 | ) 10 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/corehandlers/param_validator.go: -------------------------------------------------------------------------------- 1 | package corehandlers 2 | 3 | import "github.com/aws/aws-sdk-go/aws/request" 4 | 5 | // ValidateParametersHandler is a request handler to validate the input parameters. 6 | // Validating parameters only has meaning if done prior to the request being sent. 7 | var ValidateParametersHandler = request.NamedHandler{Name: "core.ValidateParametersHandler", Fn: func(r *request.Request) { 8 | if !r.ParamsFilled() { 9 | return 10 | } 11 | 12 | if v, ok := r.Params.(request.Validator); ok { 13 | if err := v.Validate(); err != nil { 14 | r.Error = err 15 | } 16 | } 17 | }} 18 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/credentials/example.ini: -------------------------------------------------------------------------------- 1 | [default] 2 | aws_access_key_id = accessKey 3 | aws_secret_access_key = secret 4 | aws_session_token = token 5 | 6 | [no_token] 7 | aws_access_key_id = accessKey 8 | aws_secret_access_key = secret 9 | 10 | [with_colon] 11 | aws_access_key_id: accessKey 12 | aws_secret_access_key: secret 13 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/errors.go: -------------------------------------------------------------------------------- 1 | package aws 2 | 3 | import "github.com/aws/aws-sdk-go/aws/awserr" 4 | 5 | var ( 6 | // ErrMissingRegion is an error that is returned if region configuration is 7 | // not found. 8 | // 9 | // @readonly 10 | ErrMissingRegion = awserr.New("MissingRegion", "could not find region configuration", nil) 11 | 12 | // ErrMissingEndpoint is an error that is returned if an endpoint cannot be 13 | // resolved for a service. 14 | // 15 | // @readonly 16 | ErrMissingEndpoint = awserr.New("MissingEndpoint", "'Endpoint' configuration is required for this service", nil) 17 | ) 18 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/jsonvalue.go: -------------------------------------------------------------------------------- 1 | package aws 2 | 3 | // JSONValue is a representation of a grab bag type that will be marshaled 4 | // into a json string. This type can be used just like any other map. 5 | // 6 | // Example: 7 | // 8 | // values := aws.JSONValue{ 9 | // "Foo": "Bar", 10 | // } 11 | // values["Baz"] = "Qux" 12 | type JSONValue map[string]interface{} 13 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/request/connection_reset_error.go: -------------------------------------------------------------------------------- 1 | // +build !appengine,!plan9 2 | 3 | package request 4 | 5 | import ( 6 | "net" 7 | "os" 8 | "syscall" 9 | ) 10 | 11 | func isErrConnectionReset(err error) bool { 12 | if opErr, ok := err.(*net.OpError); ok { 13 | if sysErr, ok := opErr.Err.(*os.SyscallError); ok { 14 | return sysErr.Err == syscall.ECONNRESET 15 | } 16 | } 17 | 18 | return false 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/request/connection_reset_error_other.go: -------------------------------------------------------------------------------- 1 | // +build appengine plan9 2 | 3 | package request 4 | 5 | import ( 6 | "strings" 7 | ) 8 | 9 | func isErrConnectionReset(err error) bool { 10 | return strings.Contains(err.Error(), "connection reset") 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/request/http_request.go: -------------------------------------------------------------------------------- 1 | package request 2 | 3 | import ( 4 | "io" 5 | "net/http" 6 | "net/url" 7 | ) 8 | 9 | func copyHTTPRequest(r *http.Request, body io.ReadCloser) *http.Request { 10 | req := new(http.Request) 11 | *req = *r 12 | req.URL = &url.URL{} 13 | *req.URL = *r.URL 14 | req.Body = body 15 | 16 | req.Header = http.Header{} 17 | for k, v := range r.Header { 18 | for _, vv := range v { 19 | req.Header.Add(k, vv) 20 | } 21 | } 22 | 23 | return req 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/request/request_context.go: -------------------------------------------------------------------------------- 1 | // +build go1.7 2 | 3 | package request 4 | 5 | import "github.com/aws/aws-sdk-go/aws" 6 | 7 | // setContext updates the Request to use the passed in context for cancellation. 8 | // Context will also be used for request retry delay. 9 | // 10 | // Creates shallow copy of the http.Request with the WithContext method. 11 | func setRequestContext(r *Request, ctx aws.Context) { 12 | r.context = ctx 13 | r.HTTPRequest = r.HTTPRequest.WithContext(ctx) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/request/request_context_1_6.go: -------------------------------------------------------------------------------- 1 | // +build !go1.7 2 | 3 | package request 4 | 5 | import "github.com/aws/aws-sdk-go/aws" 6 | 7 | // setContext updates the Request to use the passed in context for cancellation. 8 | // Context will also be used for request retry delay. 9 | // 10 | // Creates shallow copy of the http.Request with the WithContext method. 11 | func setRequestContext(r *Request, ctx aws.Context) { 12 | r.context = ctx 13 | r.HTTPRequest.Cancel = ctx.Done() 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/signer/v4/options.go: -------------------------------------------------------------------------------- 1 | package v4 2 | 3 | // WithUnsignedPayload will enable and set the UnsignedPayload field to 4 | // true of the signer. 5 | func WithUnsignedPayload(v4 *Signer) { 6 | v4.UnsignedPayload = true 7 | } 8 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/signer/v4/uri_path.go: -------------------------------------------------------------------------------- 1 | // +build go1.5 2 | 3 | package v4 4 | 5 | import ( 6 | "net/url" 7 | "strings" 8 | ) 9 | 10 | func getURIPath(u *url.URL) string { 11 | var uri string 12 | 13 | if len(u.Opaque) > 0 { 14 | uri = "/" + strings.Join(strings.Split(u.Opaque, "/")[3:], "/") 15 | } else { 16 | uri = u.EscapedPath() 17 | } 18 | 19 | if len(uri) == 0 { 20 | uri = "/" 21 | } 22 | 23 | return uri 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/url.go: -------------------------------------------------------------------------------- 1 | // +build go1.8 2 | 3 | package aws 4 | 5 | import "net/url" 6 | 7 | // URLHostname will extract the Hostname without port from the URL value. 8 | // 9 | // Wrapper of net/url#URL.Hostname for backwards Go version compatibility. 10 | func URLHostname(url *url.URL) string { 11 | return url.Hostname() 12 | } 13 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/url_1_7.go: -------------------------------------------------------------------------------- 1 | // +build !go1.8 2 | 3 | package aws 4 | 5 | import ( 6 | "net/url" 7 | "strings" 8 | ) 9 | 10 | // URLHostname will extract the Hostname without port from the URL value. 11 | // 12 | // Copy of Go 1.8's net/url#URL.Hostname functionality. 13 | func URLHostname(url *url.URL) string { 14 | return stripPort(url.Host) 15 | 16 | } 17 | 18 | // stripPort is copy of Go 1.8 url#URL.Hostname functionality. 19 | // https://golang.org/src/net/url/url.go 20 | func stripPort(hostport string) string { 21 | colon := strings.IndexByte(hostport, ':') 22 | if colon == -1 { 23 | return hostport 24 | } 25 | if i := strings.IndexByte(hostport, ']'); i != -1 { 26 | return strings.TrimPrefix(hostport[:i], "[") 27 | } 28 | return hostport[:colon] 29 | } 30 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/version.go: -------------------------------------------------------------------------------- 1 | // Package aws provides core functionality for making requests to AWS services. 2 | package aws 3 | 4 | // SDKName is the name of this AWS SDK 5 | const SDKName = "aws-sdk-go" 6 | 7 | // SDKVersion is the version of this SDK 8 | const SDKVersion = "1.14.27" 9 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/internal/sdkio/io_go1.6.go: -------------------------------------------------------------------------------- 1 | // +build !go1.7 2 | 3 | package sdkio 4 | 5 | // Copy of Go 1.7 io package's Seeker constants. 6 | const ( 7 | SeekStart = 0 // seek relative to the origin of the file 8 | SeekCurrent = 1 // seek relative to the current offset 9 | SeekEnd = 2 // seek relative to the end 10 | ) 11 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/internal/sdkio/io_go1.7.go: -------------------------------------------------------------------------------- 1 | // +build go1.7 2 | 3 | package sdkio 4 | 5 | import "io" 6 | 7 | // Alias for Go 1.7 io package Seeker constants 8 | const ( 9 | SeekStart = io.SeekStart // seek relative to the origin of the file 10 | SeekCurrent = io.SeekCurrent // seek relative to the current offset 11 | SeekEnd = io.SeekEnd // seek relative to the end 12 | ) 13 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/internal/sdkrand/locked_source.go: -------------------------------------------------------------------------------- 1 | package sdkrand 2 | 3 | import ( 4 | "math/rand" 5 | "sync" 6 | "time" 7 | ) 8 | 9 | // lockedSource is a thread-safe implementation of rand.Source 10 | type lockedSource struct { 11 | lk sync.Mutex 12 | src rand.Source 13 | } 14 | 15 | func (r *lockedSource) Int63() (n int64) { 16 | r.lk.Lock() 17 | n = r.src.Int63() 18 | r.lk.Unlock() 19 | return 20 | } 21 | 22 | func (r *lockedSource) Seed(seed int64) { 23 | r.lk.Lock() 24 | r.src.Seed(seed) 25 | r.lk.Unlock() 26 | } 27 | 28 | // SeededRand is a new RNG using a thread safe implementation of rand.Source 29 | var SeededRand = rand.New(&lockedSource{src: rand.NewSource(time.Now().UnixNano())}) 30 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/internal/sdkuri/path.go: -------------------------------------------------------------------------------- 1 | package sdkuri 2 | 3 | import ( 4 | "path" 5 | "strings" 6 | ) 7 | 8 | // PathJoin will join the elements of the path delimited by the "/" 9 | // character. Similar to path.Join with the exception the trailing "/" 10 | // character is preserved if present. 11 | func PathJoin(elems ...string) string { 12 | if len(elems) == 0 { 13 | return "" 14 | } 15 | 16 | hasTrailing := strings.HasSuffix(elems[len(elems)-1], "/") 17 | str := path.Join(elems...) 18 | if hasTrailing && str != "/" { 19 | str += "/" 20 | } 21 | 22 | return str 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/error.go: -------------------------------------------------------------------------------- 1 | package eventstream 2 | 3 | import "fmt" 4 | 5 | // LengthError provides the error for items being larger than a maximum length. 6 | type LengthError struct { 7 | Part string 8 | Want int 9 | Have int 10 | Value interface{} 11 | } 12 | 13 | func (e LengthError) Error() string { 14 | return fmt.Sprintf("%s length invalid, %d/%d, %v", 15 | e.Part, e.Want, e.Have, e.Value) 16 | } 17 | 18 | // ChecksumError provides the error for message checksum invalidation errors. 19 | type ChecksumError struct{} 20 | 21 | func (e ChecksumError) Error() string { 22 | return "message checksum mismatch" 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi/error.go: -------------------------------------------------------------------------------- 1 | package eventstreamapi 2 | 3 | import "fmt" 4 | 5 | type messageError struct { 6 | code string 7 | msg string 8 | } 9 | 10 | func (e messageError) Code() string { 11 | return e.code 12 | } 13 | 14 | func (e messageError) Message() string { 15 | return e.msg 16 | } 17 | 18 | func (e messageError) Error() string { 19 | return fmt.Sprintf("%s: %s", e.code, e.msg) 20 | } 21 | 22 | func (e messageError) OrigErr() error { 23 | return nil 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/private/protocol/unmarshal.go: -------------------------------------------------------------------------------- 1 | package protocol 2 | 3 | import ( 4 | "io" 5 | "io/ioutil" 6 | 7 | "github.com/aws/aws-sdk-go/aws/request" 8 | ) 9 | 10 | // UnmarshalDiscardBodyHandler is a named request handler to empty and close a response's body 11 | var UnmarshalDiscardBodyHandler = request.NamedHandler{Name: "awssdk.shared.UnmarshalDiscardBody", Fn: UnmarshalDiscardBody} 12 | 13 | // UnmarshalDiscardBody is a request handler to empty a response's body and closing it. 14 | func UnmarshalDiscardBody(r *request.Request) { 15 | if r.HTTPResponse == nil || r.HTTPResponse.Body == nil { 16 | return 17 | } 18 | 19 | io.Copy(ioutil.Discard, r.HTTPResponse.Body) 20 | r.HTTPResponse.Body.Close() 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/service/ec2/errors.go: -------------------------------------------------------------------------------- 1 | // Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. 2 | 3 | package ec2 4 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/service/s3/platform_handlers.go: -------------------------------------------------------------------------------- 1 | // +build !go1.6 2 | 3 | package s3 4 | 5 | import "github.com/aws/aws-sdk-go/aws/request" 6 | 7 | func platformRequestHandlers(r *request.Request) { 8 | } 9 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/service/s3/platform_handlers_go1.6.go: -------------------------------------------------------------------------------- 1 | // +build go1.6 2 | 3 | package s3 4 | 5 | import ( 6 | "github.com/aws/aws-sdk-go/aws" 7 | "github.com/aws/aws-sdk-go/aws/request" 8 | ) 9 | 10 | func platformRequestHandlers(r *request.Request) { 11 | if r.Operation.HTTPMethod == "PUT" { 12 | // 100-Continue should only be used on put requests. 13 | r.Handlers.Sign.PushBack(add100Continue) 14 | } 15 | } 16 | 17 | func add100Continue(r *request.Request) { 18 | if aws.BoolValue(r.Config.S3Disable100Continue) { 19 | return 20 | } 21 | if r.HTTPRequest.ContentLength < 1024*1024*2 { 22 | // Ignore requests smaller than 2MB. This helps prevent delaying 23 | // requests unnecessarily. 24 | return 25 | } 26 | 27 | r.HTTPRequest.Header.Set("Expect", "100-Continue") 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/service/sts/customizations.go: -------------------------------------------------------------------------------- 1 | package sts 2 | 3 | import "github.com/aws/aws-sdk-go/aws/request" 4 | 5 | func init() { 6 | initRequest = func(r *request.Request) { 7 | switch r.Operation.Name { 8 | case opAssumeRoleWithSAML, opAssumeRoleWithWebIdentity: 9 | r.Handlers.Sign.Clear() // these operations are unsigned 10 | } 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /vendor/github.com/bgentry/speakeasy/.gitignore: -------------------------------------------------------------------------------- 1 | example/example 2 | example/example.exe 3 | -------------------------------------------------------------------------------- /vendor/github.com/blang/semver/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | matrix: 3 | include: 4 | - go: 1.4.3 5 | - go: 1.5.4 6 | - go: 1.6.3 7 | - go: 1.7 8 | - go: tip 9 | allow_failures: 10 | - go: tip 11 | install: 12 | - go get golang.org/x/tools/cmd/cover 13 | - go get github.com/mattn/goveralls 14 | script: 15 | - echo "Test and track coverage" ; $HOME/gopath/bin/goveralls -package "." -service=travis-ci 16 | -repotoken $COVERALLS_TOKEN 17 | - echo "Build examples" ; cd examples && go build 18 | - echo "Check if gofmt'd" ; diff -u <(echo -n) <(gofmt -d -s .) 19 | env: 20 | global: 21 | secure: HroGEAUQpVq9zX1b1VIkraLiywhGbzvNnTZq2TMxgK7JHP8xqNplAeF1izrR2i4QLL9nsY+9WtYss4QuPvEtZcVHUobw6XnL6radF7jS1LgfYZ9Y7oF+zogZ2I5QUMRLGA7rcxQ05s7mKq3XZQfeqaNts4bms/eZRefWuaFZbkw= 22 | -------------------------------------------------------------------------------- /vendor/github.com/blang/semver/json.go: -------------------------------------------------------------------------------- 1 | package semver 2 | 3 | import ( 4 | "encoding/json" 5 | ) 6 | 7 | // MarshalJSON implements the encoding/json.Marshaler interface. 8 | func (v Version) MarshalJSON() ([]byte, error) { 9 | return json.Marshal(v.String()) 10 | } 11 | 12 | // UnmarshalJSON implements the encoding/json.Unmarshaler interface. 13 | func (v *Version) UnmarshalJSON(data []byte) (err error) { 14 | var versionString string 15 | 16 | if err = json.Unmarshal(data, &versionString); err != nil { 17 | return 18 | } 19 | 20 | *v, err = Parse(versionString) 21 | 22 | return 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/blang/semver/package.json: -------------------------------------------------------------------------------- 1 | { 2 | "author": "blang", 3 | "bugs": { 4 | "URL": "https://github.com/blang/semver/issues", 5 | "url": "https://github.com/blang/semver/issues" 6 | }, 7 | "gx": { 8 | "dvcsimport": "github.com/blang/semver" 9 | }, 10 | "gxVersion": "0.10.0", 11 | "language": "go", 12 | "license": "MIT", 13 | "name": "semver", 14 | "releaseCmd": "git commit -a -m \"gx publish $VERSION\"", 15 | "version": "3.5.1" 16 | } 17 | 18 | -------------------------------------------------------------------------------- /vendor/github.com/blang/semver/sort.go: -------------------------------------------------------------------------------- 1 | package semver 2 | 3 | import ( 4 | "sort" 5 | ) 6 | 7 | // Versions represents multiple versions. 8 | type Versions []Version 9 | 10 | // Len returns length of version collection 11 | func (s Versions) Len() int { 12 | return len(s) 13 | } 14 | 15 | // Swap swaps two versions inside the collection by its indices 16 | func (s Versions) Swap(i, j int) { 17 | s[i], s[j] = s[j], s[i] 18 | } 19 | 20 | // Less checks if version at index i is less than version at index j 21 | func (s Versions) Less(i, j int) bool { 22 | return s[i].LT(s[j]) 23 | } 24 | 25 | // Sort sorts a slice of versions 26 | func Sort(versions []Version) { 27 | sort.Sort(Versions(versions)) 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/blang/semver/sql.go: -------------------------------------------------------------------------------- 1 | package semver 2 | 3 | import ( 4 | "database/sql/driver" 5 | "fmt" 6 | ) 7 | 8 | // Scan implements the database/sql.Scanner interface. 9 | func (v *Version) Scan(src interface{}) (err error) { 10 | var str string 11 | switch src := src.(type) { 12 | case string: 13 | str = src 14 | case []byte: 15 | str = string(src) 16 | default: 17 | return fmt.Errorf("Version.Scan: cannot convert %T to string.", src) 18 | } 19 | 20 | if t, err := Parse(str); err == nil { 21 | *v = t 22 | } 23 | 24 | return 25 | } 26 | 27 | // Value implements the database/sql/driver.Valuer interface. 28 | func (v Version) Value() (driver.Value, error) { 29 | return v.String(), nil 30 | } 31 | -------------------------------------------------------------------------------- /vendor/github.com/davecgh/go-spew/LICENSE: -------------------------------------------------------------------------------- 1 | ISC License 2 | 3 | Copyright (c) 2012-2016 Dave Collins 4 | 5 | Permission to use, copy, modify, and distribute this software for any 6 | purpose with or without fee is hereby granted, provided that the above 7 | copyright notice and this permission notice appear in all copies. 8 | 9 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10 | WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11 | MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12 | ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 | OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 | -------------------------------------------------------------------------------- /vendor/github.com/fatih/color/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | go: 3 | - 1.8.x 4 | - tip 5 | 6 | -------------------------------------------------------------------------------- /vendor/github.com/fatih/color/Gopkg.lock: -------------------------------------------------------------------------------- 1 | # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'. 2 | 3 | 4 | [[projects]] 5 | name = "github.com/mattn/go-colorable" 6 | packages = ["."] 7 | revision = "167de6bfdfba052fa6b2d3664c8f5272e23c9072" 8 | version = "v0.0.9" 9 | 10 | [[projects]] 11 | name = "github.com/mattn/go-isatty" 12 | packages = ["."] 13 | revision = "0360b2af4f38e8d38c7fce2a9f4e702702d73a39" 14 | version = "v0.0.3" 15 | 16 | [[projects]] 17 | branch = "master" 18 | name = "golang.org/x/sys" 19 | packages = ["unix"] 20 | revision = "37707fdb30a5b38865cfb95e5aab41707daec7fd" 21 | 22 | [solve-meta] 23 | analyzer-name = "dep" 24 | analyzer-version = 1 25 | inputs-digest = "e8a50671c3cb93ea935bf210b1cd20702876b9d9226129be581ef646d1565cdc" 26 | solver-name = "gps-cdcl" 27 | solver-version = 1 28 | -------------------------------------------------------------------------------- /vendor/github.com/fatih/color/Gopkg.toml: -------------------------------------------------------------------------------- 1 | 2 | # Gopkg.toml example 3 | # 4 | # Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md 5 | # for detailed Gopkg.toml documentation. 6 | # 7 | # required = ["github.com/user/thing/cmd/thing"] 8 | # ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"] 9 | # 10 | # [[constraint]] 11 | # name = "github.com/user/project" 12 | # version = "1.0.0" 13 | # 14 | # [[constraint]] 15 | # name = "github.com/user/project2" 16 | # branch = "dev" 17 | # source = "github.com/myfork/project2" 18 | # 19 | # [[override]] 20 | # name = "github.com/x/y" 21 | # version = "2.4.0" 22 | 23 | 24 | [[constraint]] 25 | name = "github.com/mattn/go-colorable" 26 | version = "0.0.9" 27 | 28 | [[constraint]] 29 | name = "github.com/mattn/go-isatty" 30 | version = "0.0.3" 31 | -------------------------------------------------------------------------------- /vendor/github.com/go-ini/ini/.gitignore: -------------------------------------------------------------------------------- 1 | testdata/conf_out.ini 2 | ini.sublime-project 3 | ini.sublime-workspace 4 | testdata/conf_reflect.ini 5 | .idea 6 | /.vscode 7 | -------------------------------------------------------------------------------- /vendor/github.com/go-ini/ini/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | language: go 3 | go: 4 | - 1.6.x 5 | - 1.7.x 6 | - 1.8.x 7 | - 1.9.x 8 | - 1.10.x 9 | 10 | script: 11 | - go get golang.org/x/tools/cmd/cover 12 | - go get github.com/smartystreets/goconvey 13 | - mkdir -p $HOME/gopath/src/gopkg.in 14 | - ln -s $HOME/gopath/src/github.com/go-ini/ini $HOME/gopath/src/gopkg.in/ini.v1 15 | - cd $HOME/gopath/src/gopkg.in/ini.v1 16 | - go test -v -cover -race 17 | -------------------------------------------------------------------------------- /vendor/github.com/go-ini/ini/Makefile: -------------------------------------------------------------------------------- 1 | .PHONY: build test bench vet coverage 2 | 3 | build: vet bench 4 | 5 | test: 6 | go test -v -cover -race 7 | 8 | bench: 9 | go test -v -cover -race -test.bench=. -test.benchmem 10 | 11 | vet: 12 | go vet 13 | 14 | coverage: 15 | go test -coverprofile=c.out && go tool cover -html=c.out && rm c.out 16 | -------------------------------------------------------------------------------- /vendor/github.com/golang/protobuf/AUTHORS: -------------------------------------------------------------------------------- 1 | # This source code refers to The Go Authors for copyright purposes. 2 | # The master list of authors is in the main Go distribution, 3 | # visible at http://tip.golang.org/AUTHORS. 4 | -------------------------------------------------------------------------------- /vendor/github.com/golang/protobuf/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # This source code was written by the Go contributors. 2 | # The master list of contributors is in the main Go distribution, 3 | # visible at http://tip.golang.org/CONTRIBUTORS. 4 | -------------------------------------------------------------------------------- /vendor/github.com/googleapis/gax-go/.gitignore: -------------------------------------------------------------------------------- 1 | *.cover 2 | -------------------------------------------------------------------------------- /vendor/github.com/googleapis/gax-go/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | language: go 3 | go: 4 | - 1.6 5 | - 1.7 6 | before_install: 7 | - go get golang.org/x/tools/cmd/cover 8 | - go get golang.org/x/tools/cmd/goimports 9 | script: 10 | - gofmt -l . 11 | - goimports -l . 12 | - go tool vet . 13 | - go test -coverprofile=coverage.txt -covermode=atomic 14 | after_success: 15 | - bash <(curl -s https://codecov.io/bash) 16 | -------------------------------------------------------------------------------- /vendor/github.com/googleapis/gax-go/header.go: -------------------------------------------------------------------------------- 1 | package gax 2 | 3 | import "bytes" 4 | 5 | // XGoogHeader is for use by the Google Cloud Libraries only. 6 | // 7 | // XGoogHeader formats key-value pairs. 8 | // The resulting string is suitable for x-goog-api-client header. 9 | func XGoogHeader(keyval ...string) string { 10 | if len(keyval) == 0 { 11 | return "" 12 | } 13 | if len(keyval)%2 != 0 { 14 | panic("gax.Header: odd argument count") 15 | } 16 | var buf bytes.Buffer 17 | for i := 0; i < len(keyval); i += 2 { 18 | buf.WriteByte(' ') 19 | buf.WriteString(keyval[i]) 20 | buf.WriteByte('/') 21 | buf.WriteString(keyval[i+1]) 22 | } 23 | return buf.String()[1:] 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-getter/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | 3 | addons: 4 | apt: 5 | sources: 6 | - sourceline: 'ppa:git-core/ppa' 7 | packages: 8 | - git 9 | 10 | language: go 11 | 12 | go: 13 | - 1.8.x 14 | - 1.9.x 15 | - master 16 | 17 | branches: 18 | only: 19 | - master 20 | 21 | matrix: 22 | allow_failures: 23 | - go: master 24 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-getter/appveyor.yml: -------------------------------------------------------------------------------- 1 | version: "build-{branch}-{build}" 2 | image: Visual Studio 2017 3 | clone_folder: c:\gopath\github.com\hashicorp\go-getter 4 | environment: 5 | GOPATH: c:\gopath 6 | install: 7 | - cmd: >- 8 | echo %Path% 9 | 10 | go version 11 | 12 | go env 13 | 14 | go get -d -v -t ./... 15 | build_script: 16 | - cmd: go test -v ./... 17 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-getter/decompress_tbz2.go: -------------------------------------------------------------------------------- 1 | package getter 2 | 3 | import ( 4 | "compress/bzip2" 5 | "os" 6 | "path/filepath" 7 | ) 8 | 9 | // TarBzip2Decompressor is an implementation of Decompressor that can 10 | // decompress tar.bz2 files. 11 | type TarBzip2Decompressor struct{} 12 | 13 | func (d *TarBzip2Decompressor) Decompress(dst, src string, dir bool) error { 14 | // If we're going into a directory we should make that first 15 | mkdir := dst 16 | if !dir { 17 | mkdir = filepath.Dir(dst) 18 | } 19 | if err := os.MkdirAll(mkdir, 0755); err != nil { 20 | return err 21 | } 22 | 23 | // File first 24 | f, err := os.Open(src) 25 | if err != nil { 26 | return err 27 | } 28 | defer f.Close() 29 | 30 | // Bzip2 compression is second 31 | bzipR := bzip2.NewReader(f) 32 | return untar(bzipR, dst, src, dir) 33 | } 34 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-getter/get_file.go: -------------------------------------------------------------------------------- 1 | package getter 2 | 3 | import ( 4 | "net/url" 5 | "os" 6 | ) 7 | 8 | // FileGetter is a Getter implementation that will download a module from 9 | // a file scheme. 10 | type FileGetter struct { 11 | // Copy, if set to true, will copy data instead of using a symlink 12 | Copy bool 13 | } 14 | 15 | func (g *FileGetter) ClientMode(u *url.URL) (ClientMode, error) { 16 | path := u.Path 17 | if u.RawPath != "" { 18 | path = u.RawPath 19 | } 20 | 21 | fi, err := os.Stat(path) 22 | if err != nil { 23 | return 0, err 24 | } 25 | 26 | // Check if the source is a directory. 27 | if fi.IsDir() { 28 | return ClientModeDir, nil 29 | } 30 | 31 | return ClientModeFile, nil 32 | } 33 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-getter/helper/url/url.go: -------------------------------------------------------------------------------- 1 | package url 2 | 3 | import ( 4 | "net/url" 5 | ) 6 | 7 | // Parse parses rawURL into a URL structure. 8 | // The rawURL may be relative or absolute. 9 | // 10 | // Parse is a wrapper for the Go stdlib net/url Parse function, but returns 11 | // Windows "safe" URLs on Windows platforms. 12 | func Parse(rawURL string) (*url.URL, error) { 13 | return parse(rawURL) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-getter/helper/url/url_unix.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package url 4 | 5 | import ( 6 | "net/url" 7 | ) 8 | 9 | func parse(rawURL string) (*url.URL, error) { 10 | return url.Parse(rawURL) 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-getter/storage.go: -------------------------------------------------------------------------------- 1 | package getter 2 | 3 | // Storage is an interface that knows how to lookup downloaded directories 4 | // as well as download and update directories from their sources into the 5 | // proper location. 6 | type Storage interface { 7 | // Dir returns the directory on local disk where the directory source 8 | // can be loaded from. 9 | Dir(string) (string, bool, error) 10 | 11 | // Get will download and optionally update the given directory. 12 | Get(string, string, bool) error 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-getter/test-fixtures/detect-file-symlink-pwd/syml/pwd: -------------------------------------------------------------------------------- 1 | ../real -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-hclog/.gitignore: -------------------------------------------------------------------------------- 1 | .idea* -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-hclog/global.go: -------------------------------------------------------------------------------- 1 | package hclog 2 | 3 | import ( 4 | "sync" 5 | ) 6 | 7 | var ( 8 | protect sync.Once 9 | def Logger 10 | 11 | // The options used to create the Default logger. These are 12 | // read only when the Default logger is created, so set them 13 | // as soon as the process starts. 14 | DefaultOptions = &LoggerOptions{ 15 | Level: DefaultLevel, 16 | Output: DefaultOutput, 17 | } 18 | ) 19 | 20 | // Return a logger that is held globally. This can be a good starting 21 | // place, and then you can use .With() and .Name() to create sub-loggers 22 | // to be used in more specific contexts. 23 | func Default() Logger { 24 | protect.Do(func() { 25 | def = New(DefaultOptions) 26 | }) 27 | 28 | return def 29 | } 30 | 31 | // A short alias for Default() 32 | func L() Logger { 33 | return Default() 34 | } 35 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-multierror/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | 3 | language: go 4 | 5 | go: 6 | - 1.x 7 | 8 | branches: 9 | only: 10 | - master 11 | 12 | script: make test testrace 13 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-multierror/flatten.go: -------------------------------------------------------------------------------- 1 | package multierror 2 | 3 | // Flatten flattens the given error, merging any *Errors together into 4 | // a single *Error. 5 | func Flatten(err error) error { 6 | // If it isn't an *Error, just return the error as-is 7 | if _, ok := err.(*Error); !ok { 8 | return err 9 | } 10 | 11 | // Otherwise, make the result and flatten away! 12 | flatErr := new(Error) 13 | flatten(err, flatErr) 14 | return flatErr 15 | } 16 | 17 | func flatten(err error, flatErr *Error) { 18 | switch err := err.(type) { 19 | case *Error: 20 | for _, e := range err.Errors { 21 | flatten(e, flatErr) 22 | } 23 | default: 24 | flatErr.Errors = append(flatErr.Errors, err) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-multierror/format.go: -------------------------------------------------------------------------------- 1 | package multierror 2 | 3 | import ( 4 | "fmt" 5 | "strings" 6 | ) 7 | 8 | // ErrorFormatFunc is a function callback that is called by Error to 9 | // turn the list of errors into a string. 10 | type ErrorFormatFunc func([]error) string 11 | 12 | // ListFormatFunc is a basic formatter that outputs the number of errors 13 | // that occurred along with a bullet point list of the errors. 14 | func ListFormatFunc(es []error) string { 15 | if len(es) == 1 { 16 | return fmt.Sprintf("1 error occurred:\n\n* %s", es[0]) 17 | } 18 | 19 | points := make([]string, len(es)) 20 | for i, err := range es { 21 | points[i] = fmt.Sprintf("* %s", err) 22 | } 23 | 24 | return fmt.Sprintf( 25 | "%d errors occurred:\n\n%s", 26 | len(es), strings.Join(points, "\n")) 27 | } 28 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-multierror/sort.go: -------------------------------------------------------------------------------- 1 | package multierror 2 | 3 | // Len implements sort.Interface function for length 4 | func (err Error) Len() int { 5 | return len(err.Errors) 6 | } 7 | 8 | // Swap implements sort.Interface function for swapping elements 9 | func (err Error) Swap(i, j int) { 10 | err.Errors[i], err.Errors[j] = err.Errors[j], err.Errors[i] 11 | } 12 | 13 | // Less implements sort.Interface function for determining order 14 | func (err Error) Less(i, j int) bool { 15 | return err.Errors[i].Error() < err.Errors[j].Error() 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-plugin/.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-plugin/discover.go: -------------------------------------------------------------------------------- 1 | package plugin 2 | 3 | import ( 4 | "path/filepath" 5 | ) 6 | 7 | // Discover discovers plugins that are in a given directory. 8 | // 9 | // The directory doesn't need to be absolute. For example, "." will work fine. 10 | // 11 | // This currently assumes any file matching the glob is a plugin. 12 | // In the future this may be smarter about checking that a file is 13 | // executable and so on. 14 | // 15 | // TODO: test 16 | func Discover(glob, dir string) ([]string, error) { 17 | var err error 18 | 19 | // Make the directory absolute if it isn't already 20 | if !filepath.IsAbs(dir) { 21 | dir, err = filepath.Abs(dir) 22 | if err != nil { 23 | return nil, err 24 | } 25 | } 26 | 27 | return filepath.Glob(filepath.Join(dir, glob)) 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-plugin/error.go: -------------------------------------------------------------------------------- 1 | package plugin 2 | 3 | // This is a type that wraps error types so that they can be messaged 4 | // across RPC channels. Since "error" is an interface, we can't always 5 | // gob-encode the underlying structure. This is a valid error interface 6 | // implementer that we will push across. 7 | type BasicError struct { 8 | Message string 9 | } 10 | 11 | // NewBasicError is used to create a BasicError. 12 | // 13 | // err is allowed to be nil. 14 | func NewBasicError(err error) *BasicError { 15 | if err == nil { 16 | return nil 17 | } 18 | 19 | return &BasicError{err.Error()} 20 | } 21 | 22 | func (e *BasicError) Error() string { 23 | return e.Message 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-plugin/grpc_broker.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | package plugin; 3 | 4 | message ConnInfo { 5 | uint32 service_id = 1; 6 | string network = 2; 7 | string address = 3; 8 | } 9 | 10 | service GRPCBroker { 11 | rpc StartStream(stream ConnInfo) returns (stream ConnInfo); 12 | } 13 | 14 | 15 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-plugin/process.go: -------------------------------------------------------------------------------- 1 | package plugin 2 | 3 | import ( 4 | "time" 5 | ) 6 | 7 | // pidAlive checks whether a pid is alive. 8 | func pidAlive(pid int) bool { 9 | return _pidAlive(pid) 10 | } 11 | 12 | // pidWait blocks for a process to exit. 13 | func pidWait(pid int) error { 14 | ticker := time.NewTicker(1 * time.Second) 15 | defer ticker.Stop() 16 | 17 | for range ticker.C { 18 | if !pidAlive(pid) { 19 | break 20 | } 21 | } 22 | 23 | return nil 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-plugin/process_posix.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package plugin 4 | 5 | import ( 6 | "os" 7 | "syscall" 8 | ) 9 | 10 | // _pidAlive tests whether a process is alive or not by sending it Signal 0, 11 | // since Go otherwise has no way to test this. 12 | func _pidAlive(pid int) bool { 13 | proc, err := os.FindProcess(pid) 14 | if err == nil { 15 | err = proc.Signal(syscall.Signal(0)) 16 | } 17 | 18 | return err == nil 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-plugin/process_windows.go: -------------------------------------------------------------------------------- 1 | package plugin 2 | 3 | import ( 4 | "syscall" 5 | ) 6 | 7 | const ( 8 | // Weird name but matches the MSDN docs 9 | exit_STILL_ACTIVE = 259 10 | 11 | processDesiredAccess = syscall.STANDARD_RIGHTS_READ | 12 | syscall.PROCESS_QUERY_INFORMATION | 13 | syscall.SYNCHRONIZE 14 | ) 15 | 16 | // _pidAlive tests whether a process is alive or not 17 | func _pidAlive(pid int) bool { 18 | h, err := syscall.OpenProcess(processDesiredAccess, false, uint32(pid)) 19 | if err != nil { 20 | return false 21 | } 22 | 23 | var ec uint32 24 | if e := syscall.GetExitCodeProcess(h, &ec); e != nil { 25 | return false 26 | } 27 | 28 | return ec == exit_STILL_ACTIVE 29 | } 30 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-plugin/stream.go: -------------------------------------------------------------------------------- 1 | package plugin 2 | 3 | import ( 4 | "io" 5 | "log" 6 | ) 7 | 8 | func copyStream(name string, dst io.Writer, src io.Reader) { 9 | if src == nil { 10 | panic(name + ": src is nil") 11 | } 12 | if dst == nil { 13 | panic(name + ": dst is nil") 14 | } 15 | if _, err := io.Copy(dst, src); err != nil && err != io.EOF { 16 | log.Printf("[ERR] plugin: stream copy '%s' error: %s", name, err) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-safetemp/README.md: -------------------------------------------------------------------------------- 1 | # go-safetemp 2 | [![Godoc](https://godoc.org/github.com/hashcorp/go-safetemp?status.svg)](https://godoc.org/github.com/hashicorp/go-safetemp) 3 | 4 | Functions for safely working with temporary directories and files. 5 | 6 | ## Why? 7 | 8 | The Go standard library provides the excellent `ioutil` package for 9 | working with temporary directories and files. This library builds on top 10 | of that to provide safe abstractions above that. 11 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-uuid/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | sudo: false 4 | 5 | go: 6 | - 1.4 7 | - 1.5 8 | - 1.6 9 | - tip 10 | 11 | script: 12 | - go test -bench . -benchmem -v ./... 13 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-uuid/README.md: -------------------------------------------------------------------------------- 1 | # uuid [![Build Status](https://travis-ci.org/hashicorp/go-uuid.svg?branch=master)](https://travis-ci.org/hashicorp/go-uuid) 2 | 3 | Generates UUID-format strings using high quality, _purely random_ bytes. It is **not** intended to be RFC compliant, merely to use a well-understood string representation of a 128-bit value. It can also parse UUID-format strings into their component bytes. 4 | 5 | Documentation 6 | ============= 7 | 8 | The full documentation is available on [Godoc](http://godoc.org/github.com/hashicorp/go-uuid). 9 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-version/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | go: 4 | - 1.0 5 | - 1.1 6 | - 1.2 7 | - 1.3 8 | - 1.4 9 | - 1.9 10 | - "1.10" 11 | 12 | script: 13 | - go test 14 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-version/version_collection.go: -------------------------------------------------------------------------------- 1 | package version 2 | 3 | // Collection is a type that implements the sort.Interface interface 4 | // so that versions can be sorted. 5 | type Collection []*Version 6 | 7 | func (v Collection) Len() int { 8 | return len(v) 9 | } 10 | 11 | func (v Collection) Less(i, j int) bool { 12 | return v[i].LessThan(v[j]) 13 | } 14 | 15 | func (v Collection) Swap(i, j int) { 16 | v[i], v[j] = v[j], v[i] 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl/.gitignore: -------------------------------------------------------------------------------- 1 | y.output 2 | 3 | # ignore intellij files 4 | .idea 5 | *.iml 6 | *.ipr 7 | *.iws 8 | 9 | *.test 10 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | 3 | language: go 4 | 5 | go: 6 | - 1.x 7 | - tip 8 | 9 | branches: 10 | only: 11 | - master 12 | 13 | script: make test 14 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl/Makefile: -------------------------------------------------------------------------------- 1 | TEST?=./... 2 | 3 | default: test 4 | 5 | fmt: generate 6 | go fmt ./... 7 | 8 | test: generate 9 | go get -t ./... 10 | go test $(TEST) $(TESTARGS) 11 | 12 | generate: 13 | go generate ./... 14 | 15 | updatedeps: 16 | go get -u golang.org/x/tools/cmd/stringer 17 | 18 | .PHONY: default generate test updatedeps 19 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl/appveyor.yml: -------------------------------------------------------------------------------- 1 | version: "build-{branch}-{build}" 2 | image: Visual Studio 2015 3 | clone_folder: c:\gopath\src\github.com\hashicorp\hcl 4 | environment: 5 | GOPATH: c:\gopath 6 | init: 7 | - git config --global core.autocrlf false 8 | install: 9 | - cmd: >- 10 | echo %Path% 11 | 12 | go version 13 | 14 | go env 15 | 16 | go get -t ./... 17 | 18 | build_script: 19 | - cmd: go test -v ./... 20 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl/hcl.go: -------------------------------------------------------------------------------- 1 | // Package hcl decodes HCL into usable Go structures. 2 | // 3 | // hcl input can come in either pure HCL format or JSON format. 4 | // It can be parsed into an AST, and then decoded into a structure, 5 | // or it can be decoded directly from a string into a structure. 6 | // 7 | // If you choose to parse HCL into a raw AST, the benefit is that you 8 | // can write custom visitor implementations to implement custom 9 | // semantic checks. By default, HCL does not perform any semantic 10 | // checks. 11 | package hcl 12 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl/hcl/parser/error.go: -------------------------------------------------------------------------------- 1 | package parser 2 | 3 | import ( 4 | "fmt" 5 | 6 | "github.com/hashicorp/hcl/hcl/token" 7 | ) 8 | 9 | // PosError is a parse error that contains a position. 10 | type PosError struct { 11 | Pos token.Pos 12 | Err error 13 | } 14 | 15 | func (e *PosError) Error() string { 16 | return fmt.Sprintf("At %s: %s", e.Pos, e.Err) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl/lex.go: -------------------------------------------------------------------------------- 1 | package hcl 2 | 3 | import ( 4 | "unicode" 5 | "unicode/utf8" 6 | ) 7 | 8 | type lexModeValue byte 9 | 10 | const ( 11 | lexModeUnknown lexModeValue = iota 12 | lexModeHcl 13 | lexModeJson 14 | ) 15 | 16 | // lexMode returns whether we're going to be parsing in JSON 17 | // mode or HCL mode. 18 | func lexMode(v []byte) lexModeValue { 19 | var ( 20 | r rune 21 | w int 22 | offset int 23 | ) 24 | 25 | for { 26 | r, w = utf8.DecodeRune(v[offset:]) 27 | offset += w 28 | if unicode.IsSpace(r) { 29 | continue 30 | } 31 | if r == '{' { 32 | return lexModeJson 33 | } 34 | break 35 | } 36 | 37 | return lexModeHcl 38 | } 39 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl2/gohcl/types.go: -------------------------------------------------------------------------------- 1 | package gohcl 2 | 3 | import ( 4 | "reflect" 5 | 6 | "github.com/hashicorp/hcl2/hcl" 7 | ) 8 | 9 | var victimExpr hcl.Expression 10 | var victimBody hcl.Body 11 | 12 | var exprType = reflect.TypeOf(&victimExpr).Elem() 13 | var bodyType = reflect.TypeOf(&victimBody).Elem() 14 | var blockType = reflect.TypeOf((*hcl.Block)(nil)) 15 | var attrType = reflect.TypeOf((*hcl.Attribute)(nil)) 16 | var attrsType = reflect.TypeOf(hcl.Attributes(nil)) 17 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl2/hcl/doc.go: -------------------------------------------------------------------------------- 1 | package hcl 2 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl2/hcl/eval_context.go: -------------------------------------------------------------------------------- 1 | package hcl 2 | 3 | import ( 4 | "github.com/zclconf/go-cty/cty" 5 | "github.com/zclconf/go-cty/cty/function" 6 | ) 7 | 8 | // An EvalContext provides the variables and functions that should be used 9 | // to evaluate an expression. 10 | type EvalContext struct { 11 | Variables map[string]cty.Value 12 | Functions map[string]function.Function 13 | parent *EvalContext 14 | } 15 | 16 | // NewChild returns a new EvalContext that is a child of the receiver. 17 | func (ctx *EvalContext) NewChild() *EvalContext { 18 | return &EvalContext{parent: ctx} 19 | } 20 | 21 | // Parent returns the parent of the receiver, or nil if the receiver has 22 | // no parent. 23 | func (ctx *EvalContext) Parent() *EvalContext { 24 | return ctx.parent 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/doc.go: -------------------------------------------------------------------------------- 1 | // Package hclsyntax contains the parser, AST, etc for HCL's native language, 2 | // as opposed to the JSON variant. 3 | // 4 | // In normal use applications should rarely depend on this package directly, 5 | // instead preferring the higher-level interface of the main hcl package and 6 | // its companion package hclparse. 7 | package hclsyntax 8 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/file.go: -------------------------------------------------------------------------------- 1 | package hclsyntax 2 | 3 | import ( 4 | "github.com/hashicorp/hcl2/hcl" 5 | ) 6 | 7 | // File is the top-level object resulting from parsing a configuration file. 8 | type File struct { 9 | Body *Body 10 | Bytes []byte 11 | } 12 | 13 | func (f *File) AsHCLFile() *hcl.File { 14 | return &hcl.File{ 15 | Body: f.Body, 16 | Bytes: f.Bytes, 17 | 18 | // TODO: The Nav object, once we have an implementation of it 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/generate.go: -------------------------------------------------------------------------------- 1 | package hclsyntax 2 | 3 | //go:generate go run expression_vars_gen.go 4 | //go:generate ruby unicode2ragel.rb --url=http://www.unicode.org/Public/9.0.0/ucd/DerivedCoreProperties.txt -m UnicodeDerived -p ID_Start,ID_Continue -o unicode_derived.rl 5 | //go:generate ragel -Z scan_tokens.rl 6 | //go:generate gofmt -w scan_tokens.go 7 | //go:generate ragel -Z scan_string_lit.rl 8 | //go:generate gofmt -w scan_string_lit.go 9 | //go:generate stringer -type TokenType -output token_type_string.go 10 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/keywords.go: -------------------------------------------------------------------------------- 1 | package hclsyntax 2 | 3 | import ( 4 | "bytes" 5 | ) 6 | 7 | type Keyword []byte 8 | 9 | var forKeyword = Keyword([]byte{'f', 'o', 'r'}) 10 | var inKeyword = Keyword([]byte{'i', 'n'}) 11 | var ifKeyword = Keyword([]byte{'i', 'f'}) 12 | var elseKeyword = Keyword([]byte{'e', 'l', 's', 'e'}) 13 | var endifKeyword = Keyword([]byte{'e', 'n', 'd', 'i', 'f'}) 14 | var endforKeyword = Keyword([]byte{'e', 'n', 'd', 'f', 'o', 'r'}) 15 | 16 | func (kw Keyword) TokenMatches(token Token) bool { 17 | if token.Type != TokenIdent { 18 | return false 19 | } 20 | return bytes.Equal([]byte(kw), token.Bytes) 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/node.go: -------------------------------------------------------------------------------- 1 | package hclsyntax 2 | 3 | import ( 4 | "github.com/hashicorp/hcl2/hcl" 5 | ) 6 | 7 | // Node is the abstract type that every AST node implements. 8 | // 9 | // This is a closed interface, so it cannot be implemented from outside of 10 | // this package. 11 | type Node interface { 12 | // This is the mechanism by which the public-facing walk functions 13 | // are implemented. Implementations should call the given function 14 | // for each child node and then replace that node with its return value. 15 | // The return value might just be the same node, for non-transforming 16 | // walks. 17 | walkChildNodes(w internalWalkFunc) 18 | 19 | Range() hcl.Range 20 | } 21 | 22 | type internalWalkFunc func(Node) Node 23 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl2/hcl/json/doc.go: -------------------------------------------------------------------------------- 1 | // Package json is the JSON parser for HCL. It parses JSON files and returns 2 | // implementations of the core HCL structural interfaces in terms of the 3 | // JSON data inside. 4 | // 5 | // This is not a generic JSON parser. Instead, it deals with the mapping from 6 | // the JSON information model to the HCL information model, using a number 7 | // of hard-coded structural conventions. 8 | package json 9 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl2/hcl/json/peeker.go: -------------------------------------------------------------------------------- 1 | package json 2 | 3 | type peeker struct { 4 | tokens []token 5 | pos int 6 | } 7 | 8 | func newPeeker(tokens []token) *peeker { 9 | return &peeker{ 10 | tokens: tokens, 11 | pos: 0, 12 | } 13 | } 14 | 15 | func (p *peeker) Peek() token { 16 | return p.tokens[p.pos] 17 | } 18 | 19 | func (p *peeker) Read() token { 20 | ret := p.tokens[p.pos] 21 | if ret.Type != tokenEOF { 22 | p.pos++ 23 | } 24 | return ret 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl2/hcl/schema.go: -------------------------------------------------------------------------------- 1 | package hcl 2 | 3 | // BlockHeaderSchema represents the shape of a block header, and is 4 | // used for matching blocks within bodies. 5 | type BlockHeaderSchema struct { 6 | Type string 7 | LabelNames []string 8 | } 9 | 10 | // AttributeSchema represents the requirements for an attribute, and is used 11 | // for matching attributes within bodies. 12 | type AttributeSchema struct { 13 | Name string 14 | Required bool 15 | } 16 | 17 | // BodySchema represents the desired shallow structure of a body. 18 | type BodySchema struct { 19 | Attributes []AttributeSchema 20 | Blocks []BlockHeaderSchema 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl2/hcldec/block_labels.go: -------------------------------------------------------------------------------- 1 | package hcldec 2 | 3 | import ( 4 | "github.com/hashicorp/hcl2/hcl" 5 | ) 6 | 7 | type blockLabel struct { 8 | Value string 9 | Range hcl.Range 10 | } 11 | 12 | func labelsForBlock(block *hcl.Block) []blockLabel { 13 | ret := make([]blockLabel, len(block.Labels)) 14 | for i := range block.Labels { 15 | ret[i] = blockLabel{ 16 | Value: block.Labels[i], 17 | Range: block.LabelRanges[i], 18 | } 19 | } 20 | return ret 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl2/hcldec/doc.go: -------------------------------------------------------------------------------- 1 | // Package hcldec provides a higher-level API for unpacking the content of 2 | // HCL bodies, implemented in terms of the low-level "Content" API exposed 3 | // by the bodies themselves. 4 | // 5 | // It allows decoding an entire nested configuration in a single operation 6 | // by providing a description of the intended structure. 7 | // 8 | // For some applications it may be more convenient to use the "gohcl" 9 | // package, which has a similar purpose but decodes directly into native 10 | // Go data types. hcldec instead targets the cty type system, and thus allows 11 | // a cty-driven application to remain within that type system. 12 | package hcldec 13 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl2/hcldec/gob.go: -------------------------------------------------------------------------------- 1 | package hcldec 2 | 3 | import ( 4 | "encoding/gob" 5 | ) 6 | 7 | func init() { 8 | // Every Spec implementation should be registered with gob, so that 9 | // specs can be sent over gob channels, such as using 10 | // github.com/hashicorp/go-plugin with plugins that need to describe 11 | // what shape of configuration they are expecting. 12 | gob.Register(ObjectSpec(nil)) 13 | gob.Register(TupleSpec(nil)) 14 | gob.Register((*AttrSpec)(nil)) 15 | gob.Register((*LiteralSpec)(nil)) 16 | gob.Register((*ExprSpec)(nil)) 17 | gob.Register((*BlockSpec)(nil)) 18 | gob.Register((*BlockListSpec)(nil)) 19 | gob.Register((*BlockSetSpec)(nil)) 20 | gob.Register((*BlockMapSpec)(nil)) 21 | gob.Register((*BlockLabelSpec)(nil)) 22 | gob.Register((*DefaultSpec)(nil)) 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hil/.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | .idea 3 | *.iml 4 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hil/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | language: go 3 | go: 1.7 4 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hil/appveyor.yml: -------------------------------------------------------------------------------- 1 | version: "build-{branch}-{build}" 2 | image: Visual Studio 2015 3 | clone_folder: c:\gopath\src\github.com\hashicorp\hil 4 | environment: 5 | GOPATH: c:\gopath 6 | init: 7 | - git config --global core.autocrlf true 8 | install: 9 | - cmd: >- 10 | echo %Path% 11 | 12 | go version 13 | 14 | go env 15 | 16 | go get -d -v -t ./... 17 | build_script: 18 | - cmd: go test -v ./... 19 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hil/ast/arithmetic_op.go: -------------------------------------------------------------------------------- 1 | package ast 2 | 3 | // ArithmeticOp is the operation to use for the math. 4 | type ArithmeticOp int 5 | 6 | const ( 7 | ArithmeticOpInvalid ArithmeticOp = 0 8 | 9 | ArithmeticOpAdd ArithmeticOp = iota 10 | ArithmeticOpSub 11 | ArithmeticOpMul 12 | ArithmeticOpDiv 13 | ArithmeticOpMod 14 | 15 | ArithmeticOpLogicalAnd 16 | ArithmeticOpLogicalOr 17 | 18 | ArithmeticOpEqual 19 | ArithmeticOpNotEqual 20 | ArithmeticOpLessThan 21 | ArithmeticOpLessThanOrEqual 22 | ArithmeticOpGreaterThan 23 | ArithmeticOpGreaterThanOrEqual 24 | ) 25 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hil/ast/stack.go: -------------------------------------------------------------------------------- 1 | package ast 2 | 3 | // Stack is a stack of Node. 4 | type Stack struct { 5 | stack []Node 6 | } 7 | 8 | func (s *Stack) Len() int { 9 | return len(s.stack) 10 | } 11 | 12 | func (s *Stack) Push(n Node) { 13 | s.stack = append(s.stack, n) 14 | } 15 | 16 | func (s *Stack) Pop() Node { 17 | x := s.stack[len(s.stack)-1] 18 | s.stack[len(s.stack)-1] = nil 19 | s.stack = s.stack[:len(s.stack)-1] 20 | return x 21 | } 22 | 23 | func (s *Stack) Reset() { 24 | s.stack = nil 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hil/ast/unknown.go: -------------------------------------------------------------------------------- 1 | package ast 2 | 3 | // IsUnknown reports whether a variable is unknown or contains any value 4 | // that is unknown. This will recurse into lists and maps and so on. 5 | func IsUnknown(v Variable) bool { 6 | // If it is unknown itself, return true 7 | if v.Type == TypeUnknown { 8 | return true 9 | } 10 | 11 | // If it is a container type, check the values 12 | switch v.Type { 13 | case TypeList: 14 | for _, el := range v.Value.([]Variable) { 15 | if IsUnknown(el) { 16 | return true 17 | } 18 | } 19 | case TypeMap: 20 | for _, el := range v.Value.(map[string]Variable) { 21 | if IsUnknown(el) { 22 | return true 23 | } 24 | } 25 | default: 26 | } 27 | 28 | // Not a container type or survive the above checks 29 | return false 30 | } 31 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hil/ast/variable_access.go: -------------------------------------------------------------------------------- 1 | package ast 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | // VariableAccess represents a variable access. 8 | type VariableAccess struct { 9 | Name string 10 | Posx Pos 11 | } 12 | 13 | func (n *VariableAccess) Accept(v Visitor) Node { 14 | return v(n) 15 | } 16 | 17 | func (n *VariableAccess) Pos() Pos { 18 | return n.Posx 19 | } 20 | 21 | func (n *VariableAccess) GoString() string { 22 | return fmt.Sprintf("*%#v", *n) 23 | } 24 | 25 | func (n *VariableAccess) String() string { 26 | return fmt.Sprintf("Variable(%s)", n.Name) 27 | } 28 | 29 | func (n *VariableAccess) Type(s Scope) (Type, error) { 30 | v, ok := s.LookupVar(n.Name) 31 | if !ok { 32 | return TypeInvalid, fmt.Errorf("unknown variable: %s", n.Name) 33 | } 34 | 35 | return v.Type, nil 36 | } 37 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hil/eval_type.go: -------------------------------------------------------------------------------- 1 | package hil 2 | 3 | //go:generate stringer -type=EvalType eval_type.go 4 | 5 | // EvalType represents the type of the output returned from a HIL 6 | // evaluation. 7 | type EvalType uint32 8 | 9 | const ( 10 | TypeInvalid EvalType = 0 11 | TypeString EvalType = 1 << iota 12 | TypeBool 13 | TypeList 14 | TypeMap 15 | TypeUnknown 16 | ) 17 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hil/parser/fuzz.go: -------------------------------------------------------------------------------- 1 | // +build gofuzz 2 | 3 | package parser 4 | 5 | import ( 6 | "github.com/hashicorp/hil/ast" 7 | "github.com/hashicorp/hil/scanner" 8 | ) 9 | 10 | // This is a fuzz testing function designed to be used with go-fuzz: 11 | // https://github.com/dvyukov/go-fuzz 12 | // 13 | // It's not included in a normal build due to the gofuzz build tag above. 14 | // 15 | // There are some input files that you can use as a seed corpus for go-fuzz 16 | // in the directory ./fuzz-corpus . 17 | 18 | func Fuzz(data []byte) int { 19 | str := string(data) 20 | 21 | ch := scanner.Scan(str, ast.Pos{Line: 1, Column: 1}) 22 | _, err := Parse(ch) 23 | if err != nil { 24 | return 0 25 | } 26 | 27 | return 1 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/logutils/.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects) 2 | *.o 3 | *.a 4 | *.so 5 | 6 | # Folders 7 | _obj 8 | _test 9 | 10 | # Architecture specific extensions/prefixes 11 | *.[568vq] 12 | [568vq].out 13 | 14 | *.cgo1.go 15 | *.cgo2.c 16 | _cgo_defun.c 17 | _cgo_gotypes.go 18 | _cgo_export.* 19 | 20 | _testmain.go 21 | 22 | *.exe 23 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/config/configschema/doc.go: -------------------------------------------------------------------------------- 1 | // Package configschema contains types for describing the expected structure 2 | // of a configuration block whose shape is not known until runtime. 3 | // 4 | // For example, this is used to describe the expected contents of a resource 5 | // configuration block, which is defined by the corresponding provider plugin 6 | // and thus not compiled into Terraform core. 7 | // 8 | // A configschema primarily describes the shape of configuration, but it is 9 | // also suitable for use with other structures derived from the configuration, 10 | // such as the cached state of a resource or a resource diff. 11 | // 12 | // This package should not be confused with the package helper/schema, which 13 | // is the higher-level helper library used to implement providers themselves. 14 | package configschema 15 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/config/configschema/implied_type.go: -------------------------------------------------------------------------------- 1 | package configschema 2 | 3 | import ( 4 | "github.com/hashicorp/hcl2/hcldec" 5 | "github.com/zclconf/go-cty/cty" 6 | ) 7 | 8 | // ImpliedType returns the cty.Type that would result from decoding a 9 | // configuration block using the receiving block schema. 10 | // 11 | // ImpliedType always returns a result, even if the given schema is 12 | // inconsistent. Code that creates configschema.Block objects should be 13 | // tested using the InternalValidate method to detect any inconsistencies 14 | // that would cause this method to fall back on defaults and assumptions. 15 | func (b *Block) ImpliedType() cty.Type { 16 | if b == nil { 17 | return cty.EmptyObject 18 | } 19 | 20 | return hcldec.ImpliedType(b.DecoderSpec()) 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/config/configschema/nestingmode_string.go: -------------------------------------------------------------------------------- 1 | // Code generated by "stringer -type=NestingMode"; DO NOT EDIT. 2 | 3 | package configschema 4 | 5 | import "strconv" 6 | 7 | const _NestingMode_name = "nestingModeInvalidNestingSingleNestingListNestingSetNestingMap" 8 | 9 | var _NestingMode_index = [...]uint8{0, 18, 31, 42, 52, 62} 10 | 11 | func (i NestingMode) String() string { 12 | if i < 0 || i >= NestingMode(len(_NestingMode_index)-1) { 13 | return "NestingMode(" + strconv.FormatInt(int64(i), 10) + ")" 14 | } 15 | return _NestingMode_name[_NestingMode_index[i]:_NestingMode_index[i+1]] 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/config/lang.go: -------------------------------------------------------------------------------- 1 | package config 2 | 3 | import ( 4 | "github.com/hashicorp/hil/ast" 5 | ) 6 | 7 | type noopNode struct{} 8 | 9 | func (n *noopNode) Accept(ast.Visitor) ast.Node { return n } 10 | func (n *noopNode) Pos() ast.Pos { return ast.Pos{} } 11 | func (n *noopNode) Type(ast.Scope) (ast.Type, error) { return ast.TypeString, nil } 12 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/config/module/inode.go: -------------------------------------------------------------------------------- 1 | // +build linux darwin openbsd netbsd solaris dragonfly 2 | 3 | package module 4 | 5 | import ( 6 | "fmt" 7 | "os" 8 | "syscall" 9 | ) 10 | 11 | // lookup the inode of a file on posix systems 12 | func inode(path string) (uint64, error) { 13 | stat, err := os.Stat(path) 14 | if err != nil { 15 | return 0, err 16 | } 17 | if st, ok := stat.Sys().(*syscall.Stat_t); ok { 18 | return st.Ino, nil 19 | } 20 | return 0, fmt.Errorf("could not determine file inode") 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/config/module/inode_freebsd.go: -------------------------------------------------------------------------------- 1 | // +build freebsd 2 | 3 | package module 4 | 5 | import ( 6 | "fmt" 7 | "os" 8 | "syscall" 9 | ) 10 | 11 | // lookup the inode of a file on posix systems 12 | func inode(path string) (uint64, error) { 13 | stat, err := os.Stat(path) 14 | if err != nil { 15 | return 0, err 16 | } 17 | if st, ok := stat.Sys().(*syscall.Stat_t); ok { 18 | return uint64(st.Ino), nil 19 | } 20 | return 0, fmt.Errorf("could not determine file inode") 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/config/module/inode_windows.go: -------------------------------------------------------------------------------- 1 | // +build windows 2 | 3 | package module 4 | 5 | // no syscall.Stat_t on windows, return 0 for inodes 6 | func inode(path string) (uint64, error) { 7 | return 0, nil 8 | } 9 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/config/module/module.go: -------------------------------------------------------------------------------- 1 | package module 2 | 3 | // Module represents the metadata for a single module. 4 | type Module struct { 5 | Name string 6 | Source string 7 | Version string 8 | Providers map[string]string 9 | } 10 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/config/resource_mode.go: -------------------------------------------------------------------------------- 1 | package config 2 | 3 | //go:generate stringer -type=ResourceMode -output=resource_mode_string.go resource_mode.go 4 | type ResourceMode int 5 | 6 | const ( 7 | ManagedResourceMode ResourceMode = iota 8 | DataResourceMode 9 | ) 10 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/config/resource_mode_string.go: -------------------------------------------------------------------------------- 1 | // Code generated by "stringer -type=ResourceMode -output=resource_mode_string.go resource_mode.go"; DO NOT EDIT. 2 | 3 | package config 4 | 5 | import "strconv" 6 | 7 | const _ResourceMode_name = "ManagedResourceModeDataResourceMode" 8 | 9 | var _ResourceMode_index = [...]uint8{0, 19, 35} 10 | 11 | func (i ResourceMode) String() string { 12 | if i < 0 || i >= ResourceMode(len(_ResourceMode_index)-1) { 13 | return "ResourceMode(" + strconv.FormatInt(int64(i), 10) + ")" 14 | } 15 | return _ResourceMode_name[_ResourceMode_index[i]:_ResourceMode_index[i+1]] 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/config/testing.go: -------------------------------------------------------------------------------- 1 | package config 2 | 3 | import ( 4 | "testing" 5 | ) 6 | 7 | // TestRawConfig is used to create a RawConfig for testing. 8 | func TestRawConfig(t *testing.T, c map[string]interface{}) *RawConfig { 9 | t.Helper() 10 | 11 | cfg, err := NewRawConfig(c) 12 | if err != nil { 13 | t.Fatalf("err: %s", err) 14 | } 15 | 16 | return cfg 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/helper/acctest/acctest.go: -------------------------------------------------------------------------------- 1 | // Package acctest contains for Terraform Acceptance Tests 2 | package acctest 3 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/helper/config/decode.go: -------------------------------------------------------------------------------- 1 | package config 2 | 3 | import ( 4 | "github.com/mitchellh/mapstructure" 5 | ) 6 | 7 | func Decode(target interface{}, raws ...interface{}) (*mapstructure.Metadata, error) { 8 | var md mapstructure.Metadata 9 | decoderConfig := &mapstructure.DecoderConfig{ 10 | Metadata: &md, 11 | Result: target, 12 | WeaklyTypedInput: true, 13 | } 14 | 15 | decoder, err := mapstructure.NewDecoder(decoderConfig) 16 | if err != nil { 17 | return nil, err 18 | } 19 | 20 | for _, raw := range raws { 21 | err := decoder.Decode(raw) 22 | if err != nil { 23 | return nil, err 24 | } 25 | } 26 | 27 | return &md, nil 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/helper/hashcode/hashcode.go: -------------------------------------------------------------------------------- 1 | package hashcode 2 | 3 | import ( 4 | "bytes" 5 | "fmt" 6 | "hash/crc32" 7 | ) 8 | 9 | // String hashes a string to a unique hashcode. 10 | // 11 | // crc32 returns a uint32, but for our use we need 12 | // and non negative integer. Here we cast to an integer 13 | // and invert it if the result is negative. 14 | func String(s string) int { 15 | v := int(crc32.ChecksumIEEE([]byte(s))) 16 | if v >= 0 { 17 | return v 18 | } 19 | if -v >= 0 { 20 | return -v 21 | } 22 | // v == MinInt 23 | return 0 24 | } 25 | 26 | // Strings hashes a list of strings to a unique hashcode. 27 | func Strings(strings []string) string { 28 | var buf bytes.Buffer 29 | 30 | for _, s := range strings { 31 | buf.WriteString(fmt.Sprintf("%s-", s)) 32 | } 33 | 34 | return fmt.Sprintf("%d", String(buf.String())) 35 | } 36 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/helper/schema/README.md: -------------------------------------------------------------------------------- 1 | # Terraform Helper Lib: schema 2 | 3 | The `schema` package provides a high-level interface for writing resource 4 | providers for Terraform. 5 | 6 | If you're writing a resource provider, we recommend you use this package. 7 | 8 | The interface exposed by this package is much friendlier than trying to 9 | write to the Terraform API directly. The core Terraform API is low-level 10 | and built for maximum flexibility and control, whereas this library is built 11 | as a framework around that to more easily write common providers. 12 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/helper/schema/equal.go: -------------------------------------------------------------------------------- 1 | package schema 2 | 3 | // Equal is an interface that checks for deep equality between two objects. 4 | type Equal interface { 5 | Equal(interface{}) bool 6 | } 7 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/helper/schema/field_writer.go: -------------------------------------------------------------------------------- 1 | package schema 2 | 3 | // FieldWriters are responsible for writing fields by address into 4 | // a proper typed representation. ResourceData uses this to write new data 5 | // into existing sources. 6 | type FieldWriter interface { 7 | WriteField([]string, interface{}) error 8 | } 9 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/helper/schema/resource_data_get_source.go: -------------------------------------------------------------------------------- 1 | package schema 2 | 3 | //go:generate stringer -type=getSource resource_data_get_source.go 4 | 5 | // getSource represents the level we want to get for a value (internally). 6 | // Any source less than or equal to the level will be loaded (whichever 7 | // has a value first). 8 | type getSource byte 9 | 10 | const ( 11 | getSourceState getSource = 1 << iota 12 | getSourceConfig 13 | getSourceDiff 14 | getSourceSet 15 | getSourceExact // Only get from the _exact_ level 16 | getSourceLevelMask getSource = getSourceState | getSourceConfig | getSourceDiff | getSourceSet 17 | ) 18 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/helper/schema/testing.go: -------------------------------------------------------------------------------- 1 | package schema 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/hashicorp/terraform/config" 7 | "github.com/hashicorp/terraform/terraform" 8 | ) 9 | 10 | // TestResourceDataRaw creates a ResourceData from a raw configuration map. 11 | func TestResourceDataRaw( 12 | t *testing.T, schema map[string]*Schema, raw map[string]interface{}) *ResourceData { 13 | t.Helper() 14 | 15 | c, err := config.NewRawConfig(raw) 16 | if err != nil { 17 | t.Fatalf("err: %s", err) 18 | } 19 | 20 | sm := schemaMap(schema) 21 | diff, err := sm.Diff(nil, terraform.NewResourceConfig(c), nil, nil) 22 | if err != nil { 23 | t.Fatalf("err: %s", err) 24 | } 25 | 26 | result, err := sm.Data(nil, diff) 27 | if err != nil { 28 | t.Fatalf("err: %s", err) 29 | } 30 | 31 | return result 32 | } 33 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/helper/schema/valuetype.go: -------------------------------------------------------------------------------- 1 | package schema 2 | 3 | //go:generate stringer -type=ValueType valuetype.go 4 | 5 | // ValueType is an enum of the type that can be represented by a schema. 6 | type ValueType int 7 | 8 | const ( 9 | TypeInvalid ValueType = iota 10 | TypeBool 11 | TypeInt 12 | TypeFloat 13 | TypeString 14 | TypeList 15 | TypeMap 16 | TypeSet 17 | typeObject 18 | ) 19 | 20 | // NOTE: ValueType has more functions defined on it in schema.go. We can't 21 | // put them here because we reference other files. 22 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/helper/schema/valuetype_string.go: -------------------------------------------------------------------------------- 1 | // Code generated by "stringer -type=ValueType valuetype.go"; DO NOT EDIT. 2 | 3 | package schema 4 | 5 | import "strconv" 6 | 7 | const _ValueType_name = "TypeInvalidTypeBoolTypeIntTypeFloatTypeStringTypeListTypeMapTypeSettypeObject" 8 | 9 | var _ValueType_index = [...]uint8{0, 11, 19, 26, 35, 45, 53, 60, 67, 77} 10 | 11 | func (i ValueType) String() string { 12 | if i < 0 || i >= ValueType(len(_ValueType_index)-1) { 13 | return "ValueType(" + strconv.FormatInt(int64(i), 10) + ")" 14 | } 15 | return _ValueType_name[_ValueType_index[i]:_ValueType_index[i+1]] 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/helper/structure/expand_json.go: -------------------------------------------------------------------------------- 1 | package structure 2 | 3 | import "encoding/json" 4 | 5 | func ExpandJsonFromString(jsonString string) (map[string]interface{}, error) { 6 | var result map[string]interface{} 7 | 8 | err := json.Unmarshal([]byte(jsonString), &result) 9 | 10 | return result, err 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/helper/structure/flatten_json.go: -------------------------------------------------------------------------------- 1 | package structure 2 | 3 | import "encoding/json" 4 | 5 | func FlattenJsonToString(input map[string]interface{}) (string, error) { 6 | if len(input) == 0 { 7 | return "", nil 8 | } 9 | 10 | result, err := json.Marshal(input) 11 | if err != nil { 12 | return "", err 13 | } 14 | 15 | return string(result), nil 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/helper/structure/normalize_json.go: -------------------------------------------------------------------------------- 1 | package structure 2 | 3 | import "encoding/json" 4 | 5 | // Takes a value containing JSON string and passes it through 6 | // the JSON parser to normalize it, returns either a parsing 7 | // error or normalized JSON string. 8 | func NormalizeJsonString(jsonString interface{}) (string, error) { 9 | var j interface{} 10 | 11 | if jsonString == nil || jsonString.(string) == "" { 12 | return "", nil 13 | } 14 | 15 | s := jsonString.(string) 16 | 17 | err := json.Unmarshal([]byte(s), &j) 18 | if err != nil { 19 | return s, err 20 | } 21 | 22 | bytes, _ := json.Marshal(j) 23 | return string(bytes[:]), nil 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/helper/structure/suppress_json_diff.go: -------------------------------------------------------------------------------- 1 | package structure 2 | 3 | import ( 4 | "reflect" 5 | 6 | "github.com/hashicorp/terraform/helper/schema" 7 | ) 8 | 9 | func SuppressJsonDiff(k, old, new string, d *schema.ResourceData) bool { 10 | oldMap, err := ExpandJsonFromString(old) 11 | if err != nil { 12 | return false 13 | } 14 | 15 | newMap, err := ExpandJsonFromString(new) 16 | if err != nil { 17 | return false 18 | } 19 | 20 | return reflect.DeepEqual(oldMap, newMap) 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/httpclient/client.go: -------------------------------------------------------------------------------- 1 | package httpclient 2 | 3 | import ( 4 | "net/http" 5 | 6 | cleanhttp "github.com/hashicorp/go-cleanhttp" 7 | ) 8 | 9 | // New returns the DefaultPooledClient from the cleanhttp 10 | // package that will also send a Terraform User-Agent string. 11 | func New() *http.Client { 12 | cli := cleanhttp.DefaultPooledClient() 13 | cli.Transport = &userAgentRoundTripper{ 14 | userAgent: UserAgentString(), 15 | inner: cli.Transport, 16 | } 17 | return cli 18 | } 19 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/moduledeps/doc.go: -------------------------------------------------------------------------------- 1 | // Package moduledeps contains types that can be used to describe the 2 | // providers required for all of the modules in a module tree. 3 | // 4 | // It does not itself contain the functionality for populating such 5 | // data structures; that's in Terraform core, since this package intentionally 6 | // does not depend on terraform core to avoid package dependency cycles. 7 | package moduledeps 8 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/plugin/plugin.go: -------------------------------------------------------------------------------- 1 | package plugin 2 | 3 | import ( 4 | "github.com/hashicorp/go-plugin" 5 | ) 6 | 7 | // See serve.go for serving plugins 8 | 9 | // PluginMap should be used by clients for the map of plugins. 10 | var PluginMap = map[string]plugin.Plugin{ 11 | "provider": &ResourceProviderPlugin{}, 12 | "provisioner": &ResourceProvisionerPlugin{}, 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/plugin/ui_output.go: -------------------------------------------------------------------------------- 1 | package plugin 2 | 3 | import ( 4 | "net/rpc" 5 | 6 | "github.com/hashicorp/terraform/terraform" 7 | ) 8 | 9 | // UIOutput is an implementatin of terraform.UIOutput that communicates 10 | // over RPC. 11 | type UIOutput struct { 12 | Client *rpc.Client 13 | } 14 | 15 | func (o *UIOutput) Output(v string) { 16 | o.Client.Call("Plugin.Output", v, new(interface{})) 17 | } 18 | 19 | // UIOutputServer is the RPC server for serving UIOutput. 20 | type UIOutputServer struct { 21 | UIOutput terraform.UIOutput 22 | } 23 | 24 | func (s *UIOutputServer) Output( 25 | v string, 26 | reply *interface{}) error { 27 | s.UIOutput.Output(v) 28 | return nil 29 | } 30 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/registry/errors.go: -------------------------------------------------------------------------------- 1 | package registry 2 | 3 | import ( 4 | "fmt" 5 | 6 | "github.com/hashicorp/terraform/registry/regsrc" 7 | ) 8 | 9 | type errModuleNotFound struct { 10 | addr *regsrc.Module 11 | } 12 | 13 | func (e *errModuleNotFound) Error() string { 14 | return fmt.Sprintf("module %s not found", e.addr) 15 | } 16 | 17 | // IsModuleNotFound returns true only if the given error is a "module not found" 18 | // error. This allows callers to recognize this particular error condition 19 | // as distinct from operational errors such as poor network connectivity. 20 | func IsModuleNotFound(err error) bool { 21 | _, ok := err.(*errModuleNotFound) 22 | return ok 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/registry/regsrc/regsrc.go: -------------------------------------------------------------------------------- 1 | // Package regsrc provides helpers for working with source strings that identify 2 | // resources within a Terraform registry. 3 | package regsrc 4 | 5 | var ( 6 | // PublicRegistryHost is a FriendlyHost that represents the public registry. 7 | PublicRegistryHost = NewFriendlyHost("registry.terraform.io") 8 | ) 9 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/registry/response/module_list.go: -------------------------------------------------------------------------------- 1 | package response 2 | 3 | // ModuleList is the response structure for a pageable list of modules. 4 | type ModuleList struct { 5 | Meta PaginationMeta `json:"meta"` 6 | Modules []*Module `json:"modules"` 7 | } 8 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/registry/response/module_provider.go: -------------------------------------------------------------------------------- 1 | package response 2 | 3 | // ModuleProvider represents a single provider for modules. 4 | type ModuleProvider struct { 5 | Name string `json:"name"` 6 | Downloads int `json:"downloads"` 7 | ModuleCount int `json:"module_count"` 8 | } 9 | 10 | // ModuleProviderList is the response structure for a pageable list of ModuleProviders. 11 | type ModuleProviderList struct { 12 | Meta PaginationMeta `json:"meta"` 13 | Providers []*ModuleProvider `json:"providers"` 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/registry/response/redirect.go: -------------------------------------------------------------------------------- 1 | package response 2 | 3 | // Redirect causes the frontend to perform a window redirect. 4 | type Redirect struct { 5 | URL string `json:"url"` 6 | } 7 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/svchost/auth/from_map.go: -------------------------------------------------------------------------------- 1 | package auth 2 | 3 | // HostCredentialsFromMap converts a map of key-value pairs from a credentials 4 | // definition provided by the user (e.g. in a config file, or via a credentials 5 | // helper) into a HostCredentials object if possible, or returns nil if 6 | // no credentials could be extracted from the map. 7 | // 8 | // This function ignores map keys it is unfamiliar with, to allow for future 9 | // expansion of the credentials map format for new credential types. 10 | func HostCredentialsFromMap(m map[string]interface{}) HostCredentials { 11 | if m == nil { 12 | return nil 13 | } 14 | if token, ok := m["token"].(string); ok { 15 | return HostCredentialsToken(token) 16 | } 17 | return nil 18 | } 19 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/svchost/auth/token_credentials.go: -------------------------------------------------------------------------------- 1 | package auth 2 | 3 | import ( 4 | "net/http" 5 | ) 6 | 7 | // HostCredentialsToken is a HostCredentials implementation that represents a 8 | // single "bearer token", to be sent to the server via an Authorization header 9 | // with the auth type set to "Bearer" 10 | type HostCredentialsToken string 11 | 12 | // PrepareRequest alters the given HTTP request by setting its Authorization 13 | // header to the string "Bearer " followed by the encapsulated authentication 14 | // token. 15 | func (tc HostCredentialsToken) PrepareRequest(req *http.Request) { 16 | if req.Header == nil { 17 | req.Header = http.Header{} 18 | } 19 | req.Header.Set("Authorization", "Bearer "+string(tc)) 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/edge_destroy.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | import ( 4 | "fmt" 5 | 6 | "github.com/hashicorp/terraform/dag" 7 | ) 8 | 9 | // DestroyEdge is an edge that represents a standard "destroy" relationship: 10 | // Target depends on Source because Source is destroying. 11 | type DestroyEdge struct { 12 | S, T dag.Vertex 13 | } 14 | 15 | func (e *DestroyEdge) Hashcode() interface{} { return fmt.Sprintf("%p-%p", e.S, e.T) } 16 | func (e *DestroyEdge) Source() dag.Vertex { return e.S } 17 | func (e *DestroyEdge) Target() dag.Vertex { return e.T } 18 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/eval_count_computed.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | import ( 4 | "fmt" 5 | 6 | "github.com/hashicorp/terraform/config" 7 | ) 8 | 9 | // EvalCountCheckComputed is an EvalNode that checks if a resource count 10 | // is computed and errors if so. This can possibly happen across a 11 | // module boundary and we don't yet support this. 12 | type EvalCountCheckComputed struct { 13 | Resource *config.Resource 14 | } 15 | 16 | // TODO: test 17 | func (n *EvalCountCheckComputed) Eval(ctx EvalContext) (interface{}, error) { 18 | if n.Resource.RawCount.Value() == unknownValue() { 19 | return nil, fmt.Errorf( 20 | "%s: value of 'count' cannot be computed", 21 | n.Resource.Id()) 22 | } 23 | 24 | return nil, nil 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/eval_error.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | // EvalReturnError is an EvalNode implementation that returns an 4 | // error if it is present. 5 | // 6 | // This is useful for scenarios where an error has been captured by 7 | // another EvalNode (like EvalApply) for special EvalTree-based error 8 | // handling, and that handling has completed, so the error should be 9 | // returned normally. 10 | type EvalReturnError struct { 11 | Error *error 12 | } 13 | 14 | func (n *EvalReturnError) Eval(ctx EvalContext) (interface{}, error) { 15 | if n.Error == nil { 16 | return nil, nil 17 | } 18 | 19 | return nil, *n.Error 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/eval_if.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | // EvalIf is an EvalNode that is a conditional. 4 | type EvalIf struct { 5 | If func(EvalContext) (bool, error) 6 | Then EvalNode 7 | Else EvalNode 8 | } 9 | 10 | // TODO: test 11 | func (n *EvalIf) Eval(ctx EvalContext) (interface{}, error) { 12 | yes, err := n.If(ctx) 13 | if err != nil { 14 | return nil, err 15 | } 16 | 17 | if yes { 18 | return EvalRaw(n.Then, ctx) 19 | } else { 20 | if n.Else != nil { 21 | return EvalRaw(n.Else, ctx) 22 | } 23 | } 24 | 25 | return nil, nil 26 | } 27 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/eval_noop.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | // EvalNoop is an EvalNode that does nothing. 4 | type EvalNoop struct{} 5 | 6 | func (EvalNoop) Eval(EvalContext) (interface{}, error) { 7 | return nil, nil 8 | } 9 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/eval_resource.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | // EvalInstanceInfo is an EvalNode implementation that fills in the 4 | // InstanceInfo as much as it can. 5 | type EvalInstanceInfo struct { 6 | Info *InstanceInfo 7 | } 8 | 9 | // TODO: test 10 | func (n *EvalInstanceInfo) Eval(ctx EvalContext) (interface{}, error) { 11 | n.Info.ModulePath = ctx.Path() 12 | return nil, nil 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/eval_sequence.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | // EvalSequence is an EvalNode that evaluates in sequence. 4 | type EvalSequence struct { 5 | Nodes []EvalNode 6 | } 7 | 8 | func (n *EvalSequence) Eval(ctx EvalContext) (interface{}, error) { 9 | for _, n := range n.Nodes { 10 | if n == nil { 11 | continue 12 | } 13 | 14 | if _, err := EvalRaw(n, ctx); err != nil { 15 | return nil, err 16 | } 17 | } 18 | 19 | return nil, nil 20 | } 21 | 22 | // EvalNodeFilterable impl. 23 | func (n *EvalSequence) Filter(fn EvalNodeFilterFunc) { 24 | for i, node := range n.Nodes { 25 | n.Nodes[i] = fn(node) 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/features.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | import "os" 4 | 5 | // This file holds feature flags for the next release 6 | 7 | var flagWarnOutputErrors = os.Getenv("TF_WARN_OUTPUT_ERRORS") != "" 8 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/graph_dot.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | import "github.com/hashicorp/terraform/dag" 4 | 5 | // GraphDot returns the dot formatting of a visual representation of 6 | // the given Terraform graph. 7 | func GraphDot(g *Graph, opts *dag.DotOpts) (string, error) { 8 | return string(g.Dot(opts)), nil 9 | } 10 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/graph_interface_subgraph.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | // GraphNodeSubPath says that a node is part of a graph with a 4 | // different path, and the context should be adjusted accordingly. 5 | type GraphNodeSubPath interface { 6 | Path() []string 7 | } 8 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/graph_walk_operation.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | //go:generate stringer -type=walkOperation graph_walk_operation.go 4 | 5 | // walkOperation is an enum which tells the walkContext what to do. 6 | type walkOperation byte 7 | 8 | const ( 9 | walkInvalid walkOperation = iota 10 | walkInput 11 | walkApply 12 | walkPlan 13 | walkPlanDestroy 14 | walkRefresh 15 | walkValidate 16 | walkDestroy 17 | walkImport 18 | ) 19 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/graphtype_string.go: -------------------------------------------------------------------------------- 1 | // Code generated by "stringer -type=GraphType context_graph_type.go"; DO NOT EDIT. 2 | 3 | package terraform 4 | 5 | import "strconv" 6 | 7 | const _GraphType_name = "GraphTypeInvalidGraphTypeLegacyGraphTypeRefreshGraphTypePlanGraphTypePlanDestroyGraphTypeApplyGraphTypeInputGraphTypeValidate" 8 | 9 | var _GraphType_index = [...]uint8{0, 16, 31, 47, 60, 80, 94, 108, 125} 10 | 11 | func (i GraphType) String() string { 12 | if i >= GraphType(len(_GraphType_index)-1) { 13 | return "GraphType(" + strconv.FormatInt(int64(i), 10) + ")" 14 | } 15 | return _GraphType_name[_GraphType_index[i]:_GraphType_index[i+1]] 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/instancetype.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | //go:generate stringer -type=InstanceType instancetype.go 4 | 5 | // InstanceType is an enum of the various types of instances store in the State 6 | type InstanceType int 7 | 8 | const ( 9 | TypeInvalid InstanceType = iota 10 | TypePrimary 11 | TypeTainted 12 | TypeDeposed 13 | ) 14 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/instancetype_string.go: -------------------------------------------------------------------------------- 1 | // Code generated by "stringer -type=InstanceType instancetype.go"; DO NOT EDIT. 2 | 3 | package terraform 4 | 5 | import "strconv" 6 | 7 | const _InstanceType_name = "TypeInvalidTypePrimaryTypeTaintedTypeDeposed" 8 | 9 | var _InstanceType_index = [...]uint8{0, 11, 22, 33, 44} 10 | 11 | func (i InstanceType) String() string { 12 | if i < 0 || i >= InstanceType(len(_InstanceType_index)-1) { 13 | return "InstanceType(" + strconv.FormatInt(int64(i), 10) + ")" 14 | } 15 | return _InstanceType_name[_InstanceType_index[i]:_InstanceType_index[i+1]] 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/node_count_boundary.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | // NodeCountBoundary fixes any "count boundarie" in the state: resources 4 | // that are named "foo.0" when they should be named "foo" 5 | type NodeCountBoundary struct{} 6 | 7 | func (n *NodeCountBoundary) Name() string { 8 | return "meta.count-boundary (count boundary fixup)" 9 | } 10 | 11 | // GraphNodeEvalable 12 | func (n *NodeCountBoundary) EvalTree() EvalNode { 13 | return &EvalCountFixZeroOneBoundaryGlobal{} 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/node_data_destroy.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | // NodeDestroyableDataResource represents a resource that is "plannable": 4 | // it is ready to be planned in order to create a diff. 5 | type NodeDestroyableDataResource struct { 6 | *NodeAbstractResource 7 | } 8 | 9 | // GraphNodeEvalable 10 | func (n *NodeDestroyableDataResource) EvalTree() EvalNode { 11 | addr := n.NodeAbstractResource.Addr 12 | 13 | // stateId is the ID to put into the state 14 | stateId := addr.stateId() 15 | 16 | // Just destroy it. 17 | var state *InstanceState 18 | return &EvalWriteState{ 19 | Name: stateId, 20 | State: &state, // state is nil here 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/node_provider.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | // NodeApplyableProvider represents a provider during an apply. 4 | type NodeApplyableProvider struct { 5 | *NodeAbstractProvider 6 | } 7 | 8 | // GraphNodeEvalable 9 | func (n *NodeApplyableProvider) EvalTree() EvalNode { 10 | return ProviderEvalTree(n, n.ProviderConfig()) 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/node_root_variable.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | import ( 4 | "fmt" 5 | 6 | "github.com/hashicorp/terraform/config" 7 | ) 8 | 9 | // NodeRootVariable represents a root variable input. 10 | type NodeRootVariable struct { 11 | Config *config.Variable 12 | } 13 | 14 | func (n *NodeRootVariable) Name() string { 15 | result := fmt.Sprintf("var.%s", n.Config.Name) 16 | return result 17 | } 18 | 19 | // GraphNodeReferenceable 20 | func (n *NodeRootVariable) ReferenceableName() []string { 21 | return []string{n.Name()} 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/path.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | import ( 4 | "strings" 5 | ) 6 | 7 | // PathCacheKey returns a cache key for a module path. 8 | func PathCacheKey(path []string) string { 9 | return strings.Join(path, "|") 10 | } 11 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/test_failure: -------------------------------------------------------------------------------- 1 | --- FAIL: TestContext2Plan_moduleProviderInherit (0.01s) 2 | context_plan_test.go:552: bad: []string{"child"} 3 | map[string]dag.Vertex{} 4 | "module.middle.null" 5 | map[string]dag.Vertex{} 6 | "module.middle.module.inner.null" 7 | map[string]dag.Vertex{} 8 | "aws" 9 | FAIL 10 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/testing.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | import ( 4 | "os" 5 | "testing" 6 | ) 7 | 8 | // TestStateFile writes the given state to the path. 9 | func TestStateFile(t *testing.T, path string, state *State) { 10 | f, err := os.Create(path) 11 | if err != nil { 12 | t.Fatalf("err: %s", err) 13 | } 14 | defer f.Close() 15 | 16 | if err := WriteState(state, f); err != nil { 17 | t.Fatalf("err: %s", err) 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/transform_attach_config_provider.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | import ( 4 | "github.com/hashicorp/terraform/config" 5 | ) 6 | 7 | // GraphNodeAttachProvider is an interface that must be implemented by nodes 8 | // that want provider configurations attached. 9 | type GraphNodeAttachProvider interface { 10 | // Must be implemented to determine the path for the configuration 11 | GraphNodeSubPath 12 | 13 | // ProviderName with no module prefix. Example: "aws". 14 | ProviderName() string 15 | 16 | // Sets the configuration 17 | AttachProvider(*config.ProviderConfig) 18 | } 19 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/transform_config_old.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | import ( 4 | "fmt" 5 | 6 | "github.com/hashicorp/terraform/config" 7 | ) 8 | 9 | // varNameForVar returns the VarName value for an interpolated variable. 10 | // This value is compared to the VarName() value for the nodes within the 11 | // graph to build the graph edges. 12 | func varNameForVar(raw config.InterpolatedVariable) string { 13 | switch v := raw.(type) { 14 | case *config.ModuleVariable: 15 | return fmt.Sprintf("module.%s.output.%s", v.Name, v.Field) 16 | case *config.ResourceVariable: 17 | return v.ResourceId() 18 | case *config.UserVariable: 19 | return fmt.Sprintf("var.%s", v.Name) 20 | default: 21 | return "" 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/transform_count_boundary.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | import ( 4 | "github.com/hashicorp/terraform/dag" 5 | ) 6 | 7 | // CountBoundaryTransformer adds a node that depends on everything else 8 | // so that it runs last in order to clean up the state for nodes that 9 | // are on the "count boundary": "foo.0" when only one exists becomes "foo" 10 | type CountBoundaryTransformer struct{} 11 | 12 | func (t *CountBoundaryTransformer) Transform(g *Graph) error { 13 | node := &NodeCountBoundary{} 14 | g.Add(node) 15 | 16 | // Depends on everything 17 | for _, v := range g.Vertices() { 18 | // Don't connect to ourselves 19 | if v == node { 20 | continue 21 | } 22 | 23 | // Connect! 24 | g.Connect(dag.BasicEdge(node, v)) 25 | } 26 | 27 | return nil 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/transform_transitive_reduction.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | // TransitiveReductionTransformer is a GraphTransformer that performs 4 | // finds the transitive reduction of the graph. For a definition of 5 | // transitive reduction, see Wikipedia. 6 | type TransitiveReductionTransformer struct{} 7 | 8 | func (t *TransitiveReductionTransformer) Transform(g *Graph) error { 9 | // If the graph isn't valid, skip the transitive reduction. 10 | // We don't error here because Terraform itself handles graph 11 | // validation in a better way, or we assume it does. 12 | if err := g.Validate(); err != nil { 13 | return nil 14 | } 15 | 16 | // Do it 17 | g.TransitiveReduction() 18 | 19 | return nil 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/ui_input_mock.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | // MockUIInput is an implementation of UIInput that can be used for tests. 4 | type MockUIInput struct { 5 | InputCalled bool 6 | InputOpts *InputOpts 7 | InputReturnMap map[string]string 8 | InputReturnString string 9 | InputReturnError error 10 | InputFn func(*InputOpts) (string, error) 11 | } 12 | 13 | func (i *MockUIInput) Input(opts *InputOpts) (string, error) { 14 | i.InputCalled = true 15 | i.InputOpts = opts 16 | if i.InputFn != nil { 17 | return i.InputFn(opts) 18 | } 19 | if i.InputReturnMap != nil { 20 | return i.InputReturnMap[opts.Id], i.InputReturnError 21 | } 22 | return i.InputReturnString, i.InputReturnError 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/ui_input_prefix.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | // PrefixUIInput is an implementation of UIInput that prefixes the ID 8 | // with a string, allowing queries to be namespaced. 9 | type PrefixUIInput struct { 10 | IdPrefix string 11 | QueryPrefix string 12 | UIInput UIInput 13 | } 14 | 15 | func (i *PrefixUIInput) Input(opts *InputOpts) (string, error) { 16 | opts.Id = fmt.Sprintf("%s.%s", i.IdPrefix, opts.Id) 17 | opts.Query = fmt.Sprintf("%s%s", i.QueryPrefix, opts.Query) 18 | return i.UIInput.Input(opts) 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/ui_output.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | // UIOutput is the interface that must be implemented to output 4 | // data to the end user. 5 | type UIOutput interface { 6 | Output(string) 7 | } 8 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/ui_output_callback.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | type CallbackUIOutput struct { 4 | OutputFn func(string) 5 | } 6 | 7 | func (o *CallbackUIOutput) Output(v string) { 8 | o.OutputFn(v) 9 | } 10 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/ui_output_mock.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | import "sync" 4 | 5 | // MockUIOutput is an implementation of UIOutput that can be used for tests. 6 | type MockUIOutput struct { 7 | sync.Mutex 8 | OutputCalled bool 9 | OutputMessage string 10 | OutputFn func(string) 11 | } 12 | 13 | func (o *MockUIOutput) Output(v string) { 14 | o.Lock() 15 | defer o.Unlock() 16 | o.OutputCalled = true 17 | o.OutputMessage = v 18 | if o.OutputFn != nil { 19 | o.OutputFn(v) 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/ui_output_provisioner.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | // ProvisionerUIOutput is an implementation of UIOutput that calls a hook 4 | // for the output so that the hooks can handle it. 5 | type ProvisionerUIOutput struct { 6 | Info *InstanceInfo 7 | Type string 8 | Hooks []Hook 9 | } 10 | 11 | func (o *ProvisionerUIOutput) Output(msg string) { 12 | for _, h := range o.Hooks { 13 | h.ProvisionOutput(o.Info, o.Type, msg) 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/user_agent.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | import ( 4 | "github.com/hashicorp/terraform/httpclient" 5 | ) 6 | 7 | // Generate a UserAgent string 8 | // 9 | // Deprecated: Use httpclient.UserAgentString if you are setting your 10 | // own User-Agent header. 11 | func UserAgentString() string { 12 | return httpclient.UserAgentString() 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/version.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | import ( 4 | "github.com/hashicorp/terraform/version" 5 | ) 6 | 7 | // TODO: update providers to use the version package directly 8 | func VersionString() string { 9 | return version.String() 10 | } 11 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/terraform/walkoperation_string.go: -------------------------------------------------------------------------------- 1 | // Code generated by "stringer -type=walkOperation graph_walk_operation.go"; DO NOT EDIT. 2 | 3 | package terraform 4 | 5 | import "strconv" 6 | 7 | const _walkOperation_name = "walkInvalidwalkInputwalkApplywalkPlanwalkPlanDestroywalkRefreshwalkValidatewalkDestroywalkImport" 8 | 9 | var _walkOperation_index = [...]uint8{0, 11, 20, 29, 37, 52, 63, 75, 86, 96} 10 | 11 | func (i walkOperation) String() string { 12 | if i >= walkOperation(len(_walkOperation_index)-1) { 13 | return "walkOperation(" + strconv.FormatInt(int64(i), 10) + ")" 14 | } 15 | return _walkOperation_name[_walkOperation_index[i]:_walkOperation_index[i+1]] 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/tfdiags/diagnostic.go: -------------------------------------------------------------------------------- 1 | package tfdiags 2 | 3 | type Diagnostic interface { 4 | Severity() Severity 5 | Description() Description 6 | Source() Source 7 | } 8 | 9 | type Severity rune 10 | 11 | //go:generate stringer -type=Severity 12 | 13 | const ( 14 | Error Severity = 'E' 15 | Warning Severity = 'W' 16 | ) 17 | 18 | type Description struct { 19 | Summary string 20 | Detail string 21 | } 22 | 23 | type Source struct { 24 | Subject *SourceRange 25 | Context *SourceRange 26 | } 27 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/tfdiags/error.go: -------------------------------------------------------------------------------- 1 | package tfdiags 2 | 3 | // nativeError is a Diagnostic implementation that wraps a normal Go error 4 | type nativeError struct { 5 | err error 6 | } 7 | 8 | var _ Diagnostic = nativeError{} 9 | 10 | func (e nativeError) Severity() Severity { 11 | return Error 12 | } 13 | 14 | func (e nativeError) Description() Description { 15 | return Description{ 16 | Summary: e.err.Error(), 17 | } 18 | } 19 | 20 | func (e nativeError) Source() Source { 21 | // No source information available for a native error 22 | return Source{} 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/tfdiags/severity_string.go: -------------------------------------------------------------------------------- 1 | // Code generated by "stringer -type=Severity"; DO NOT EDIT. 2 | 3 | package tfdiags 4 | 5 | import "strconv" 6 | 7 | const ( 8 | _Severity_name_0 = "Error" 9 | _Severity_name_1 = "Warning" 10 | ) 11 | 12 | func (i Severity) String() string { 13 | switch { 14 | case i == 69: 15 | return _Severity_name_0 16 | case i == 87: 17 | return _Severity_name_1 18 | default: 19 | return "Severity(" + strconv.FormatInt(int64(i), 10) + ")" 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform/tfdiags/simple_warning.go: -------------------------------------------------------------------------------- 1 | package tfdiags 2 | 3 | type simpleWarning string 4 | 5 | var _ Diagnostic = simpleWarning("") 6 | 7 | // SimpleWarning constructs a simple (summary-only) warning diagnostic. 8 | func SimpleWarning(msg string) Diagnostic { 9 | return simpleWarning(msg) 10 | } 11 | 12 | func (e simpleWarning) Severity() Severity { 13 | return Warning 14 | } 15 | 16 | func (e simpleWarning) Description() Description { 17 | return Description{ 18 | Summary: string(e), 19 | } 20 | } 21 | 22 | func (e simpleWarning) Source() Source { 23 | // No source information available for a native error 24 | return Source{} 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/yamux/.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects) 2 | *.o 3 | *.a 4 | *.so 5 | 6 | # Folders 7 | _obj 8 | _test 9 | 10 | # Architecture specific extensions/prefixes 11 | *.[568vq] 12 | [568vq].out 13 | 14 | *.cgo1.go 15 | *.cgo2.c 16 | _cgo_defun.c 17 | _cgo_gotypes.go 18 | _cgo_export.* 19 | 20 | _testmain.go 21 | 22 | *.exe 23 | *.test 24 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/yamux/util.go: -------------------------------------------------------------------------------- 1 | package yamux 2 | 3 | import ( 4 | "sync" 5 | "time" 6 | ) 7 | 8 | var ( 9 | timerPool = &sync.Pool{ 10 | New: func() interface{} { 11 | timer := time.NewTimer(time.Hour * 1e6) 12 | timer.Stop() 13 | return timer 14 | }, 15 | } 16 | ) 17 | 18 | // asyncSendErr is used to try an async send of an error 19 | func asyncSendErr(ch chan error, err error) { 20 | if ch == nil { 21 | return 22 | } 23 | select { 24 | case ch <- err: 25 | default: 26 | } 27 | } 28 | 29 | // asyncNotify is used to signal a waiting goroutine 30 | func asyncNotify(ch chan struct{}) { 31 | select { 32 | case ch <- struct{}{}: 33 | default: 34 | } 35 | } 36 | 37 | // min computes the minimum of two values 38 | func min(a, b uint32) uint32 { 39 | if a < b { 40 | return a 41 | } 42 | return b 43 | } 44 | -------------------------------------------------------------------------------- /vendor/github.com/jmespath/go-jmespath/.gitignore: -------------------------------------------------------------------------------- 1 | jpgo 2 | jmespath-fuzz.zip 3 | cpu.out 4 | go-jmespath.test 5 | -------------------------------------------------------------------------------- /vendor/github.com/jmespath/go-jmespath/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | sudo: false 4 | 5 | go: 6 | - 1.4 7 | 8 | install: go get -v -t ./... 9 | script: make test 10 | -------------------------------------------------------------------------------- /vendor/github.com/jmespath/go-jmespath/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright 2015 James Saryerwinnie 2 | 3 | Licensed under the Apache License, Version 2.0 (the "License"); 4 | you may not use this file except in compliance with the License. 5 | You may obtain a copy of the License at 6 | 7 | http://www.apache.org/licenses/LICENSE-2.0 8 | 9 | Unless required by applicable law or agreed to in writing, software 10 | distributed under the License is distributed on an "AS IS" BASIS, 11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | See the License for the specific language governing permissions and 13 | limitations under the License. 14 | -------------------------------------------------------------------------------- /vendor/github.com/jmespath/go-jmespath/README.md: -------------------------------------------------------------------------------- 1 | # go-jmespath - A JMESPath implementation in Go 2 | 3 | [![Build Status](https://img.shields.io/travis/jmespath/go-jmespath.svg)](https://travis-ci.org/jmespath/go-jmespath) 4 | 5 | 6 | 7 | See http://jmespath.org for more info. 8 | -------------------------------------------------------------------------------- /vendor/github.com/jmespath/go-jmespath/toktype_string.go: -------------------------------------------------------------------------------- 1 | // generated by stringer -type=tokType; DO NOT EDIT 2 | 3 | package jmespath 4 | 5 | import "fmt" 6 | 7 | const _tokType_name = "tUnknowntStartDottFiltertFlattentLparentRparentLbrackettRbrackettLbracetRbracetOrtPipetNumbertUnquotedIdentifiertQuotedIdentifiertCommatColontLTtLTEtGTtGTEtEQtNEtJSONLiteraltStringLiteraltCurrenttExpreftAndtNottEOF" 8 | 9 | var _tokType_index = [...]uint8{0, 8, 13, 17, 24, 32, 39, 46, 55, 64, 71, 78, 81, 86, 93, 112, 129, 135, 141, 144, 148, 151, 155, 158, 161, 173, 187, 195, 202, 206, 210, 214} 10 | 11 | func (i tokType) String() string { 12 | if i < 0 || i >= tokType(len(_tokType_index)-1) { 13 | return fmt.Sprintf("tokType(%d)", i) 14 | } 15 | return _tokType_name[_tokType_index[i]:_tokType_index[i+1]] 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-colorable/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | go: 3 | - tip 4 | 5 | before_install: 6 | - go get github.com/mattn/goveralls 7 | - go get golang.org/x/tools/cmd/cover 8 | script: 9 | - $HOME/gopath/bin/goveralls -repotoken xnXqRGwgW3SXIguzxf90ZSK1GPYZPaGrw 10 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-colorable/colorable_appengine.go: -------------------------------------------------------------------------------- 1 | // +build appengine 2 | 3 | package colorable 4 | 5 | import ( 6 | "io" 7 | "os" 8 | 9 | _ "github.com/mattn/go-isatty" 10 | ) 11 | 12 | // NewColorable return new instance of Writer which handle escape sequence. 13 | func NewColorable(file *os.File) io.Writer { 14 | if file == nil { 15 | panic("nil passed instead of *os.File to NewColorable()") 16 | } 17 | 18 | return file 19 | } 20 | 21 | // NewColorableStdout return new instance of Writer which handle escape sequence for stdout. 22 | func NewColorableStdout() io.Writer { 23 | return os.Stdout 24 | } 25 | 26 | // NewColorableStderr return new instance of Writer which handle escape sequence for stderr. 27 | func NewColorableStderr() io.Writer { 28 | return os.Stderr 29 | } 30 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-colorable/colorable_others.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | // +build !appengine 3 | 4 | package colorable 5 | 6 | import ( 7 | "io" 8 | "os" 9 | 10 | _ "github.com/mattn/go-isatty" 11 | ) 12 | 13 | // NewColorable return new instance of Writer which handle escape sequence. 14 | func NewColorable(file *os.File) io.Writer { 15 | if file == nil { 16 | panic("nil passed instead of *os.File to NewColorable()") 17 | } 18 | 19 | return file 20 | } 21 | 22 | // NewColorableStdout return new instance of Writer which handle escape sequence for stdout. 23 | func NewColorableStdout() io.Writer { 24 | return os.Stdout 25 | } 26 | 27 | // NewColorableStderr return new instance of Writer which handle escape sequence for stderr. 28 | func NewColorableStderr() io.Writer { 29 | return os.Stderr 30 | } 31 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | go: 3 | - tip 4 | 5 | before_install: 6 | - go get github.com/mattn/goveralls 7 | - go get golang.org/x/tools/cmd/cover 8 | script: 9 | - $HOME/gopath/bin/goveralls -repotoken 3gHdORO5k5ziZcWMBxnd9LrMZaJs8m9x5 10 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/doc.go: -------------------------------------------------------------------------------- 1 | // Package isatty implements interface to isatty 2 | package isatty 3 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/isatty_appengine.go: -------------------------------------------------------------------------------- 1 | // +build appengine 2 | 3 | package isatty 4 | 5 | // IsTerminal returns true if the file descriptor is terminal which 6 | // is always false on on appengine classic which is a sandboxed PaaS. 7 | func IsTerminal(fd uintptr) bool { 8 | return false 9 | } 10 | 11 | // IsCygwinTerminal() return true if the file descriptor is a cygwin or msys2 12 | // terminal. This is also always false on this environment. 13 | func IsCygwinTerminal(fd uintptr) bool { 14 | return false 15 | } 16 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/isatty_bsd.go: -------------------------------------------------------------------------------- 1 | // +build darwin freebsd openbsd netbsd dragonfly 2 | // +build !appengine 3 | 4 | package isatty 5 | 6 | import ( 7 | "syscall" 8 | "unsafe" 9 | ) 10 | 11 | const ioctlReadTermios = syscall.TIOCGETA 12 | 13 | // IsTerminal return true if the file descriptor is terminal. 14 | func IsTerminal(fd uintptr) bool { 15 | var termios syscall.Termios 16 | _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0) 17 | return err == 0 18 | } 19 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/isatty_linux.go: -------------------------------------------------------------------------------- 1 | // +build linux 2 | // +build !appengine,!ppc64,!ppc64le 3 | 4 | package isatty 5 | 6 | import ( 7 | "syscall" 8 | "unsafe" 9 | ) 10 | 11 | const ioctlReadTermios = syscall.TCGETS 12 | 13 | // IsTerminal return true if the file descriptor is terminal. 14 | func IsTerminal(fd uintptr) bool { 15 | var termios syscall.Termios 16 | _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0) 17 | return err == 0 18 | } 19 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/isatty_linux_ppc64x.go: -------------------------------------------------------------------------------- 1 | // +build linux 2 | // +build ppc64 ppc64le 3 | 4 | package isatty 5 | 6 | import ( 7 | "unsafe" 8 | 9 | syscall "golang.org/x/sys/unix" 10 | ) 11 | 12 | const ioctlReadTermios = syscall.TCGETS 13 | 14 | // IsTerminal return true if the file descriptor is terminal. 15 | func IsTerminal(fd uintptr) bool { 16 | var termios syscall.Termios 17 | _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0) 18 | return err == 0 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/isatty_others.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | // +build !appengine 3 | 4 | package isatty 5 | 6 | // IsCygwinTerminal() return true if the file descriptor is a cygwin or msys2 7 | // terminal. This is also always false on this environment. 8 | func IsCygwinTerminal(fd uintptr) bool { 9 | return false 10 | } 11 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/isatty_solaris.go: -------------------------------------------------------------------------------- 1 | // +build solaris 2 | // +build !appengine 3 | 4 | package isatty 5 | 6 | import ( 7 | "golang.org/x/sys/unix" 8 | ) 9 | 10 | // IsTerminal returns true if the given file descriptor is a terminal. 11 | // see: http://src.illumos.org/source/xref/illumos-gate/usr/src/lib/libbc/libc/gen/common/isatty.c 12 | func IsTerminal(fd uintptr) bool { 13 | var termio unix.Termio 14 | err := unix.IoctlSetTermio(int(fd), unix.TCGETA, &termio) 15 | return err == nil 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/mitchellh/cli/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | 3 | language: go 4 | 5 | go: 6 | - "1.8" 7 | - "1.9" 8 | - "1.10" 9 | 10 | branches: 11 | only: 12 | - master 13 | 14 | script: make updatedeps test testrace 15 | -------------------------------------------------------------------------------- /vendor/github.com/mitchellh/cli/Makefile: -------------------------------------------------------------------------------- 1 | TEST?=./... 2 | 3 | default: test 4 | 5 | # test runs the test suite and vets the code 6 | test: 7 | go list $(TEST) | xargs -n1 go test -timeout=60s -parallel=10 $(TESTARGS) 8 | 9 | # testrace runs the race checker 10 | testrace: 11 | go list $(TEST) | xargs -n1 go test -race $(TESTARGS) 12 | 13 | # updatedeps installs all the dependencies to run and build 14 | updatedeps: 15 | go list ./... \ 16 | | xargs go list -f '{{ join .Deps "\n" }}{{ printf "\n" }}{{ join .TestImports "\n" }}' \ 17 | | grep -v github.com/mitchellh/cli \ 18 | | xargs go get -f -u -v 19 | 20 | .PHONY: test testrace updatedeps 21 | -------------------------------------------------------------------------------- /vendor/github.com/mitchellh/cli/ui_writer.go: -------------------------------------------------------------------------------- 1 | package cli 2 | 3 | // UiWriter is an io.Writer implementation that can be used with 4 | // loggers that writes every line of log output data to a Ui at the 5 | // Info level. 6 | type UiWriter struct { 7 | Ui Ui 8 | } 9 | 10 | func (w *UiWriter) Write(p []byte) (n int, err error) { 11 | n = len(p) 12 | if n > 0 && p[n-1] == '\n' { 13 | p = p[:n-1] 14 | } 15 | 16 | w.Ui.Info(string(p)) 17 | return n, nil 18 | } 19 | -------------------------------------------------------------------------------- /vendor/github.com/mitchellh/copystructure/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | go: 4 | - 1.7 5 | - tip 6 | 7 | script: 8 | - go test 9 | 10 | matrix: 11 | allow_failures: 12 | - go: tip 13 | -------------------------------------------------------------------------------- /vendor/github.com/mitchellh/copystructure/README.md: -------------------------------------------------------------------------------- 1 | # copystructure 2 | 3 | copystructure is a Go library for deep copying values in Go. 4 | 5 | This allows you to copy Go values that may contain reference values 6 | such as maps, slices, or pointers, and copy their data as well instead 7 | of just their references. 8 | 9 | ## Installation 10 | 11 | Standard `go get`: 12 | 13 | ``` 14 | $ go get github.com/mitchellh/copystructure 15 | ``` 16 | 17 | ## Usage & Example 18 | 19 | For usage and examples see the [Godoc](http://godoc.org/github.com/mitchellh/copystructure). 20 | 21 | The `Copy` function has examples associated with it there. 22 | -------------------------------------------------------------------------------- /vendor/github.com/mitchellh/copystructure/copier_time.go: -------------------------------------------------------------------------------- 1 | package copystructure 2 | 3 | import ( 4 | "reflect" 5 | "time" 6 | ) 7 | 8 | func init() { 9 | Copiers[reflect.TypeOf(time.Time{})] = timeCopier 10 | } 11 | 12 | func timeCopier(v interface{}) (interface{}, error) { 13 | // Just... copy it. 14 | return v.(time.Time), nil 15 | } 16 | -------------------------------------------------------------------------------- /vendor/github.com/mitchellh/go-homedir/README.md: -------------------------------------------------------------------------------- 1 | # go-homedir 2 | 3 | This is a Go library for detecting the user's home directory without 4 | the use of cgo, so the library can be used in cross-compilation environments. 5 | 6 | Usage is incredibly simple, just call `homedir.Dir()` to get the home directory 7 | for a user, and `homedir.Expand()` to expand the `~` in a path to the home 8 | directory. 9 | 10 | **Why not just use `os/user`?** The built-in `os/user` package requires 11 | cgo on Darwin systems. This means that any Go code that uses that package 12 | cannot cross compile. But 99% of the time the use for `os/user` is just to 13 | retrieve the home directory, which we can do for the current user without 14 | cgo. This library does that, enabling cross-compilation. 15 | -------------------------------------------------------------------------------- /vendor/github.com/mitchellh/go-testing-interface/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | go: 4 | - 1.8 5 | - 1.x 6 | - tip 7 | 8 | script: 9 | - go test 10 | 11 | matrix: 12 | allow_failures: 13 | - go: tip 14 | -------------------------------------------------------------------------------- /vendor/github.com/mitchellh/hashstructure/include.go: -------------------------------------------------------------------------------- 1 | package hashstructure 2 | 3 | // Includable is an interface that can optionally be implemented by 4 | // a struct. It will be called for each field in the struct to check whether 5 | // it should be included in the hash. 6 | type Includable interface { 7 | HashInclude(field string, v interface{}) (bool, error) 8 | } 9 | 10 | // IncludableMap is an interface that can optionally be implemented by 11 | // a struct. It will be called when a map-type field is found to ask the 12 | // struct if the map item should be included in the hash. 13 | type IncludableMap interface { 14 | HashIncludeMap(field string, k, v interface{}) (bool, error) 15 | } 16 | -------------------------------------------------------------------------------- /vendor/github.com/mitchellh/mapstructure/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | go: 4 | - 1.9.x 5 | - tip 6 | 7 | script: 8 | - go test 9 | -------------------------------------------------------------------------------- /vendor/github.com/mitchellh/reflectwalk/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | -------------------------------------------------------------------------------- /vendor/github.com/mitchellh/reflectwalk/README.md: -------------------------------------------------------------------------------- 1 | # reflectwalk 2 | 3 | reflectwalk is a Go library for "walking" a value in Go using reflection, 4 | in the same way a directory tree can be "walked" on the filesystem. Walking 5 | a complex structure can allow you to do manipulations on unknown structures 6 | such as those decoded from JSON. 7 | -------------------------------------------------------------------------------- /vendor/github.com/mitchellh/reflectwalk/location.go: -------------------------------------------------------------------------------- 1 | package reflectwalk 2 | 3 | //go:generate stringer -type=Location location.go 4 | 5 | type Location uint 6 | 7 | const ( 8 | None Location = iota 9 | Map 10 | MapKey 11 | MapValue 12 | Slice 13 | SliceElem 14 | Array 15 | ArrayElem 16 | Struct 17 | StructField 18 | WalkLoc 19 | ) 20 | -------------------------------------------------------------------------------- /vendor/github.com/mitchellh/reflectwalk/location_string.go: -------------------------------------------------------------------------------- 1 | // Code generated by "stringer -type=Location location.go"; DO NOT EDIT. 2 | 3 | package reflectwalk 4 | 5 | import "fmt" 6 | 7 | const _Location_name = "NoneMapMapKeyMapValueSliceSliceElemArrayArrayElemStructStructFieldWalkLoc" 8 | 9 | var _Location_index = [...]uint8{0, 4, 7, 13, 21, 26, 35, 40, 49, 55, 66, 73} 10 | 11 | func (i Location) String() string { 12 | if i >= Location(len(_Location_index)-1) { 13 | return fmt.Sprintf("Location(%d)", i) 14 | } 15 | return _Location_name[_Location_index[i]:_Location_index[i+1]] 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/oklog/run/.gitignore: -------------------------------------------------------------------------------- 1 | # Binaries for programs and plugins 2 | *.exe 3 | *.dll 4 | *.so 5 | *.dylib 6 | 7 | # Test binary, build with `go test -c` 8 | *.test 9 | 10 | # Output of the go coverage tool, specifically when used with LiteIDE 11 | *.out 12 | 13 | # Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736 14 | .glide/ 15 | -------------------------------------------------------------------------------- /vendor/github.com/oklog/run/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | sudo: false 3 | go: 4 | - 1.x 5 | - tip 6 | install: 7 | - go get -v github.com/golang/lint/golint 8 | - go build ./... 9 | script: 10 | - go vet ./... 11 | - $HOME/gopath/bin/golint . 12 | - go test -v -race ./... 13 | -------------------------------------------------------------------------------- /vendor/github.com/posener/complete/.gitignore: -------------------------------------------------------------------------------- 1 | .idea 2 | coverage.txt 3 | -------------------------------------------------------------------------------- /vendor/github.com/posener/complete/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | sudo: false 3 | go: 4 | - 1.9 5 | - 1.8 6 | 7 | before_install: 8 | - go get -u -t ./... 9 | - go get -u gopkg.in/alecthomas/gometalinter.v1 10 | - gometalinter.v1 --install 11 | 12 | script: 13 | - gometalinter.v1 --config metalinter.json ./... 14 | - ./test.sh 15 | 16 | after_success: 17 | - bash <(curl -s https://codecov.io/bash) 18 | -------------------------------------------------------------------------------- /vendor/github.com/posener/complete/log.go: -------------------------------------------------------------------------------- 1 | package complete 2 | 3 | import ( 4 | "io" 5 | "io/ioutil" 6 | "log" 7 | "os" 8 | ) 9 | 10 | // Log is used for debugging purposes 11 | // since complete is running on tab completion, it is nice to 12 | // have logs to the stderr (when writing your own completer) 13 | // to write logs, set the COMP_DEBUG environment variable and 14 | // use complete.Log in the complete program 15 | var Log = getLogger() 16 | 17 | func getLogger() func(format string, args ...interface{}) { 18 | var logfile io.Writer = ioutil.Discard 19 | if os.Getenv(envDebug) != "" { 20 | logfile = os.Stderr 21 | } 22 | return log.New(logfile, "complete ", log.Flags()).Printf 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/posener/complete/match/file.go: -------------------------------------------------------------------------------- 1 | package match 2 | 3 | import "strings" 4 | 5 | // File returns true if prefix can match the file 6 | func File(file, prefix string) bool { 7 | // special case for current directory completion 8 | if file == "./" && (prefix == "." || prefix == "") { 9 | return true 10 | } 11 | if prefix == "." && strings.HasPrefix(file, ".") { 12 | return true 13 | } 14 | 15 | file = strings.TrimPrefix(file, "./") 16 | prefix = strings.TrimPrefix(prefix, "./") 17 | 18 | return strings.HasPrefix(file, prefix) 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/posener/complete/match/match.go: -------------------------------------------------------------------------------- 1 | package match 2 | 3 | // Match matches two strings 4 | // it is used for comparing a term to the last typed 5 | // word, the prefix, and see if it is a possible auto complete option. 6 | type Match func(term, prefix string) bool 7 | -------------------------------------------------------------------------------- /vendor/github.com/posener/complete/match/prefix.go: -------------------------------------------------------------------------------- 1 | package match 2 | 3 | import "strings" 4 | 5 | // Prefix is a simple Matcher, if the word is it's prefix, there is a match 6 | // Match returns true if a has the prefix as prefix 7 | func Prefix(long, prefix string) bool { 8 | return strings.HasPrefix(long, prefix) 9 | } 10 | -------------------------------------------------------------------------------- /vendor/github.com/posener/complete/metalinter.json: -------------------------------------------------------------------------------- 1 | { 2 | "Vendor": true, 3 | "DisableAll": true, 4 | "Enable": [ 5 | "gofmt", 6 | "goimports", 7 | "interfacer", 8 | "goconst", 9 | "misspell", 10 | "unconvert", 11 | "gosimple", 12 | "golint", 13 | "structcheck", 14 | "deadcode", 15 | "vet" 16 | ], 17 | "Exclude": [ 18 | "initTests is unused" 19 | ], 20 | "Deadline": "2m" 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/posener/complete/predict_set.go: -------------------------------------------------------------------------------- 1 | package complete 2 | 3 | // PredictSet expects specific set of terms, given in the options argument. 4 | func PredictSet(options ...string) Predictor { 5 | return predictSet(options) 6 | } 7 | 8 | type predictSet []string 9 | 10 | func (p predictSet) Predict(a Args) []string { 11 | return p 12 | } 13 | -------------------------------------------------------------------------------- /vendor/github.com/posener/complete/test.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -e 4 | echo "" > coverage.txt 5 | 6 | for d in $(go list ./... | grep -v vendor); do 7 | go test -v -race -coverprofile=profile.out -covermode=atomic $d 8 | if [ -f profile.out ]; then 9 | cat profile.out >> coverage.txt 10 | rm profile.out 11 | fi 12 | done -------------------------------------------------------------------------------- /vendor/github.com/terraform-providers/terraform-provider-template/template/provider.go: -------------------------------------------------------------------------------- 1 | package template 2 | 3 | import ( 4 | "github.com/hashicorp/terraform/helper/schema" 5 | "github.com/hashicorp/terraform/terraform" 6 | ) 7 | 8 | func Provider() terraform.ResourceProvider { 9 | return &schema.Provider{ 10 | DataSourcesMap: map[string]*schema.Resource{ 11 | "template_file": dataSourceFile(), 12 | "template_cloudinit_config": dataSourceCloudinitConfig(), 13 | }, 14 | ResourcesMap: map[string]*schema.Resource{ 15 | "template_file": schema.DataSourceResourceShim( 16 | "template_file", 17 | dataSourceFile(), 18 | ), 19 | "template_cloudinit_config": schema.DataSourceResourceShim( 20 | "template_cloudinit_config", 21 | dataSourceCloudinitConfig(), 22 | ), 23 | "template_dir": resourceDir(), 24 | }, 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /vendor/github.com/ulikunitz/xz/.gitignore: -------------------------------------------------------------------------------- 1 | # .gitignore 2 | 3 | TODO.html 4 | README.html 5 | 6 | lzma/writer.txt 7 | lzma/reader.txt 8 | 9 | cmd/gxz/gxz 10 | cmd/xb/xb 11 | 12 | # test executables 13 | *.test 14 | 15 | # profile files 16 | *.out 17 | 18 | # vim swap file 19 | .*.swp 20 | 21 | # executables on windows 22 | *.exe 23 | 24 | # default compression test file 25 | enwik8* 26 | -------------------------------------------------------------------------------- /vendor/github.com/ulikunitz/xz/fox.xz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/elislusarczyk/terraform-provider-firebase/a52fe5c25e0d7b301a83989916a73426f7838f12/vendor/github.com/ulikunitz/xz/fox.xz -------------------------------------------------------------------------------- /vendor/github.com/ulikunitz/xz/internal/hash/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014-2017 Ulrich Kunitz. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | /* 6 | Package hash provides rolling hashes. 7 | 8 | Rolling hashes have to be used for maintaining the positions of n-byte 9 | sequences in the dictionary buffer. 10 | 11 | The package provides currently the Rabin-Karp rolling hash and a Cyclic 12 | Polynomial hash. Both support the Hashes method to be used with an interface. 13 | */ 14 | package hash 15 | -------------------------------------------------------------------------------- /vendor/github.com/ulikunitz/xz/lzma/fox.lzma: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/elislusarczyk/terraform-provider-firebase/a52fe5c25e0d7b301a83989916a73426f7838f12/vendor/github.com/ulikunitz/xz/lzma/fox.lzma -------------------------------------------------------------------------------- /vendor/github.com/ulikunitz/xz/make-docs: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | set -x 4 | pandoc -t html5 -f markdown -s --css=doc/md.css -o README.html README.md 5 | pandoc -t html5 -f markdown -s --css=doc/md.css -o TODO.html TODO.md 6 | -------------------------------------------------------------------------------- /vendor/github.com/zclconf/go-cty/cty/function/doc.go: -------------------------------------------------------------------------------- 1 | // Package function builds on the functionality of cty by modeling functions 2 | // that operate on cty Values. 3 | // 4 | // Functions are, at their core, Go anonymous functions. However, this package 5 | // wraps around them utility functions for parameter type checking, etc. 6 | package function 7 | -------------------------------------------------------------------------------- /vendor/github.com/zclconf/go-cty/cty/function/stdlib/doc.go: -------------------------------------------------------------------------------- 1 | // Package stdlib is a collection of cty functions that are expected to be 2 | // generally useful, and are thus factored out into this shared library in 3 | // the hope that cty-using applications will have consistent behavior when 4 | // using these functions. 5 | // 6 | // See the parent package "function" for more information on the purpose 7 | // and usage of cty functions. 8 | // 9 | // This package contains both Go functions, which provide convenient access 10 | // to call the functions from Go code, and the Function objects themselves. 11 | // The latter follow the naming scheme of appending "Func" to the end of 12 | // the function name. 13 | package stdlib 14 | -------------------------------------------------------------------------------- /vendor/github.com/zclconf/go-cty/cty/gocty/doc.go: -------------------------------------------------------------------------------- 1 | // Package gocty deals with converting between cty Values and native go 2 | // values. 3 | // 4 | // It operates under a similar principle to the encoding/json and 5 | // encoding/xml packages in the standard library, using reflection to 6 | // populate native Go data structures from cty values and vice-versa. 7 | package gocty 8 | -------------------------------------------------------------------------------- /vendor/github.com/zclconf/go-cty/cty/json/doc.go: -------------------------------------------------------------------------------- 1 | // Package json provides functions for serializing cty types and values in 2 | // JSON format, and for decoding them again. 3 | // 4 | // Since the cty type system is a superset of the JSON type system, 5 | // round-tripping through JSON is lossy unless type information is provided 6 | // both at encoding time and decoding time. Callers of this package are 7 | // therefore suggested to define their expected structure as a cty.Type 8 | // and pass it in consistently both when encoding and when decoding, though 9 | // default (type-lossy) behavior is provided for situations where the precise 10 | // representation of the data is not significant. 11 | package json 12 | -------------------------------------------------------------------------------- /vendor/github.com/zclconf/go-cty/cty/json/type.go: -------------------------------------------------------------------------------- 1 | package json 2 | 3 | import ( 4 | "github.com/zclconf/go-cty/cty" 5 | ) 6 | 7 | // MarshalType returns a JSON serialization of the given type. 8 | // 9 | // This is just a thin wrapper around t.MarshalJSON, for symmetry with 10 | // UnmarshalType. 11 | func MarshalType(t cty.Type) ([]byte, error) { 12 | return t.MarshalJSON() 13 | } 14 | 15 | // UnmarshalType decodes a JSON serialization of the given type as produced 16 | // by either Type.MarshalJSON or MarshalType. 17 | // 18 | // This is a convenience wrapper around Type.UnmarshalJSON. 19 | func UnmarshalType(buf []byte) (cty.Type, error) { 20 | var t cty.Type 21 | err := t.UnmarshalJSON(buf) 22 | return t, err 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/zclconf/go-cty/cty/null.go: -------------------------------------------------------------------------------- 1 | package cty 2 | 3 | // NullVal returns a null value of the given type. A null can be created of any 4 | // type, but operations on such values will always panic. Calling applications 5 | // are encouraged to use nulls only sparingly, particularly when user-provided 6 | // expressions are to be evaluated, since the precence of nulls creates a 7 | // much higher chance of evaluation errors that can't be caught by a type 8 | // checker. 9 | func NullVal(t Type) Value { 10 | return Value{ 11 | ty: t, 12 | v: nil, 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/zclconf/go-cty/cty/set/iterator.go: -------------------------------------------------------------------------------- 1 | package set 2 | 3 | type Iterator struct { 4 | bucketIds []int 5 | vals map[int][]interface{} 6 | bucketIdx int 7 | valIdx int 8 | } 9 | 10 | func (it *Iterator) Value() interface{} { 11 | return it.currentBucket()[it.valIdx] 12 | } 13 | 14 | func (it *Iterator) Next() bool { 15 | if it.bucketIdx == -1 { 16 | // init 17 | if len(it.bucketIds) == 0 { 18 | return false 19 | } 20 | 21 | it.valIdx = 0 22 | it.bucketIdx = 0 23 | return true 24 | } 25 | 26 | it.valIdx++ 27 | if it.valIdx >= len(it.currentBucket()) { 28 | it.valIdx = 0 29 | it.bucketIdx++ 30 | } 31 | return it.bucketIdx < len(it.bucketIds) 32 | } 33 | 34 | func (it *Iterator) currentBucket() []interface{} { 35 | return it.vals[it.bucketIds[it.bucketIdx]] 36 | } 37 | -------------------------------------------------------------------------------- /vendor/go.opencensus.io/.gitignore: -------------------------------------------------------------------------------- 1 | /.idea/ 2 | 3 | # go.opencensus.io/exporter/aws 4 | /exporter/aws/ 5 | 6 | # Exclude vendor, use dep ensure after checkout: 7 | /vendor/ 8 | -------------------------------------------------------------------------------- /vendor/go.opencensus.io/AUTHORS: -------------------------------------------------------------------------------- 1 | Google Inc. 2 | -------------------------------------------------------------------------------- /vendor/go.opencensus.io/appveyor.yml: -------------------------------------------------------------------------------- 1 | version: "{build}" 2 | 3 | platform: x64 4 | 5 | clone_folder: c:\gopath\src\go.opencensus.io 6 | 7 | environment: 8 | GOPATH: c:\gopath 9 | GOVERSION: 1.8 10 | 11 | install: 12 | - set PATH=%GOPATH%\bin;c:\go\bin;%PATH% 13 | - go version 14 | - go env 15 | 16 | build: false 17 | deploy: false 18 | 19 | test_script: 20 | - cd %APPVEYOR_BUILD_FOLDER% 21 | - gofmt -w . 22 | - go get -v -t .\... 23 | - go test -race -v .\... 24 | - go vet .\... 25 | -------------------------------------------------------------------------------- /vendor/go.opencensus.io/tag/profile_not19.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018, OpenCensus Authors 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | // +build !go1.9 16 | 17 | package tag 18 | 19 | import "context" 20 | 21 | func do(ctx context.Context, f func(ctx context.Context)) { 22 | f(ctx) 23 | } 24 | -------------------------------------------------------------------------------- /vendor/go.opencensus.io/trace/internal/internal.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018, OpenCensus Authors 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | // Package internal provides trace internals. 16 | package internal 17 | 18 | type IDGenerator interface { 19 | NewTraceID() [16]byte 20 | NewSpanID() [8]byte 21 | } 22 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/AUTHORS: -------------------------------------------------------------------------------- 1 | # This source code refers to The Go Authors for copyright purposes. 2 | # The master list of authors is in the main Go distribution, 3 | # visible at https://tip.golang.org/AUTHORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # This source code was written by the Go contributors. 2 | # The master list of contributors is in the main Go distribution, 3 | # visible at https://tip.golang.org/CONTRIBUTORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/const_amd64.h: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // This code was translated into a form compatible with 6a from the public 6 | // domain sources in SUPERCOP: https://bench.cr.yp.to/supercop.html 7 | 8 | #define REDMASK51 0x0007FFFFFFFFFFFF 9 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/const_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // This code was translated into a form compatible with 6a from the public 6 | // domain sources in SUPERCOP: https://bench.cr.yp.to/supercop.html 7 | 8 | // +build amd64,!gccgo,!appengine 9 | 10 | // These constants cannot be encoded in non-MOVQ immediates. 11 | // We access them directly from memory instead. 12 | 13 | DATA ·_121666_213(SB)/8, $996687872 14 | GLOBL ·_121666_213(SB), 8, $8 15 | 16 | DATA ·_2P0(SB)/8, $0xFFFFFFFFFFFDA 17 | GLOBL ·_2P0(SB), 8, $8 18 | 19 | DATA ·_2P1234(SB)/8, $0xFFFFFFFFFFFFE 20 | GLOBL ·_2P1234(SB), 8, $8 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/internal/chacha20/chacha_noasm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !s390x gccgo appengine 6 | 7 | package chacha20 8 | 9 | const ( 10 | bufSize = 64 11 | haveAsm = false 12 | ) 13 | 14 | func (*Cipher) xorKeyStreamAsm(dst, src []byte) { 15 | panic("not implemented") 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/poly1305/sum_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build amd64,!gccgo,!appengine 6 | 7 | package poly1305 8 | 9 | // This function is implemented in sum_amd64.s 10 | //go:noescape 11 | func poly1305(out *[16]byte, m *byte, mlen uint64, key *[32]byte) 12 | 13 | // Sum generates an authenticator for m using a one-time key and puts the 14 | // 16-byte result into out. Authenticating two different messages with the same 15 | // key allows an attacker to forge messages at will. 16 | func Sum(out *[16]byte, m []byte, key *[32]byte) { 17 | var mPtr *byte 18 | if len(m) > 0 { 19 | mPtr = &m[0] 20 | } 21 | poly1305(out, mPtr, uint64(len(m)), key) 22 | } 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/poly1305/sum_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build arm,!gccgo,!appengine,!nacl 6 | 7 | package poly1305 8 | 9 | // This function is implemented in sum_arm.s 10 | //go:noescape 11 | func poly1305_auth_armv6(out *[16]byte, m *byte, mlen uint32, key *[32]byte) 12 | 13 | // Sum generates an authenticator for m using a one-time key and puts the 14 | // 16-byte result into out. Authenticating two different messages with the same 15 | // key allows an attacker to forge messages at will. 16 | func Sum(out *[16]byte, m []byte, key *[32]byte) { 17 | var mPtr *byte 18 | if len(m) > 0 { 19 | mPtr = &m[0] 20 | } 21 | poly1305_auth_armv6(out, mPtr, uint32(len(m)), key) 22 | } 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/poly1305/sum_noasm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build s390x,!go1.11 !arm,!amd64,!s390x gccgo appengine nacl 6 | 7 | package poly1305 8 | 9 | // Sum generates an authenticator for msg using a one-time key and puts the 10 | // 16-byte result into out. Authenticating two different messages with the same 11 | // key allows an attacker to forge messages at will. 12 | func Sum(out *[TagSize]byte, msg []byte, key *[32]byte) { 13 | sumGeneric(out, msg, key) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/AUTHORS: -------------------------------------------------------------------------------- 1 | # This source code refers to The Go Authors for copyright purposes. 2 | # The master list of authors is in the main Go distribution, 3 | # visible at http://tip.golang.org/AUTHORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # This source code was written by the Go contributors. 2 | # The master list of contributors is in the main Go distribution, 3 | # visible at http://tip.golang.org/CONTRIBUTORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/context/go19.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build go1.9 6 | 7 | package context 8 | 9 | import "context" // standard library's context, as of Go 1.7 10 | 11 | // A Context carries a deadline, a cancelation signal, and other values across 12 | // API boundaries. 13 | // 14 | // Context's methods may be called by multiple goroutines simultaneously. 15 | type Context = context.Context 16 | 17 | // A CancelFunc tells an operation to abandon its work. 18 | // A CancelFunc does not wait for the work to stop. 19 | // After the first call, subsequent calls to a CancelFunc do nothing. 20 | type CancelFunc = context.CancelFunc 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/.gitignore: -------------------------------------------------------------------------------- 1 | *~ 2 | h2i/h2i 3 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/Makefile: -------------------------------------------------------------------------------- 1 | curlimage: 2 | docker build -t gohttp2/curl . 3 | 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/README: -------------------------------------------------------------------------------- 1 | This is a work-in-progress HTTP/2 implementation for Go. 2 | 3 | It will eventually live in the Go standard library and won't require 4 | any changes to your code to use. It will just be automatic. 5 | 6 | Status: 7 | 8 | * The server support is pretty good. A few things are missing 9 | but are being worked on. 10 | * The client work has just started but shares a lot of code 11 | is coming along much quicker. 12 | 13 | Docs are at https://godoc.org/golang.org/x/net/http2 14 | 15 | Demo test server at https://http2.golang.org/ 16 | 17 | Help & bug reports welcome! 18 | 19 | Contributing: https://golang.org/doc/contribute.html 20 | Bugs: https://golang.org/issue/new?title=x/net/http2:+ 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/go111.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build go1.11 6 | 7 | package http2 8 | 9 | import "net/textproto" 10 | 11 | func traceHasWroteHeaderField(trace *clientTrace) bool { 12 | return trace != nil && trace.WroteHeaderField != nil 13 | } 14 | 15 | func traceWroteHeaderField(trace *clientTrace, k, v string) { 16 | if trace != nil && trace.WroteHeaderField != nil { 17 | trace.WroteHeaderField(k, []string{v}) 18 | } 19 | } 20 | 21 | func traceGot1xxResponseFunc(trace *clientTrace) func(int, textproto.MIMEHeader) error { 22 | if trace != nil { 23 | return trace.Got1xxResponse 24 | } 25 | return nil 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/go16.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build go1.6 6 | 7 | package http2 8 | 9 | import ( 10 | "net/http" 11 | "time" 12 | ) 13 | 14 | func transportExpectContinueTimeout(t1 *http.Transport) time.Duration { 15 | return t1.ExpectContinueTimeout 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/go19.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build go1.9 6 | 7 | package http2 8 | 9 | import ( 10 | "net/http" 11 | ) 12 | 13 | func configureServer19(s *http.Server, conf *Server) error { 14 | s.RegisterOnShutdown(conf.state.startGracefulShutdown) 15 | return nil 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/not_go111.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !go1.11 6 | 7 | package http2 8 | 9 | import "net/textproto" 10 | 11 | func traceHasWroteHeaderField(trace *clientTrace) bool { return false } 12 | 13 | func traceWroteHeaderField(trace *clientTrace, k, v string) {} 14 | 15 | func traceGot1xxResponseFunc(trace *clientTrace) func(int, textproto.MIMEHeader) error { 16 | return nil 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/not_go16.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !go1.6 6 | 7 | package http2 8 | 9 | import ( 10 | "net/http" 11 | "time" 12 | ) 13 | 14 | func configureTransport(t1 *http.Transport) (*Transport, error) { 15 | return nil, errTransportVersion 16 | } 17 | 18 | func transportExpectContinueTimeout(t1 *http.Transport) time.Duration { 19 | return 0 20 | 21 | } 22 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/not_go18.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !go1.8 6 | 7 | package http2 8 | 9 | import ( 10 | "io" 11 | "net/http" 12 | ) 13 | 14 | func configureServer18(h1 *http.Server, h2 *Server) error { 15 | // No IdleTimeout to sync prior to Go 1.8. 16 | return nil 17 | } 18 | 19 | func shouldLogPanic(panicValue interface{}) bool { 20 | return panicValue != nil 21 | } 22 | 23 | func reqGetBody(req *http.Request) func() (io.ReadCloser, error) { 24 | return nil 25 | } 26 | 27 | func reqBodyIsNoBody(io.ReadCloser) bool { return false } 28 | 29 | func go18httpNoBody() io.ReadCloser { return nil } // for tests only 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/not_go19.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !go1.9 6 | 7 | package http2 8 | 9 | import ( 10 | "net/http" 11 | ) 12 | 13 | func configureServer19(s *http.Server, conf *Server) error { 14 | // not supported prior to go1.9 15 | return nil 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/trace/trace_go16.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !go1.7 6 | 7 | package trace 8 | 9 | import "golang.org/x/net/context" 10 | 11 | // NewContext returns a copy of the parent context 12 | // and associates it with a Trace. 13 | func NewContext(ctx context.Context, tr Trace) context.Context { 14 | return context.WithValue(ctx, contextKey, tr) 15 | } 16 | 17 | // FromContext returns the Trace bound to the context, if any. 18 | func FromContext(ctx context.Context) (tr Trace, ok bool) { 19 | tr, ok = ctx.Value(contextKey).(Trace) 20 | return 21 | } 22 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/trace/trace_go17.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build go1.7 6 | 7 | package trace 8 | 9 | import "context" 10 | 11 | // NewContext returns a copy of the parent context 12 | // and associates it with a Trace. 13 | func NewContext(ctx context.Context, tr Trace) context.Context { 14 | return context.WithValue(ctx, contextKey, tr) 15 | } 16 | 17 | // FromContext returns the Trace bound to the context, if any. 18 | func FromContext(ctx context.Context) (tr Trace, ok bool) { 19 | tr, ok = ctx.Value(contextKey).(Trace) 20 | return 21 | } 22 | -------------------------------------------------------------------------------- /vendor/golang.org/x/oauth2/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | go: 4 | - tip 5 | 6 | install: 7 | - export GOPATH="$HOME/gopath" 8 | - mkdir -p "$GOPATH/src/golang.org/x" 9 | - mv "$TRAVIS_BUILD_DIR" "$GOPATH/src/golang.org/x/oauth2" 10 | - go get -v -t -d golang.org/x/oauth2/... 11 | 12 | script: 13 | - go test -v golang.org/x/oauth2/... 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/oauth2/AUTHORS: -------------------------------------------------------------------------------- 1 | # This source code refers to The Go Authors for copyright purposes. 2 | # The master list of authors is in the main Go distribution, 3 | # visible at http://tip.golang.org/AUTHORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/oauth2/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # This source code was written by the Go contributors. 2 | # The master list of contributors is in the main Go distribution, 3 | # visible at http://tip.golang.org/CONTRIBUTORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/oauth2/google/appengine_hook.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build appengine appenginevm 6 | 7 | package google 8 | 9 | import "google.golang.org/appengine" 10 | 11 | func init() { 12 | appengineTokenFunc = appengine.AccessToken 13 | appengineAppIDFunc = appengine.AppID 14 | } 15 | -------------------------------------------------------------------------------- /vendor/golang.org/x/oauth2/google/appengineflex_hook.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build appenginevm 6 | 7 | package google 8 | 9 | func init() { 10 | appengineFlex = true // Flex doesn't support appengine.AccessToken; depend on metadata server. 11 | } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/oauth2/internal/client_appengine.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build appengine 6 | 7 | package internal 8 | 9 | import "google.golang.org/appengine/urlfetch" 10 | 11 | func init() { 12 | appengineClientHook = urlfetch.Client 13 | } 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/oauth2/internal/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package internal contains support packages for oauth2 package. 6 | package internal 7 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/AUTHORS: -------------------------------------------------------------------------------- 1 | # This source code refers to The Go Authors for copyright purposes. 2 | # The master list of authors is in the main Go distribution, 3 | # visible at http://tip.golang.org/AUTHORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # This source code was written by the Go contributors. 2 | # The master list of contributors is in the main Go distribution, 3 | # visible at http://tip.golang.org/CONTRIBUTORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/.gitignore: -------------------------------------------------------------------------------- 1 | _obj/ 2 | unix.test 3 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_darwin_386.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for 386, Darwin 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-28 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_darwin_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for AMD64, Darwin 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_darwin_arm.s: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | // +build arm,darwin 7 | 8 | #include "textflag.h" 9 | 10 | // 11 | // System call support for ARM, Darwin 12 | // 13 | 14 | // Just jump to package syscall's implementation for all these functions. 15 | // The runtime may know about them. 16 | 17 | TEXT ·Syscall(SB),NOSPLIT,$0-28 18 | B syscall·Syscall(SB) 19 | 20 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 21 | B syscall·Syscall6(SB) 22 | 23 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 24 | B syscall·Syscall9(SB) 25 | 26 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 27 | B syscall·RawSyscall(SB) 28 | 29 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 30 | B syscall·RawSyscall6(SB) 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_darwin_arm64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | // +build arm64,darwin 7 | 8 | #include "textflag.h" 9 | 10 | // 11 | // System call support for AMD64, Darwin 12 | // 13 | 14 | // Just jump to package syscall's implementation for all these functions. 15 | // The runtime may know about them. 16 | 17 | TEXT ·Syscall(SB),NOSPLIT,$0-56 18 | B syscall·Syscall(SB) 19 | 20 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 21 | B syscall·Syscall6(SB) 22 | 23 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 24 | B syscall·Syscall9(SB) 25 | 26 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 27 | B syscall·RawSyscall(SB) 28 | 29 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 30 | B syscall·RawSyscall6(SB) 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_dragonfly_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for AMD64, DragonFly 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_freebsd_386.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for 386, FreeBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-28 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_freebsd_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for AMD64, FreeBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_freebsd_arm.s: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for ARM, FreeBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-28 17 | B syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | B syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | B syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | B syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | B syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_netbsd_386.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for 386, NetBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-28 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_netbsd_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for AMD64, NetBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_netbsd_arm.s: -------------------------------------------------------------------------------- 1 | // Copyright 2013 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for ARM, NetBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-28 17 | B syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | B syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | B syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | B syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | B syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_openbsd_386.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for 386, OpenBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-28 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_openbsd_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for AMD64, OpenBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_openbsd_arm.s: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for ARM, OpenBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-28 17 | B syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | B syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | B syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | B syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | B syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_solaris_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for amd64, Solaris are implemented in runtime/syscall_solaris.go 11 | // 12 | 13 | TEXT ·sysvicall6(SB),NOSPLIT,$0-88 14 | JMP syscall·sysvicall6(SB) 15 | 16 | TEXT ·rawSysvicall6(SB),NOSPLIT,$0-88 17 | JMP syscall·rawSysvicall6(SB) 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/bluetooth_linux.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Bluetooth sockets and messages 6 | 7 | package unix 8 | 9 | // Bluetooth Protocols 10 | const ( 11 | BTPROTO_L2CAP = 0 12 | BTPROTO_HCI = 1 13 | BTPROTO_SCO = 2 14 | BTPROTO_RFCOMM = 3 15 | BTPROTO_BNEP = 4 16 | BTPROTO_CMTP = 5 17 | BTPROTO_HIDP = 6 18 | BTPROTO_AVDTP = 7 19 | ) 20 | 21 | const ( 22 | HCI_CHANNEL_RAW = 0 23 | HCI_CHANNEL_USER = 1 24 | HCI_CHANNEL_MONITOR = 2 25 | HCI_CHANNEL_CONTROL = 3 26 | ) 27 | 28 | // Socketoption Level 29 | const ( 30 | SOL_BLUETOOTH = 0x112 31 | SOL_HCI = 0x0 32 | SOL_L2CAP = 0x6 33 | SOL_RFCOMM = 0x12 34 | SOL_SCO = 0x11 35 | ) 36 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/constants.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build darwin dragonfly freebsd linux netbsd openbsd solaris 6 | 7 | package unix 8 | 9 | const ( 10 | R_OK = 0x4 11 | W_OK = 0x2 12 | X_OK = 0x1 13 | ) 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/dirent.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | // ParseDirent parses up to max directory entries in buf, 12 | // appending the names to names. It returns the number of 13 | // bytes consumed from buf, the number of entries added 14 | // to names, and the new names slice. 15 | func ParseDirent(buf []byte, max int, names []string) (consumed int, count int, newnames []string) { 16 | return syscall.ParseDirent(buf, max, names) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/endian_big.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | // 5 | // +build ppc64 s390x mips mips64 6 | 7 | package unix 8 | 9 | const isBigEndian = true 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/endian_little.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | // 5 | // +build 386 amd64 amd64p32 arm arm64 ppc64le mipsle mips64le 6 | 7 | package unix 8 | 9 | const isBigEndian = false 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/env_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2010 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build darwin dragonfly freebsd linux netbsd openbsd solaris 6 | 7 | // Unix environment variables. 8 | 9 | package unix 10 | 11 | import "syscall" 12 | 13 | func Getenv(key string) (value string, found bool) { 14 | return syscall.Getenv(key) 15 | } 16 | 17 | func Setenv(key, value string) error { 18 | return syscall.Setenv(key, value) 19 | } 20 | 21 | func Clearenv() { 22 | syscall.Clearenv() 23 | } 24 | 25 | func Environ() []string { 26 | return syscall.Environ() 27 | } 28 | 29 | func Unsetenv(key string) error { 30 | return syscall.Unsetenv(key) 31 | } 32 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/fcntl_linux_32bit.go: -------------------------------------------------------------------------------- 1 | // +build linux,386 linux,arm linux,mips linux,mipsle 2 | 3 | // Copyright 2014 The Go Authors. All rights reserved. 4 | // Use of this source code is governed by a BSD-style 5 | // license that can be found in the LICENSE file. 6 | 7 | package unix 8 | 9 | func init() { 10 | // On 32-bit Linux systems, the fcntl syscall that matches Go's 11 | // Flock_t type is SYS_FCNTL64, not SYS_FCNTL. 12 | fcntl64Syscall = SYS_FCNTL64 13 | } 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/gccgo_linux_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build gccgo,linux,amd64 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | //extern gettimeofday 12 | func realGettimeofday(*Timeval, *byte) int32 13 | 14 | func gettimeofday(tv *Timeval) (err syscall.Errno) { 15 | r := realGettimeofday(tv, nil) 16 | if r < 0 { 17 | return syscall.GetErrno() 18 | } 19 | return 0 20 | } 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/pagesize_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build darwin dragonfly freebsd linux netbsd openbsd solaris 6 | 7 | // For Unix, get the pagesize from the runtime. 8 | 9 | package unix 10 | 11 | import "syscall" 12 | 13 | func Getpagesize() int { 14 | return syscall.Getpagesize() 15 | } 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/race.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build darwin,race linux,race freebsd,race 6 | 7 | package unix 8 | 9 | import ( 10 | "runtime" 11 | "unsafe" 12 | ) 13 | 14 | const raceenabled = true 15 | 16 | func raceAcquire(addr unsafe.Pointer) { 17 | runtime.RaceAcquire(addr) 18 | } 19 | 20 | func raceReleaseMerge(addr unsafe.Pointer) { 21 | runtime.RaceReleaseMerge(addr) 22 | } 23 | 24 | func raceReadRange(addr unsafe.Pointer, len int) { 25 | runtime.RaceReadRange(addr, len) 26 | } 27 | 28 | func raceWriteRange(addr unsafe.Pointer, len int) { 29 | runtime.RaceWriteRange(addr, len) 30 | } 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/race0.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build darwin,!race linux,!race freebsd,!race netbsd openbsd solaris dragonfly 6 | 7 | package unix 8 | 9 | import ( 10 | "unsafe" 11 | ) 12 | 13 | const raceenabled = false 14 | 15 | func raceAcquire(addr unsafe.Pointer) { 16 | } 17 | 18 | func raceReleaseMerge(addr unsafe.Pointer) { 19 | } 20 | 21 | func raceReadRange(addr unsafe.Pointer, len int) { 22 | } 23 | 24 | func raceWriteRange(addr unsafe.Pointer, len int) { 25 | } 26 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/str.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build darwin dragonfly freebsd linux netbsd openbsd solaris 6 | 7 | package unix 8 | 9 | func itoa(val int) string { // do it here rather than with fmt to avoid dependency 10 | if val < 0 { 11 | return "-" + uitoa(uint(-val)) 12 | } 13 | return uitoa(uint(val)) 14 | } 15 | 16 | func uitoa(val uint) string { 17 | var buf [32]byte // big enough for int64 18 | i := len(buf) - 1 19 | for val >= 10 { 20 | buf[i] = byte(val%10 + '0') 21 | i-- 22 | val /= 10 23 | } 24 | buf[i] = byte(val + '0') 25 | return string(buf[i:]) 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_amd64_gc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build amd64,linux 6 | // +build !gccgo 7 | 8 | package unix 9 | 10 | import "syscall" 11 | 12 | //go:noescape 13 | func gettimeofday(tv *Timeval) (err syscall.Errno) 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_gc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build linux,!gccgo 6 | 7 | package unix 8 | 9 | // SyscallNoError may be used instead of Syscall for syscalls that don't fail. 10 | func SyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) 11 | 12 | // RawSyscallNoError may be used instead of RawSyscall for syscalls that don't 13 | // fail. 14 | func RawSyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) 15 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_gc_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build linux,!gccgo,386 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | // Underlying system call writes to newoffset via pointer. 12 | // Implemented in assembly to avoid allocation. 13 | func seek(fd int, offset int64, whence int) (newoffset int64, err syscall.Errno) 14 | 15 | func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno) 16 | func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno) 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_gccgo_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build linux,gccgo,arm 6 | 7 | package unix 8 | 9 | import ( 10 | "syscall" 11 | "unsafe" 12 | ) 13 | 14 | func seek(fd int, offset int64, whence int) (int64, syscall.Errno) { 15 | var newoffset int64 16 | offsetLow := uint32(offset & 0xffffffff) 17 | offsetHigh := uint32((offset >> 32) & 0xffffffff) 18 | _, _, err := Syscall6(SYS__LLSEEK, uintptr(fd), uintptr(offsetHigh), uintptr(offsetLow), uintptr(unsafe.Pointer(&newoffset)), uintptr(whence), 0) 19 | return newoffset, err 20 | } 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_solaris_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build amd64,solaris 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: nsec} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: usec} 15 | } 16 | 17 | func (iov *Iovec) SetLen(length int) { 18 | iov.Len = uint64(length) 19 | } 20 | 21 | func (cmsg *Cmsghdr) SetLen(length int) { 22 | cmsg.Len = uint32(length) 23 | } 24 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_unix_gc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build darwin dragonfly freebsd linux netbsd openbsd solaris 6 | // +build !gccgo 7 | 8 | package unix 9 | 10 | import "syscall" 11 | 12 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) 13 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) 14 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) 15 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/AUTHORS: -------------------------------------------------------------------------------- 1 | # This source code refers to The Go Authors for copyright purposes. 2 | # The master list of authors is in the main Go distribution, 3 | # visible at http://tip.golang.org/AUTHORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # This source code was written by the Go contributors. 2 | # The master list of contributors is in the main Go distribution, 3 | # visible at http://tip.golang.org/CONTRIBUTORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/language/Makefile: -------------------------------------------------------------------------------- 1 | # Copyright 2013 The Go Authors. All rights reserved. 2 | # Use of this source code is governed by a BSD-style 3 | # license that can be found in the LICENSE file. 4 | 5 | CLEANFILES+=maketables 6 | 7 | maketables: maketables.go 8 | go build $^ 9 | 10 | tables: maketables 11 | ./maketables > tables.go 12 | gofmt -w -s tables.go 13 | 14 | # Build (but do not run) maketables during testing, 15 | # just to make sure it still compiles. 16 | testshort: maketables 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/language/common.go: -------------------------------------------------------------------------------- 1 | // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT. 2 | 3 | package language 4 | 5 | // This file contains code common to the maketables.go and the package code. 6 | 7 | // langAliasType is the type of an alias in langAliasMap. 8 | type langAliasType int8 9 | 10 | const ( 11 | langDeprecated langAliasType = iota 12 | langMacro 13 | langLegacy 14 | 15 | langAliasTypeUnknown langAliasType = -1 16 | ) 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/language/gen_common.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build ignore 6 | 7 | package main 8 | 9 | // This file contains code common to the maketables.go and the package code. 10 | 11 | // langAliasType is the type of an alias in langAliasMap. 12 | type langAliasType int8 13 | 14 | const ( 15 | langDeprecated langAliasType = iota 16 | langMacro 17 | langLegacy 18 | 19 | langAliasTypeUnknown langAliasType = -1 20 | ) 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/language/go1_2.go: -------------------------------------------------------------------------------- 1 | // Copyright 2013 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build go1.2 6 | 7 | package language 8 | 9 | import "sort" 10 | 11 | var sortStable = sort.Stable 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/secure/bidirule/bidirule10.0.0.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build go1.10 6 | 7 | package bidirule 8 | 9 | func (t *Transformer) isFinal() bool { 10 | return t.state == ruleLTRFinal || t.state == ruleRTLFinal || t.state == ruleInitial 11 | } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/secure/bidirule/bidirule9.0.0.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !go1.10 6 | 7 | package bidirule 8 | 9 | func (t *Transformer) isFinal() bool { 10 | if !t.isRTL() { 11 | return true 12 | } 13 | return t.state == ruleLTRFinal || t.state == ruleRTLFinal || t.state == ruleInitial 14 | } 15 | -------------------------------------------------------------------------------- /vendor/google.golang.org/api/AUTHORS: -------------------------------------------------------------------------------- 1 | # This is the official list of authors for copyright purposes. 2 | # This file is distinct from the CONTRIBUTORS files. 3 | # See the latter for an explanation. 4 | 5 | # Names should be added to this file as 6 | # Name or Organization 7 | # The email address is not required for organizations. 8 | 9 | # Please keep the list sorted. 10 | Google Inc. 11 | -------------------------------------------------------------------------------- /vendor/google.golang.org/api/gensupport/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package gensupport is an internal implementation detail used by code 6 | // generated by the google-api-go-generator tool. 7 | // 8 | // This package may be modified at any time without regard for backwards 9 | // compatibility. It should not be used directly by API users. 10 | package gensupport 11 | -------------------------------------------------------------------------------- /vendor/google.golang.org/api/gensupport/go18.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build go1.8 6 | 7 | package gensupport 8 | 9 | import ( 10 | "io" 11 | "net/http" 12 | ) 13 | 14 | // SetGetBody sets the GetBody field of req to f. 15 | func SetGetBody(req *http.Request, f func() (io.ReadCloser, error)) { 16 | req.GetBody = f 17 | } 18 | -------------------------------------------------------------------------------- /vendor/google.golang.org/api/gensupport/header.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package gensupport 6 | 7 | import ( 8 | "fmt" 9 | "runtime" 10 | "strings" 11 | ) 12 | 13 | // GoogleClientHeader returns the value to use for the x-goog-api-client 14 | // header, which is used internally by Google. 15 | func GoogleClientHeader(generatorVersion, clientElement string) string { 16 | elts := []string{"gl-go/" + strings.Replace(runtime.Version(), " ", "_", -1)} 17 | if clientElement != "" { 18 | elts = append(elts, clientElement) 19 | } 20 | elts = append(elts, fmt.Sprintf("gdcl/%s", generatorVersion)) 21 | return strings.Join(elts, " ") 22 | } 23 | -------------------------------------------------------------------------------- /vendor/google.golang.org/api/gensupport/not_go18.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !go1.8 6 | 7 | package gensupport 8 | 9 | import ( 10 | "io" 11 | "net/http" 12 | ) 13 | 14 | func SetGetBody(req *http.Request, f func() (io.ReadCloser, error)) {} 15 | -------------------------------------------------------------------------------- /vendor/google.golang.org/api/googleapi/internal/uritemplates/utils.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package uritemplates 6 | 7 | // Expand parses then expands a URI template with a set of values to produce 8 | // the resultant URI. Two forms of the result are returned: one with all the 9 | // elements escaped, and one with the elements unescaped. 10 | func Expand(path string, values map[string]string) (escaped, unescaped string, err error) { 11 | template, err := parse(path) 12 | if err != nil { 13 | return "", "", err 14 | } 15 | escaped, unescaped = template.Expand(values) 16 | return escaped, unescaped, nil 17 | } 18 | -------------------------------------------------------------------------------- /vendor/google.golang.org/api/internal/service-account.json: -------------------------------------------------------------------------------- 1 | { 2 | "type": "service_account", 3 | "project_id": "project_id", 4 | "private_key_id": "private_key_id", 5 | "private_key": "private_key", 6 | "client_email": "xyz@developer.gserviceaccount.com", 7 | "client_id": "123", 8 | "auth_uri": "https://accounts.google.com/o/oauth2/auth", 9 | "token_uri": "https://accounts.google.com/o/oauth2/token", 10 | "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs", 11 | "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/xyz%40developer.gserviceaccount.com" 12 | } 13 | -------------------------------------------------------------------------------- /vendor/google.golang.org/api/transport/http/not_go18.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 Google Inc. All Rights Reserved. 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | // +build !go1.8 16 | 17 | package http 18 | 19 | import "net/http" 20 | 21 | func addOCTransport(trans http.RoundTripper) http.RoundTripper { return trans } 22 | -------------------------------------------------------------------------------- /vendor/google.golang.org/appengine/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | go: 4 | - 1.6.x 5 | - 1.7.x 6 | - 1.8.x 7 | - 1.9.x 8 | 9 | go_import_path: google.golang.org/appengine 10 | 11 | install: 12 | - go get -u -v $(go list -f '{{join .Imports "\n"}}{{"\n"}}{{join .TestImports "\n"}}' ./... | sort | uniq | grep -v appengine) 13 | - mkdir /tmp/sdk 14 | - curl -o /tmp/sdk.zip "https://storage.googleapis.com/appengine-sdks/featured/go_appengine_sdk_linux_amd64-1.9.40.zip" 15 | - unzip -q /tmp/sdk.zip -d /tmp/sdk 16 | - export PATH="$PATH:/tmp/sdk/go_appengine" 17 | - export APPENGINE_DEV_APPSERVER=/tmp/sdk/go_appengine/dev_appserver.py 18 | 19 | script: 20 | - goapp version 21 | - go version 22 | - go test -v google.golang.org/appengine/... 23 | - go test -v -race google.golang.org/appengine/... 24 | - goapp test -v google.golang.org/appengine/... 25 | -------------------------------------------------------------------------------- /vendor/google.golang.org/appengine/appengine_vm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 Google Inc. All rights reserved. 2 | // Use of this source code is governed by the Apache 2.0 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !appengine 6 | 7 | package appengine 8 | 9 | import ( 10 | "golang.org/x/net/context" 11 | 12 | "google.golang.org/appengine/internal" 13 | ) 14 | 15 | // BackgroundContext returns a context not associated with a request. 16 | // This should only be used when not servicing a request. 17 | // This only works in App Engine "flexible environment". 18 | func BackgroundContext() context.Context { 19 | return internal.BackgroundContext() 20 | } 21 | -------------------------------------------------------------------------------- /vendor/google.golang.org/appengine/internal/app_id.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 Google Inc. All rights reserved. 2 | // Use of this source code is governed by the Apache 2.0 3 | // license that can be found in the LICENSE file. 4 | 5 | package internal 6 | 7 | import ( 8 | "strings" 9 | ) 10 | 11 | func parseFullAppID(appid string) (partition, domain, displayID string) { 12 | if i := strings.Index(appid, "~"); i != -1 { 13 | partition, appid = appid[:i], appid[i+1:] 14 | } 15 | if i := strings.Index(appid, ":"); i != -1 { 16 | domain, appid = appid[:i], appid[i+1:] 17 | } 18 | return partition, domain, appid 19 | } 20 | 21 | // appID returns "appid" or "domain.com:appid". 22 | func appID(fullAppID string) string { 23 | _, dom, dis := parseFullAppID(fullAppID) 24 | if dom != "" { 25 | return dom + ":" + dis 26 | } 27 | return dis 28 | } 29 | -------------------------------------------------------------------------------- /vendor/google.golang.org/appengine/internal/base/api_base.proto: -------------------------------------------------------------------------------- 1 | // Built-in base types for API calls. Primarily useful as return types. 2 | 3 | syntax = "proto2"; 4 | option go_package = "base"; 5 | 6 | package appengine.base; 7 | 8 | message StringProto { 9 | required string value = 1; 10 | } 11 | 12 | message Integer32Proto { 13 | required int32 value = 1; 14 | } 15 | 16 | message Integer64Proto { 17 | required int64 value = 1; 18 | } 19 | 20 | message BoolProto { 21 | required bool value = 1; 22 | } 23 | 24 | message DoubleProto { 25 | required double value = 1; 26 | } 27 | 28 | message BytesProto { 29 | required bytes value = 1 [ctype=CORD]; 30 | } 31 | 32 | message VoidProto { 33 | } 34 | -------------------------------------------------------------------------------- /vendor/google.golang.org/appengine/internal/identity.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 Google Inc. All rights reserved. 2 | // Use of this source code is governed by the Apache 2.0 3 | // license that can be found in the LICENSE file. 4 | 5 | package internal 6 | 7 | import netcontext "golang.org/x/net/context" 8 | 9 | // These functions are implementations of the wrapper functions 10 | // in ../appengine/identity.go. See that file for commentary. 11 | 12 | func AppID(c netcontext.Context) string { 13 | return appID(FullyQualifiedAppID(c)) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/google.golang.org/appengine/internal/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 Google Inc. All rights reserved. 2 | // Use of this source code is governed by the Apache 2.0 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build appengine 6 | 7 | package internal 8 | 9 | import ( 10 | "appengine_internal" 11 | ) 12 | 13 | func Main() { 14 | appengine_internal.Main() 15 | } 16 | -------------------------------------------------------------------------------- /vendor/google.golang.org/appengine/socket/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 Google Inc. All rights reserved. 2 | // Use of this source code is governed by the Apache 2.0 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package socket provides outbound network sockets. 6 | // 7 | // This package is only required in the classic App Engine environment. 8 | // Applications running only in App Engine "flexible environment" should 9 | // use the standard library's net package. 10 | package socket 11 | -------------------------------------------------------------------------------- /vendor/google.golang.org/appengine/timeout.go: -------------------------------------------------------------------------------- 1 | // Copyright 2013 Google Inc. All rights reserved. 2 | // Use of this source code is governed by the Apache 2.0 3 | // license that can be found in the LICENSE file. 4 | 5 | package appengine 6 | 7 | import "golang.org/x/net/context" 8 | 9 | // IsTimeoutError reports whether err is a timeout error. 10 | func IsTimeoutError(err error) bool { 11 | if err == context.DeadlineExceeded { 12 | return true 13 | } 14 | if t, ok := err.(interface { 15 | IsTimeout() bool 16 | }); ok { 17 | return t.IsTimeout() 18 | } 19 | return false 20 | } 21 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | go: 4 | - 1.6.x 5 | - 1.7.x 6 | - 1.8.x 7 | - 1.9.x 8 | - 1.10.x 9 | 10 | matrix: 11 | include: 12 | - go: 1.10.x 13 | env: RUN386=1 14 | 15 | go_import_path: google.golang.org/grpc 16 | 17 | before_install: 18 | - if [[ -n "$RUN386" ]]; then export GOARCH=386; fi 19 | - if [[ "$TRAVIS_GO_VERSION" = 1.10* && "$GOARCH" != "386" ]]; then ./vet.sh -install || exit 1; fi 20 | 21 | script: 22 | - if [[ "$TRAVIS_GO_VERSION" = 1.10* && "$GOARCH" != "386" ]]; then ./vet.sh || exit 1; fi 23 | - make test || exit 1 24 | - if [[ "$GOARCH" != "386" ]]; then make testrace; fi 25 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/AUTHORS: -------------------------------------------------------------------------------- 1 | Google Inc. 2 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/codegen.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | # This script serves as an example to demonstrate how to generate the gRPC-Go 4 | # interface and the related messages from .proto file. 5 | # 6 | # It assumes the installation of i) Google proto buffer compiler at 7 | # https://github.com/google/protobuf (after v2.6.1) and ii) the Go codegen 8 | # plugin at https://github.com/golang/protobuf (after 2015-02-20). If you have 9 | # not, please install them first. 10 | # 11 | # We recommend running this script at $GOPATH/src. 12 | # 13 | # If this is not what you need, feel free to make your own scripts. Again, this 14 | # script is for demonstration purpose. 15 | # 16 | proto=$1 17 | protoc --go_out=plugins=grpc:. $proto 18 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/version.go: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright 2018 gRPC authors. 4 | * 5 | * Licensed under the Apache License, Version 2.0 (the "License"); 6 | * you may not use this file except in compliance with the License. 7 | * You may obtain a copy of the License at 8 | * 9 | * http://www.apache.org/licenses/LICENSE-2.0 10 | * 11 | * Unless required by applicable law or agreed to in writing, software 12 | * distributed under the License is distributed on an "AS IS" BASIS, 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 | * See the License for the specific language governing permissions and 15 | * limitations under the License. 16 | * 17 | */ 18 | 19 | package grpc 20 | 21 | // Version is the current grpc version. 22 | const Version = "1.13.0" 23 | --------------------------------------------------------------------------------