├── .gitconfig ├── .github └── workflows │ └── ci.yml ├── .gitignore ├── .goreleaser.yml ├── LICENSE ├── Makefile ├── README.md ├── bin └── .gitignore ├── go.mod ├── go.sum ├── main.go ├── statuspage ├── main.go ├── provider.go ├── provider_test.go ├── resource_component.go ├── resource_component_group.go ├── resource_component_group_test.go ├── resource_component_test.go ├── resource_metric.go ├── resource_metric_provider.go ├── resource_metric_test.go └── utils.go ├── terraform-registry-manifest.json ├── vendor ├── github.com │ ├── agext │ │ └── levenshtein │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── DCO │ │ │ ├── LICENSE │ │ │ ├── MAINTAINERS │ │ │ ├── NOTICE │ │ │ ├── README.md │ │ │ ├── levenshtein.go │ │ │ ├── params.go │ │ │ └── test.sh │ ├── apparentlymart │ │ ├── go-cidr │ │ │ ├── LICENSE │ │ │ └── cidr │ │ │ │ ├── cidr.go │ │ │ │ └── wrangling.go │ │ └── go-textseg │ │ │ └── v13 │ │ │ ├── LICENSE │ │ │ └── textseg │ │ │ ├── all_tokens.go │ │ │ ├── emoji_table.rl │ │ │ ├── generate.go │ │ │ ├── grapheme_clusters.go │ │ │ ├── grapheme_clusters.rl │ │ │ ├── grapheme_clusters_table.rl │ │ │ ├── tables.go │ │ │ ├── unicode2ragel.rb │ │ │ └── utf8_seqs.go │ ├── davecgh │ │ └── go-spew │ │ │ ├── LICENSE │ │ │ └── spew │ │ │ ├── bypass.go │ │ │ ├── bypasssafe.go │ │ │ ├── common.go │ │ │ ├── config.go │ │ │ ├── doc.go │ │ │ ├── dump.go │ │ │ ├── format.go │ │ │ └── spew.go │ ├── fatih │ │ └── color │ │ │ ├── LICENSE.md │ │ │ ├── README.md │ │ │ ├── color.go │ │ │ ├── color_windows.go │ │ │ └── doc.go │ ├── golang │ │ └── protobuf │ │ │ ├── AUTHORS │ │ │ ├── CONTRIBUTORS │ │ │ ├── LICENSE │ │ │ ├── jsonpb │ │ │ ├── decode.go │ │ │ ├── encode.go │ │ │ └── json.go │ │ │ ├── proto │ │ │ ├── buffer.go │ │ │ ├── defaults.go │ │ │ ├── deprecated.go │ │ │ ├── discard.go │ │ │ ├── extensions.go │ │ │ ├── properties.go │ │ │ ├── proto.go │ │ │ ├── registry.go │ │ │ ├── text_decode.go │ │ │ ├── text_encode.go │ │ │ ├── wire.go │ │ │ └── wrappers.go │ │ │ └── ptypes │ │ │ ├── any.go │ │ │ ├── any │ │ │ └── any.pb.go │ │ │ ├── doc.go │ │ │ ├── duration.go │ │ │ ├── duration │ │ │ └── duration.pb.go │ │ │ ├── empty │ │ │ └── empty.pb.go │ │ │ ├── timestamp.go │ │ │ └── timestamp │ │ │ └── timestamp.pb.go │ ├── google │ │ └── go-cmp │ │ │ ├── LICENSE │ │ │ └── cmp │ │ │ ├── compare.go │ │ │ ├── export_panic.go │ │ │ ├── export_unsafe.go │ │ │ ├── internal │ │ │ ├── diff │ │ │ │ ├── debug_disable.go │ │ │ │ ├── debug_enable.go │ │ │ │ └── diff.go │ │ │ ├── flags │ │ │ │ └── flags.go │ │ │ ├── function │ │ │ │ └── func.go │ │ │ └── value │ │ │ │ ├── name.go │ │ │ │ ├── pointer_purego.go │ │ │ │ ├── pointer_unsafe.go │ │ │ │ ├── sort.go │ │ │ │ └── zero.go │ │ │ ├── options.go │ │ │ ├── path.go │ │ │ ├── report.go │ │ │ ├── report_compare.go │ │ │ ├── report_references.go │ │ │ ├── report_reflect.go │ │ │ ├── report_slices.go │ │ │ ├── report_text.go │ │ │ └── report_value.go │ ├── hashicorp │ │ ├── errwrap │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ └── errwrap.go │ │ ├── go-checkpoint │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── check.go │ │ │ ├── telemetry.go │ │ │ └── versions.go │ │ ├── go-cleanhttp │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── cleanhttp.go │ │ │ ├── doc.go │ │ │ └── handlers.go │ │ ├── go-cty │ │ │ ├── LICENSE │ │ │ └── cty │ │ │ │ ├── capsule.go │ │ │ │ ├── capsule_ops.go │ │ │ │ ├── collection.go │ │ │ │ ├── convert │ │ │ │ ├── compare_types.go │ │ │ │ ├── conversion.go │ │ │ │ ├── conversion_capsule.go │ │ │ │ ├── conversion_collection.go │ │ │ │ ├── conversion_dynamic.go │ │ │ │ ├── conversion_object.go │ │ │ │ ├── conversion_primitive.go │ │ │ │ ├── conversion_tuple.go │ │ │ │ ├── doc.go │ │ │ │ ├── mismatch_msg.go │ │ │ │ ├── public.go │ │ │ │ ├── sort_types.go │ │ │ │ └── unify.go │ │ │ │ ├── doc.go │ │ │ │ ├── element_iterator.go │ │ │ │ ├── error.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 │ │ │ │ ├── marks.go │ │ │ │ ├── msgpack │ │ │ │ ├── doc.go │ │ │ │ ├── dynamic.go │ │ │ │ ├── infinity.go │ │ │ │ ├── marshal.go │ │ │ │ ├── type_implied.go │ │ │ │ ├── unknown.go │ │ │ │ └── unmarshal.go │ │ │ │ ├── null.go │ │ │ │ ├── object_type.go │ │ │ │ ├── path.go │ │ │ │ ├── path_set.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-hclog │ │ │ ├── .gitignore │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── colorize_unix.go │ │ │ ├── colorize_windows.go │ │ │ ├── context.go │ │ │ ├── exclude.go │ │ │ ├── global.go │ │ │ ├── interceptlogger.go │ │ │ ├── intlogger.go │ │ │ ├── logger.go │ │ │ ├── nulllogger.go │ │ │ ├── stacktrace.go │ │ │ ├── stdlog.go │ │ │ └── writer.go │ │ ├── go-multierror │ │ │ ├── LICENSE │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── append.go │ │ │ ├── flatten.go │ │ │ ├── format.go │ │ │ ├── group.go │ │ │ ├── multierror.go │ │ │ ├── prefix.go │ │ │ └── sort.go │ │ ├── go-plugin │ │ │ ├── .gitignore │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── client.go │ │ │ ├── discover.go │ │ │ ├── error.go │ │ │ ├── grpc_broker.go │ │ │ ├── grpc_client.go │ │ │ ├── grpc_controller.go │ │ │ ├── grpc_server.go │ │ │ ├── grpc_stdio.go │ │ │ ├── internal │ │ │ │ └── plugin │ │ │ │ │ ├── gen.go │ │ │ │ │ ├── grpc_broker.pb.go │ │ │ │ │ ├── grpc_broker.proto │ │ │ │ │ ├── grpc_controller.pb.go │ │ │ │ │ ├── grpc_controller.proto │ │ │ │ │ ├── grpc_stdio.pb.go │ │ │ │ │ └── grpc_stdio.proto │ │ │ ├── log_entry.go │ │ │ ├── mtls.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-retryablehttp │ │ │ ├── .gitignore │ │ │ ├── .go-version │ │ │ ├── CHANGELOG.md │ │ │ ├── CODEOWNERS │ │ │ ├── LICENSE │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── cert_error_go119.go │ │ │ ├── cert_error_go120.go │ │ │ ├── client.go │ │ │ └── roundtripper.go │ │ ├── go-uuid │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ └── uuid.go │ │ ├── go-version │ │ │ ├── CHANGELOG.md │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── constraint.go │ │ │ ├── version.go │ │ │ └── version_collection.go │ │ ├── hc-install │ │ │ ├── .go-version │ │ │ ├── .goreleaser.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── checkpoint │ │ │ │ └── latest_version.go │ │ │ ├── errors │ │ │ │ └── errors.go │ │ │ ├── fs │ │ │ │ ├── any_version.go │ │ │ │ ├── exact_version.go │ │ │ │ ├── fs.go │ │ │ │ ├── fs_unix.go │ │ │ │ └── fs_windows.go │ │ │ ├── installer.go │ │ │ ├── internal │ │ │ │ ├── build │ │ │ │ │ ├── get_go_version.go │ │ │ │ │ ├── go_build.go │ │ │ │ │ ├── go_is_installed.go │ │ │ │ │ └── install_go_version.go │ │ │ │ ├── httpclient │ │ │ │ │ └── httpclient.go │ │ │ │ ├── pubkey │ │ │ │ │ └── pubkey.go │ │ │ │ ├── releasesjson │ │ │ │ │ ├── checksum_downloader.go │ │ │ │ │ ├── downloader.go │ │ │ │ │ ├── product_version.go │ │ │ │ │ └── releases.go │ │ │ │ ├── src │ │ │ │ │ └── src.go │ │ │ │ ├── validators │ │ │ │ │ └── validators.go │ │ │ │ └── version │ │ │ │ │ └── version.go │ │ │ ├── product │ │ │ │ ├── consul.go │ │ │ │ ├── product.go │ │ │ │ └── terraform.go │ │ │ ├── releases │ │ │ │ ├── exact_version.go │ │ │ │ ├── latest_version.go │ │ │ │ ├── releases.go │ │ │ │ └── versions.go │ │ │ └── src │ │ │ │ └── src.go │ │ ├── hcl │ │ │ └── v2 │ │ │ │ ├── CHANGELOG.md │ │ │ │ ├── LICENSE │ │ │ │ ├── README.md │ │ │ │ ├── diagnostic.go │ │ │ │ ├── diagnostic_text.go │ │ │ │ ├── didyoumean.go │ │ │ │ ├── doc.go │ │ │ │ ├── eval_context.go │ │ │ │ ├── expr_call.go │ │ │ │ ├── expr_list.go │ │ │ │ ├── expr_map.go │ │ │ │ ├── expr_unwrap.go │ │ │ │ ├── ext │ │ │ │ └── customdecode │ │ │ │ │ ├── README.md │ │ │ │ │ ├── customdecode.go │ │ │ │ │ └── expression_type.go │ │ │ │ ├── hclsyntax │ │ │ │ ├── diagnostics.go │ │ │ │ ├── didyoumean.go │ │ │ │ ├── doc.go │ │ │ │ ├── expression.go │ │ │ │ ├── expression_ops.go │ │ │ │ ├── expression_template.go │ │ │ │ ├── expression_vars.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 │ │ │ │ ├── structure_at_pos.go │ │ │ │ ├── token.go │ │ │ │ ├── token_type_string.go │ │ │ │ ├── unicode2ragel.rb │ │ │ │ ├── unicode_derived.rl │ │ │ │ ├── variables.go │ │ │ │ └── walk.go │ │ │ │ ├── merged.go │ │ │ │ ├── ops.go │ │ │ │ ├── pos.go │ │ │ │ ├── pos_scanner.go │ │ │ │ ├── schema.go │ │ │ │ ├── spec.md │ │ │ │ ├── static_expr.go │ │ │ │ ├── structure.go │ │ │ │ ├── structure_at_pos.go │ │ │ │ ├── traversal.go │ │ │ │ └── traversal_for_expr.go │ │ ├── logutils │ │ │ ├── .gitignore │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ └── level.go │ │ ├── terraform-exec │ │ │ ├── LICENSE │ │ │ ├── internal │ │ │ │ └── version │ │ │ │ │ └── version.go │ │ │ └── tfexec │ │ │ │ ├── apply.go │ │ │ │ ├── cmd.go │ │ │ │ ├── cmd_default.go │ │ │ │ ├── cmd_linux.go │ │ │ │ ├── destroy.go │ │ │ │ ├── doc.go │ │ │ │ ├── errors.go │ │ │ │ ├── exit_errors.go │ │ │ │ ├── fmt.go │ │ │ │ ├── force_unlock.go │ │ │ │ ├── get.go │ │ │ │ ├── graph.go │ │ │ │ ├── import.go │ │ │ │ ├── init.go │ │ │ │ ├── options.go │ │ │ │ ├── output.go │ │ │ │ ├── plan.go │ │ │ │ ├── providers_lock.go │ │ │ │ ├── providers_schema.go │ │ │ │ ├── refresh.go │ │ │ │ ├── show.go │ │ │ │ ├── state_mv.go │ │ │ │ ├── state_rm.go │ │ │ │ ├── taint.go │ │ │ │ ├── terraform.go │ │ │ │ ├── untaint.go │ │ │ │ ├── upgrade012.go │ │ │ │ ├── upgrade013.go │ │ │ │ ├── validate.go │ │ │ │ ├── version.go │ │ │ │ ├── workspace_delete.go │ │ │ │ ├── workspace_list.go │ │ │ │ ├── workspace_new.go │ │ │ │ ├── workspace_select.go │ │ │ │ └── workspace_show.go │ │ ├── terraform-json │ │ │ ├── .gitignore │ │ │ ├── .go-version │ │ │ ├── LICENSE │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── action.go │ │ │ ├── config.go │ │ │ ├── expression.go │ │ │ ├── plan.go │ │ │ ├── schemas.go │ │ │ ├── state.go │ │ │ ├── tfjson.go │ │ │ ├── validate.go │ │ │ └── version.go │ │ ├── terraform-plugin-go │ │ │ ├── LICENSE │ │ │ ├── internal │ │ │ │ └── logging │ │ │ │ │ ├── context.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── environment_variables.go │ │ │ │ │ ├── keys.go │ │ │ │ │ ├── protocol.go │ │ │ │ │ ├── protocol_data.go │ │ │ │ │ └── provider.go │ │ │ ├── tfprotov5 │ │ │ │ ├── data_source.go │ │ │ │ ├── diagnostic.go │ │ │ │ ├── doc.go │ │ │ │ ├── dynamic_value.go │ │ │ │ ├── internal │ │ │ │ │ ├── fromproto │ │ │ │ │ │ ├── attribute_path.go │ │ │ │ │ │ ├── data_source.go │ │ │ │ │ │ ├── diagnostic.go │ │ │ │ │ │ ├── provider.go │ │ │ │ │ │ ├── resource.go │ │ │ │ │ │ ├── schema.go │ │ │ │ │ │ ├── state.go │ │ │ │ │ │ ├── string_kind.go │ │ │ │ │ │ └── types.go │ │ │ │ │ ├── tfplugin5 │ │ │ │ │ │ ├── tfplugin5.pb.go │ │ │ │ │ │ ├── tfplugin5.proto │ │ │ │ │ │ └── tfplugin5_grpc.pb.go │ │ │ │ │ └── toproto │ │ │ │ │ │ ├── attribute_path.go │ │ │ │ │ │ ├── data_source.go │ │ │ │ │ │ ├── diagnostic.go │ │ │ │ │ │ ├── dynamic_value.go │ │ │ │ │ │ ├── provider.go │ │ │ │ │ │ ├── resource.go │ │ │ │ │ │ ├── schema.go │ │ │ │ │ │ ├── state.go │ │ │ │ │ │ └── string_kind.go │ │ │ │ ├── provider.go │ │ │ │ ├── resource.go │ │ │ │ ├── schema.go │ │ │ │ ├── state.go │ │ │ │ ├── string_kind.go │ │ │ │ └── tf5server │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── plugin.go │ │ │ │ │ └── server.go │ │ │ ├── tfprotov6 │ │ │ │ ├── data_source.go │ │ │ │ ├── diagnostic.go │ │ │ │ ├── doc.go │ │ │ │ ├── dynamic_value.go │ │ │ │ ├── internal │ │ │ │ │ ├── fromproto │ │ │ │ │ │ ├── attribute_path.go │ │ │ │ │ │ ├── data_source.go │ │ │ │ │ │ ├── diagnostic.go │ │ │ │ │ │ ├── provider.go │ │ │ │ │ │ ├── resource.go │ │ │ │ │ │ ├── schema.go │ │ │ │ │ │ ├── state.go │ │ │ │ │ │ ├── string_kind.go │ │ │ │ │ │ └── types.go │ │ │ │ │ ├── tfplugin6 │ │ │ │ │ │ ├── tfplugin6.pb.go │ │ │ │ │ │ ├── tfplugin6.proto │ │ │ │ │ │ └── tfplugin6_grpc.pb.go │ │ │ │ │ └── toproto │ │ │ │ │ │ ├── attribute_path.go │ │ │ │ │ │ ├── data_source.go │ │ │ │ │ │ ├── diagnostic.go │ │ │ │ │ │ ├── dynamic_value.go │ │ │ │ │ │ ├── provider.go │ │ │ │ │ │ ├── resource.go │ │ │ │ │ │ ├── schema.go │ │ │ │ │ │ ├── state.go │ │ │ │ │ │ └── string_kind.go │ │ │ │ ├── provider.go │ │ │ │ ├── resource.go │ │ │ │ ├── schema.go │ │ │ │ ├── state.go │ │ │ │ ├── string_kind.go │ │ │ │ └── tf6server │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── plugin.go │ │ │ │ │ └── server.go │ │ │ └── tftypes │ │ │ │ ├── attribute_path.go │ │ │ │ ├── attribute_path_error.go │ │ │ │ ├── diff.go │ │ │ │ ├── doc.go │ │ │ │ ├── list.go │ │ │ │ ├── map.go │ │ │ │ ├── object.go │ │ │ │ ├── primitive.go │ │ │ │ ├── set.go │ │ │ │ ├── tuple.go │ │ │ │ ├── type.go │ │ │ │ ├── unknown_value.go │ │ │ │ ├── value.go │ │ │ │ ├── value_json.go │ │ │ │ ├── value_msgpack.go │ │ │ │ └── walk.go │ │ ├── terraform-plugin-log │ │ │ ├── LICENSE │ │ │ ├── internal │ │ │ │ ├── hclogutils │ │ │ │ │ ├── args.go │ │ │ │ │ └── logger_options.go │ │ │ │ └── logging │ │ │ │ │ ├── log.go │ │ │ │ │ ├── options.go │ │ │ │ │ ├── provider.go │ │ │ │ │ ├── sdk.go │ │ │ │ │ └── sink.go │ │ │ ├── tflog │ │ │ │ ├── doc.go │ │ │ │ ├── options.go │ │ │ │ ├── provider.go │ │ │ │ └── subsystem.go │ │ │ └── tfsdklog │ │ │ │ ├── doc.go │ │ │ │ ├── options.go │ │ │ │ ├── sdk.go │ │ │ │ ├── sink.go │ │ │ │ └── subsystem.go │ │ ├── terraform-plugin-sdk │ │ │ └── v2 │ │ │ │ ├── LICENSE │ │ │ │ ├── diag │ │ │ │ ├── diagnostic.go │ │ │ │ └── helpers.go │ │ │ │ ├── helper │ │ │ │ ├── acctest │ │ │ │ │ └── random.go │ │ │ │ ├── logging │ │ │ │ │ ├── logging.go │ │ │ │ │ └── transport.go │ │ │ │ ├── resource │ │ │ │ │ ├── environment_variables.go │ │ │ │ │ ├── error.go │ │ │ │ │ ├── id.go │ │ │ │ │ ├── json.go │ │ │ │ │ ├── plugin.go │ │ │ │ │ ├── state.go │ │ │ │ │ ├── state_shim.go │ │ │ │ │ ├── testing.go │ │ │ │ │ ├── testing_config.go │ │ │ │ │ ├── testing_new.go │ │ │ │ │ ├── testing_new_config.go │ │ │ │ │ ├── testing_new_import_state.go │ │ │ │ │ ├── testing_sets.go │ │ │ │ │ └── wait.go │ │ │ │ ├── schema │ │ │ │ │ ├── README.md │ │ │ │ │ ├── context.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 │ │ │ │ │ ├── grpc_provider.go │ │ │ │ │ ├── json.go │ │ │ │ │ ├── provider.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 │ │ │ │ │ ├── shims.go │ │ │ │ │ ├── testing.go │ │ │ │ │ ├── unknown.go │ │ │ │ │ ├── valuetype.go │ │ │ │ │ └── valuetype_string.go │ │ │ │ ├── structure │ │ │ │ │ ├── expand_json.go │ │ │ │ │ ├── flatten_json.go │ │ │ │ │ ├── normalize_json.go │ │ │ │ │ └── suppress_json_diff.go │ │ │ │ └── validation │ │ │ │ │ ├── float.go │ │ │ │ │ ├── int.go │ │ │ │ │ ├── list.go │ │ │ │ │ ├── map.go │ │ │ │ │ ├── meta.go │ │ │ │ │ ├── network.go │ │ │ │ │ ├── strings.go │ │ │ │ │ ├── testing.go │ │ │ │ │ ├── time.go │ │ │ │ │ ├── uuid.go │ │ │ │ │ └── web.go │ │ │ │ ├── internal │ │ │ │ ├── addrs │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── instance_key.go │ │ │ │ │ ├── module.go │ │ │ │ │ ├── module_instance.go │ │ │ │ │ ├── resource.go │ │ │ │ │ └── resourcemode_string.go │ │ │ │ ├── configs │ │ │ │ │ ├── configschema │ │ │ │ │ │ ├── coerce_value.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── empty_value.go │ │ │ │ │ │ ├── implied_type.go │ │ │ │ │ │ ├── nestingmode_string.go │ │ │ │ │ │ └── schema.go │ │ │ │ │ └── hcl2shim │ │ │ │ │ │ ├── flatmap.go │ │ │ │ │ │ ├── paths.go │ │ │ │ │ │ ├── values.go │ │ │ │ │ │ └── values_equiv.go │ │ │ │ ├── helper │ │ │ │ │ └── hashcode │ │ │ │ │ │ └── hashcode.go │ │ │ │ ├── logging │ │ │ │ │ ├── context.go │ │ │ │ │ ├── environment_variables.go │ │ │ │ │ ├── helper_resource.go │ │ │ │ │ ├── helper_schema.go │ │ │ │ │ └── keys.go │ │ │ │ ├── plans │ │ │ │ │ └── objchange │ │ │ │ │ │ └── normalize_obj.go │ │ │ │ ├── plugin │ │ │ │ │ └── convert │ │ │ │ │ │ ├── diagnostics.go │ │ │ │ │ │ └── schema.go │ │ │ │ ├── plugintest │ │ │ │ │ ├── config.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── environment_variables.go │ │ │ │ │ ├── guard.go │ │ │ │ │ ├── helper.go │ │ │ │ │ ├── util.go │ │ │ │ │ └── working_dir.go │ │ │ │ └── tfdiags │ │ │ │ │ ├── config_traversals.go │ │ │ │ │ ├── contextual.go │ │ │ │ │ ├── diagnostic.go │ │ │ │ │ ├── diagnostic_base.go │ │ │ │ │ ├── diagnostics.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── error.go │ │ │ │ │ ├── rpc_friendly.go │ │ │ │ │ ├── severity_string.go │ │ │ │ │ └── simple_warning.go │ │ │ │ ├── meta │ │ │ │ └── meta.go │ │ │ │ ├── plugin │ │ │ │ ├── debug.go │ │ │ │ └── serve.go │ │ │ │ └── terraform │ │ │ │ ├── diff.go │ │ │ │ ├── instancetype.go │ │ │ │ ├── instancetype_string.go │ │ │ │ ├── resource.go │ │ │ │ ├── resource_address.go │ │ │ │ ├── resource_mode.go │ │ │ │ ├── resource_mode_string.go │ │ │ │ ├── resource_provider.go │ │ │ │ ├── schemas.go │ │ │ │ ├── state.go │ │ │ │ ├── state_filter.go │ │ │ │ └── util.go │ │ ├── terraform-registry-address │ │ │ ├── .go-version │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── errors.go │ │ │ ├── module.go │ │ │ ├── module_package.go │ │ │ └── provider.go │ │ ├── terraform-svchost │ │ │ ├── LICENSE │ │ │ ├── label_iter.go │ │ │ └── svchost.go │ │ └── yamux │ │ │ ├── .gitignore │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── addr.go │ │ │ ├── const.go │ │ │ ├── mux.go │ │ │ ├── session.go │ │ │ ├── spec.md │ │ │ ├── stream.go │ │ │ └── util.go │ ├── mattn │ │ ├── go-colorable │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── colorable_appengine.go │ │ │ ├── colorable_others.go │ │ │ ├── colorable_windows.go │ │ │ ├── go.test.sh │ │ │ └── noncolorable.go │ │ └── go-isatty │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── doc.go │ │ │ ├── go.test.sh │ │ │ ├── isatty_bsd.go │ │ │ ├── isatty_others.go │ │ │ ├── isatty_plan9.go │ │ │ ├── isatty_solaris.go │ │ │ ├── isatty_tcgets.go │ │ │ └── isatty_windows.go │ ├── mitchellh │ │ ├── copystructure │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── copier_time.go │ │ │ └── copystructure.go │ │ ├── go-testing-interface │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ └── testing.go │ │ ├── go-wordwrap │ │ │ ├── LICENSE.md │ │ │ ├── README.md │ │ │ └── wordwrap.go │ │ ├── mapstructure │ │ │ ├── CHANGELOG.md │ │ │ ├── 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 │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── actors.go │ │ │ └── group.go │ ├── vmihailenco │ │ ├── msgpack │ │ │ ├── .travis.yml │ │ │ ├── CHANGELOG.md │ │ │ ├── LICENSE │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── appengine.go │ │ │ ├── codes │ │ │ │ └── codes.go │ │ │ ├── decode.go │ │ │ ├── decode_map.go │ │ │ ├── decode_number.go │ │ │ ├── decode_query.go │ │ │ ├── decode_slice.go │ │ │ ├── decode_string.go │ │ │ ├── decode_value.go │ │ │ ├── encode.go │ │ │ ├── encode_map.go │ │ │ ├── encode_number.go │ │ │ ├── encode_slice.go │ │ │ ├── encode_value.go │ │ │ ├── ext.go │ │ │ ├── msgpack.go │ │ │ ├── tag.go │ │ │ ├── time.go │ │ │ ├── types.go │ │ │ └── v4 │ │ │ │ ├── .golangci.yml │ │ │ │ ├── .travis.yml │ │ │ │ ├── CHANGELOG.md │ │ │ │ ├── LICENSE │ │ │ │ ├── Makefile │ │ │ │ ├── README.md │ │ │ │ ├── appengine.go │ │ │ │ ├── codes │ │ │ │ └── codes.go │ │ │ │ ├── decode.go │ │ │ │ ├── decode_map.go │ │ │ │ ├── decode_number.go │ │ │ │ ├── decode_query.go │ │ │ │ ├── decode_slice.go │ │ │ │ ├── decode_string.go │ │ │ │ ├── decode_value.go │ │ │ │ ├── encode.go │ │ │ │ ├── encode_map.go │ │ │ │ ├── encode_number.go │ │ │ │ ├── encode_slice.go │ │ │ │ ├── encode_value.go │ │ │ │ ├── ext.go │ │ │ │ ├── intern.go │ │ │ │ ├── msgpack.go │ │ │ │ ├── safe.go │ │ │ │ ├── time.go │ │ │ │ ├── types.go │ │ │ │ └── unsafe.go │ │ └── tagparser │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── internal │ │ │ ├── parser │ │ │ │ └── parser.go │ │ │ ├── safe.go │ │ │ └── unsafe.go │ │ │ └── tagparser.go │ ├── yannh │ │ └── statuspage-go-sdk │ │ │ ├── LICENSE.txt │ │ │ ├── README.md │ │ │ ├── component.go │ │ │ ├── component_group.go │ │ │ ├── incident.go │ │ │ ├── incident_template.go │ │ │ ├── main.go │ │ │ ├── metric.go │ │ │ ├── metrics_provider.go │ │ │ └── retryable_http_client.go │ └── zclconf │ │ └── go-cty │ │ ├── LICENSE │ │ └── cty │ │ ├── capsule.go │ │ ├── capsule_ops.go │ │ ├── collection.go │ │ ├── convert │ │ ├── compare_types.go │ │ ├── conversion.go │ │ ├── conversion_capsule.go │ │ ├── conversion_collection.go │ │ ├── conversion_dynamic.go │ │ ├── conversion_object.go │ │ ├── conversion_primitive.go │ │ ├── conversion_tuple.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 │ │ │ ├── conversion.go │ │ │ ├── csv.go │ │ │ ├── datetime.go │ │ │ ├── doc.go │ │ │ ├── format.go │ │ │ ├── format_fsm.go │ │ │ ├── format_fsm.rl │ │ │ ├── general.go │ │ │ ├── json.go │ │ │ ├── number.go │ │ │ ├── regexp.go │ │ │ ├── sequence.go │ │ │ ├── set.go │ │ │ ├── string.go │ │ │ └── string_replace.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 │ │ ├── marks.go │ │ ├── null.go │ │ ├── object_type.go │ │ ├── path.go │ │ ├── path_set.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 ├── golang.org │ └── x │ │ ├── crypto │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── LICENSE │ │ ├── PATENTS │ │ ├── blowfish │ │ │ ├── block.go │ │ │ ├── cipher.go │ │ │ └── const.go │ │ ├── cast5 │ │ │ └── cast5.go │ │ ├── chacha20 │ │ │ ├── chacha_arm64.go │ │ │ ├── chacha_arm64.s │ │ │ ├── chacha_generic.go │ │ │ ├── chacha_noasm.go │ │ │ ├── chacha_ppc64le.go │ │ │ ├── chacha_ppc64le.s │ │ │ ├── chacha_s390x.go │ │ │ ├── chacha_s390x.s │ │ │ └── xor.go │ │ ├── curve25519 │ │ │ ├── curve25519.go │ │ │ └── internal │ │ │ │ └── field │ │ │ │ ├── README │ │ │ │ ├── fe.go │ │ │ │ ├── fe_amd64.go │ │ │ │ ├── fe_amd64.s │ │ │ │ ├── fe_amd64_noasm.go │ │ │ │ ├── fe_arm64.go │ │ │ │ ├── fe_arm64.s │ │ │ │ ├── fe_arm64_noasm.go │ │ │ │ ├── fe_generic.go │ │ │ │ ├── sync.checkpoint │ │ │ │ └── sync.sh │ │ ├── ed25519 │ │ │ ├── ed25519.go │ │ │ ├── ed25519_go113.go │ │ │ └── internal │ │ │ │ └── edwards25519 │ │ │ │ ├── const.go │ │ │ │ └── edwards25519.go │ │ ├── internal │ │ │ └── subtle │ │ │ │ ├── aliasing.go │ │ │ │ └── aliasing_purego.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 │ │ │ ├── bits_compat.go │ │ │ ├── bits_go1.13.go │ │ │ ├── mac_noasm.go │ │ │ ├── poly1305.go │ │ │ ├── sum_amd64.go │ │ │ ├── sum_amd64.s │ │ │ ├── sum_generic.go │ │ │ ├── sum_ppc64le.go │ │ │ ├── sum_ppc64le.s │ │ │ ├── sum_s390x.go │ │ │ └── sum_s390x.s │ │ └── ssh │ │ │ ├── buffer.go │ │ │ ├── certs.go │ │ │ ├── channel.go │ │ │ ├── cipher.go │ │ │ ├── client.go │ │ │ ├── client_auth.go │ │ │ ├── common.go │ │ │ ├── connection.go │ │ │ ├── doc.go │ │ │ ├── handshake.go │ │ │ ├── internal │ │ │ └── bcrypt_pbkdf │ │ │ │ └── bcrypt_pbkdf.go │ │ │ ├── kex.go │ │ │ ├── keys.go │ │ │ ├── mac.go │ │ │ ├── messages.go │ │ │ ├── mux.go │ │ │ ├── server.go │ │ │ ├── session.go │ │ │ ├── ssh_gss.go │ │ │ ├── streamlocal.go │ │ │ ├── tcpip.go │ │ │ └── transport.go │ │ ├── net │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── LICENSE │ │ ├── PATENTS │ │ ├── context │ │ │ ├── context.go │ │ │ ├── go17.go │ │ │ ├── go19.go │ │ │ ├── pre_go17.go │ │ │ └── pre_go19.go │ │ ├── http │ │ │ └── httpguts │ │ │ │ ├── guts.go │ │ │ │ └── httplex.go │ │ ├── http2 │ │ │ ├── .gitignore │ │ │ ├── Dockerfile │ │ │ ├── Makefile │ │ │ ├── ascii.go │ │ │ ├── ciphers.go │ │ │ ├── client_conn_pool.go │ │ │ ├── databuffer.go │ │ │ ├── errors.go │ │ │ ├── flow.go │ │ │ ├── frame.go │ │ │ ├── go111.go │ │ │ ├── go115.go │ │ │ ├── go118.go │ │ │ ├── gotrack.go │ │ │ ├── headermap.go │ │ │ ├── hpack │ │ │ │ ├── encode.go │ │ │ │ ├── hpack.go │ │ │ │ ├── huffman.go │ │ │ │ └── tables.go │ │ │ ├── http2.go │ │ │ ├── not_go111.go │ │ │ ├── not_go115.go │ │ │ ├── not_go118.go │ │ │ ├── pipe.go │ │ │ ├── server.go │ │ │ ├── transport.go │ │ │ ├── write.go │ │ │ ├── writesched.go │ │ │ ├── writesched_priority.go │ │ │ └── writesched_random.go │ │ ├── idna │ │ │ ├── go118.go │ │ │ ├── idna10.0.0.go │ │ │ ├── idna9.0.0.go │ │ │ ├── pre_go118.go │ │ │ ├── punycode.go │ │ │ ├── tables10.0.0.go │ │ │ ├── tables11.0.0.go │ │ │ ├── tables12.0.0.go │ │ │ ├── tables13.0.0.go │ │ │ ├── tables9.0.0.go │ │ │ ├── trie.go │ │ │ └── trieval.go │ │ ├── internal │ │ │ └── timeseries │ │ │ │ └── timeseries.go │ │ └── trace │ │ │ ├── events.go │ │ │ ├── histogram.go │ │ │ └── trace.go │ │ ├── sys │ │ ├── LICENSE │ │ ├── PATENTS │ │ ├── cpu │ │ │ ├── asm_aix_ppc64.s │ │ │ ├── byteorder.go │ │ │ ├── cpu.go │ │ │ ├── cpu_aix.go │ │ │ ├── cpu_arm.go │ │ │ ├── cpu_arm64.go │ │ │ ├── cpu_arm64.s │ │ │ ├── cpu_gc_arm64.go │ │ │ ├── cpu_gc_s390x.go │ │ │ ├── cpu_gc_x86.go │ │ │ ├── cpu_gccgo_arm64.go │ │ │ ├── cpu_gccgo_s390x.go │ │ │ ├── cpu_gccgo_x86.c │ │ │ ├── cpu_gccgo_x86.go │ │ │ ├── cpu_linux.go │ │ │ ├── cpu_linux_arm.go │ │ │ ├── cpu_linux_arm64.go │ │ │ ├── cpu_linux_mips64x.go │ │ │ ├── cpu_linux_noinit.go │ │ │ ├── cpu_linux_ppc64x.go │ │ │ ├── cpu_linux_s390x.go │ │ │ ├── cpu_loong64.go │ │ │ ├── cpu_mips64x.go │ │ │ ├── cpu_mipsx.go │ │ │ ├── cpu_netbsd_arm64.go │ │ │ ├── cpu_openbsd_arm64.go │ │ │ ├── cpu_openbsd_arm64.s │ │ │ ├── cpu_other_arm.go │ │ │ ├── cpu_other_arm64.go │ │ │ ├── cpu_other_mips64x.go │ │ │ ├── cpu_other_ppc64x.go │ │ │ ├── cpu_other_riscv64.go │ │ │ ├── cpu_ppc64x.go │ │ │ ├── cpu_riscv64.go │ │ │ ├── cpu_s390x.go │ │ │ ├── cpu_s390x.s │ │ │ ├── cpu_wasm.go │ │ │ ├── cpu_x86.go │ │ │ ├── cpu_x86.s │ │ │ ├── cpu_zos.go │ │ │ ├── cpu_zos_s390x.go │ │ │ ├── endian_big.go │ │ │ ├── endian_little.go │ │ │ ├── hwcap_linux.go │ │ │ ├── parse.go │ │ │ ├── proc_cpuinfo_linux.go │ │ │ ├── runtime_auxv.go │ │ │ ├── runtime_auxv_go121.go │ │ │ ├── syscall_aix_gccgo.go │ │ │ └── syscall_aix_ppc64_gc.go │ │ ├── unix │ │ │ ├── .gitignore │ │ │ ├── README.md │ │ │ ├── affinity_linux.go │ │ │ ├── aliases.go │ │ │ ├── asm_aix_ppc64.s │ │ │ ├── asm_bsd_386.s │ │ │ ├── asm_bsd_amd64.s │ │ │ ├── asm_bsd_arm.s │ │ │ ├── asm_bsd_arm64.s │ │ │ ├── asm_bsd_ppc64.s │ │ │ ├── asm_bsd_riscv64.s │ │ │ ├── asm_linux_386.s │ │ │ ├── asm_linux_amd64.s │ │ │ ├── asm_linux_arm.s │ │ │ ├── asm_linux_arm64.s │ │ │ ├── asm_linux_loong64.s │ │ │ ├── asm_linux_mips64x.s │ │ │ ├── asm_linux_mipsx.s │ │ │ ├── asm_linux_ppc64x.s │ │ │ ├── asm_linux_riscv64.s │ │ │ ├── asm_linux_s390x.s │ │ │ ├── asm_openbsd_mips64.s │ │ │ ├── asm_solaris_amd64.s │ │ │ ├── asm_zos_s390x.s │ │ │ ├── bluetooth_linux.go │ │ │ ├── bpxsvc_zos.go │ │ │ ├── bpxsvc_zos.s │ │ │ ├── cap_freebsd.go │ │ │ ├── constants.go │ │ │ ├── dev_aix_ppc.go │ │ │ ├── dev_aix_ppc64.go │ │ │ ├── dev_darwin.go │ │ │ ├── dev_dragonfly.go │ │ │ ├── dev_freebsd.go │ │ │ ├── dev_linux.go │ │ │ ├── dev_netbsd.go │ │ │ ├── dev_openbsd.go │ │ │ ├── dev_zos.go │ │ │ ├── dirent.go │ │ │ ├── endian_big.go │ │ │ ├── endian_little.go │ │ │ ├── env_unix.go │ │ │ ├── fcntl.go │ │ │ ├── fcntl_darwin.go │ │ │ ├── fcntl_linux_32bit.go │ │ │ ├── fdset.go │ │ │ ├── gccgo.go │ │ │ ├── gccgo_c.c │ │ │ ├── gccgo_linux_amd64.go │ │ │ ├── ifreq_linux.go │ │ │ ├── ioctl_linux.go │ │ │ ├── ioctl_signed.go │ │ │ ├── ioctl_unsigned.go │ │ │ ├── ioctl_zos.go │ │ │ ├── mkall.sh │ │ │ ├── mkerrors.sh │ │ │ ├── mmap_nomremap.go │ │ │ ├── mremap.go │ │ │ ├── pagesize_unix.go │ │ │ ├── pledge_openbsd.go │ │ │ ├── ptrace_darwin.go │ │ │ ├── ptrace_ios.go │ │ │ ├── race.go │ │ │ ├── race0.go │ │ │ ├── readdirent_getdents.go │ │ │ ├── readdirent_getdirentries.go │ │ │ ├── sockcmsg_dragonfly.go │ │ │ ├── sockcmsg_linux.go │ │ │ ├── sockcmsg_unix.go │ │ │ ├── sockcmsg_unix_other.go │ │ │ ├── sockcmsg_zos.go │ │ │ ├── symaddr_zos_s390x.s │ │ │ ├── syscall.go │ │ │ ├── syscall_aix.go │ │ │ ├── syscall_aix_ppc.go │ │ │ ├── syscall_aix_ppc64.go │ │ │ ├── syscall_bsd.go │ │ │ ├── syscall_darwin.go │ │ │ ├── syscall_darwin_amd64.go │ │ │ ├── syscall_darwin_arm64.go │ │ │ ├── syscall_darwin_libSystem.go │ │ │ ├── syscall_dragonfly.go │ │ │ ├── syscall_dragonfly_amd64.go │ │ │ ├── syscall_freebsd.go │ │ │ ├── syscall_freebsd_386.go │ │ │ ├── syscall_freebsd_amd64.go │ │ │ ├── syscall_freebsd_arm.go │ │ │ ├── syscall_freebsd_arm64.go │ │ │ ├── syscall_freebsd_riscv64.go │ │ │ ├── syscall_hurd.go │ │ │ ├── syscall_hurd_386.go │ │ │ ├── syscall_illumos.go │ │ │ ├── syscall_linux.go │ │ │ ├── syscall_linux_386.go │ │ │ ├── syscall_linux_alarm.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_gc_arm.go │ │ │ ├── syscall_linux_gccgo_386.go │ │ │ ├── syscall_linux_gccgo_arm.go │ │ │ ├── syscall_linux_loong64.go │ │ │ ├── syscall_linux_mips64x.go │ │ │ ├── syscall_linux_mipsx.go │ │ │ ├── syscall_linux_ppc.go │ │ │ ├── syscall_linux_ppc64x.go │ │ │ ├── syscall_linux_riscv64.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_netbsd_arm64.go │ │ │ ├── syscall_openbsd.go │ │ │ ├── syscall_openbsd_386.go │ │ │ ├── syscall_openbsd_amd64.go │ │ │ ├── syscall_openbsd_arm.go │ │ │ ├── syscall_openbsd_arm64.go │ │ │ ├── syscall_openbsd_libc.go │ │ │ ├── syscall_openbsd_mips64.go │ │ │ ├── syscall_openbsd_ppc64.go │ │ │ ├── syscall_openbsd_riscv64.go │ │ │ ├── syscall_solaris.go │ │ │ ├── syscall_solaris_amd64.go │ │ │ ├── syscall_unix.go │ │ │ ├── syscall_unix_gc.go │ │ │ ├── syscall_unix_gc_ppc64x.go │ │ │ ├── syscall_zos_s390x.go │ │ │ ├── sysvshm_linux.go │ │ │ ├── sysvshm_unix.go │ │ │ ├── sysvshm_unix_other.go │ │ │ ├── timestruct.go │ │ │ ├── unveil_openbsd.go │ │ │ ├── xattr_bsd.go │ │ │ ├── zerrors_aix_ppc.go │ │ │ ├── zerrors_aix_ppc64.go │ │ │ ├── zerrors_darwin_amd64.go │ │ │ ├── zerrors_darwin_arm64.go │ │ │ ├── zerrors_dragonfly_amd64.go │ │ │ ├── zerrors_freebsd_386.go │ │ │ ├── zerrors_freebsd_amd64.go │ │ │ ├── zerrors_freebsd_arm.go │ │ │ ├── zerrors_freebsd_arm64.go │ │ │ ├── zerrors_freebsd_riscv64.go │ │ │ ├── zerrors_linux.go │ │ │ ├── zerrors_linux_386.go │ │ │ ├── zerrors_linux_amd64.go │ │ │ ├── zerrors_linux_arm.go │ │ │ ├── zerrors_linux_arm64.go │ │ │ ├── zerrors_linux_loong64.go │ │ │ ├── zerrors_linux_mips.go │ │ │ ├── zerrors_linux_mips64.go │ │ │ ├── zerrors_linux_mips64le.go │ │ │ ├── zerrors_linux_mipsle.go │ │ │ ├── zerrors_linux_ppc.go │ │ │ ├── zerrors_linux_ppc64.go │ │ │ ├── zerrors_linux_ppc64le.go │ │ │ ├── zerrors_linux_riscv64.go │ │ │ ├── zerrors_linux_s390x.go │ │ │ ├── zerrors_linux_sparc64.go │ │ │ ├── zerrors_netbsd_386.go │ │ │ ├── zerrors_netbsd_amd64.go │ │ │ ├── zerrors_netbsd_arm.go │ │ │ ├── zerrors_netbsd_arm64.go │ │ │ ├── zerrors_openbsd_386.go │ │ │ ├── zerrors_openbsd_amd64.go │ │ │ ├── zerrors_openbsd_arm.go │ │ │ ├── zerrors_openbsd_arm64.go │ │ │ ├── zerrors_openbsd_mips64.go │ │ │ ├── zerrors_openbsd_ppc64.go │ │ │ ├── zerrors_openbsd_riscv64.go │ │ │ ├── zerrors_solaris_amd64.go │ │ │ ├── zerrors_zos_s390x.go │ │ │ ├── zptrace_armnn_linux.go │ │ │ ├── zptrace_linux_arm64.go │ │ │ ├── zptrace_mipsnn_linux.go │ │ │ ├── zptrace_mipsnnle_linux.go │ │ │ ├── zptrace_x86_linux.go │ │ │ ├── zsymaddr_zos_s390x.s │ │ │ ├── zsyscall_aix_ppc.go │ │ │ ├── zsyscall_aix_ppc64.go │ │ │ ├── zsyscall_aix_ppc64_gc.go │ │ │ ├── zsyscall_aix_ppc64_gccgo.go │ │ │ ├── zsyscall_darwin_amd64.go │ │ │ ├── zsyscall_darwin_amd64.s │ │ │ ├── zsyscall_darwin_arm64.go │ │ │ ├── zsyscall_darwin_arm64.s │ │ │ ├── zsyscall_dragonfly_amd64.go │ │ │ ├── zsyscall_freebsd_386.go │ │ │ ├── zsyscall_freebsd_amd64.go │ │ │ ├── zsyscall_freebsd_arm.go │ │ │ ├── zsyscall_freebsd_arm64.go │ │ │ ├── zsyscall_freebsd_riscv64.go │ │ │ ├── zsyscall_illumos_amd64.go │ │ │ ├── zsyscall_linux.go │ │ │ ├── zsyscall_linux_386.go │ │ │ ├── zsyscall_linux_amd64.go │ │ │ ├── zsyscall_linux_arm.go │ │ │ ├── zsyscall_linux_arm64.go │ │ │ ├── zsyscall_linux_loong64.go │ │ │ ├── zsyscall_linux_mips.go │ │ │ ├── zsyscall_linux_mips64.go │ │ │ ├── zsyscall_linux_mips64le.go │ │ │ ├── zsyscall_linux_mipsle.go │ │ │ ├── zsyscall_linux_ppc.go │ │ │ ├── zsyscall_linux_ppc64.go │ │ │ ├── zsyscall_linux_ppc64le.go │ │ │ ├── zsyscall_linux_riscv64.go │ │ │ ├── zsyscall_linux_s390x.go │ │ │ ├── zsyscall_linux_sparc64.go │ │ │ ├── zsyscall_netbsd_386.go │ │ │ ├── zsyscall_netbsd_amd64.go │ │ │ ├── zsyscall_netbsd_arm.go │ │ │ ├── zsyscall_netbsd_arm64.go │ │ │ ├── zsyscall_openbsd_386.go │ │ │ ├── zsyscall_openbsd_386.s │ │ │ ├── zsyscall_openbsd_amd64.go │ │ │ ├── zsyscall_openbsd_amd64.s │ │ │ ├── zsyscall_openbsd_arm.go │ │ │ ├── zsyscall_openbsd_arm.s │ │ │ ├── zsyscall_openbsd_arm64.go │ │ │ ├── zsyscall_openbsd_arm64.s │ │ │ ├── zsyscall_openbsd_mips64.go │ │ │ ├── zsyscall_openbsd_mips64.s │ │ │ ├── zsyscall_openbsd_ppc64.go │ │ │ ├── zsyscall_openbsd_ppc64.s │ │ │ ├── zsyscall_openbsd_riscv64.go │ │ │ ├── zsyscall_openbsd_riscv64.s │ │ │ ├── zsyscall_solaris_amd64.go │ │ │ ├── zsyscall_zos_s390x.go │ │ │ ├── zsysctl_openbsd_386.go │ │ │ ├── zsysctl_openbsd_amd64.go │ │ │ ├── zsysctl_openbsd_arm.go │ │ │ ├── zsysctl_openbsd_arm64.go │ │ │ ├── zsysctl_openbsd_mips64.go │ │ │ ├── zsysctl_openbsd_ppc64.go │ │ │ ├── zsysctl_openbsd_riscv64.go │ │ │ ├── zsysnum_darwin_amd64.go │ │ │ ├── zsysnum_darwin_arm64.go │ │ │ ├── zsysnum_dragonfly_amd64.go │ │ │ ├── zsysnum_freebsd_386.go │ │ │ ├── zsysnum_freebsd_amd64.go │ │ │ ├── zsysnum_freebsd_arm.go │ │ │ ├── zsysnum_freebsd_arm64.go │ │ │ ├── zsysnum_freebsd_riscv64.go │ │ │ ├── zsysnum_linux_386.go │ │ │ ├── zsysnum_linux_amd64.go │ │ │ ├── zsysnum_linux_arm.go │ │ │ ├── zsysnum_linux_arm64.go │ │ │ ├── zsysnum_linux_loong64.go │ │ │ ├── zsysnum_linux_mips.go │ │ │ ├── zsysnum_linux_mips64.go │ │ │ ├── zsysnum_linux_mips64le.go │ │ │ ├── zsysnum_linux_mipsle.go │ │ │ ├── zsysnum_linux_ppc.go │ │ │ ├── zsysnum_linux_ppc64.go │ │ │ ├── zsysnum_linux_ppc64le.go │ │ │ ├── zsysnum_linux_riscv64.go │ │ │ ├── zsysnum_linux_s390x.go │ │ │ ├── zsysnum_linux_sparc64.go │ │ │ ├── zsysnum_netbsd_386.go │ │ │ ├── zsysnum_netbsd_amd64.go │ │ │ ├── zsysnum_netbsd_arm.go │ │ │ ├── zsysnum_netbsd_arm64.go │ │ │ ├── zsysnum_openbsd_386.go │ │ │ ├── zsysnum_openbsd_amd64.go │ │ │ ├── zsysnum_openbsd_arm.go │ │ │ ├── zsysnum_openbsd_arm64.go │ │ │ ├── zsysnum_openbsd_mips64.go │ │ │ ├── zsysnum_openbsd_ppc64.go │ │ │ ├── zsysnum_openbsd_riscv64.go │ │ │ ├── zsysnum_zos_s390x.go │ │ │ ├── ztypes_aix_ppc.go │ │ │ ├── ztypes_aix_ppc64.go │ │ │ ├── ztypes_darwin_amd64.go │ │ │ ├── ztypes_darwin_arm64.go │ │ │ ├── ztypes_dragonfly_amd64.go │ │ │ ├── ztypes_freebsd_386.go │ │ │ ├── ztypes_freebsd_amd64.go │ │ │ ├── ztypes_freebsd_arm.go │ │ │ ├── ztypes_freebsd_arm64.go │ │ │ ├── ztypes_freebsd_riscv64.go │ │ │ ├── ztypes_linux.go │ │ │ ├── ztypes_linux_386.go │ │ │ ├── ztypes_linux_amd64.go │ │ │ ├── ztypes_linux_arm.go │ │ │ ├── ztypes_linux_arm64.go │ │ │ ├── ztypes_linux_loong64.go │ │ │ ├── ztypes_linux_mips.go │ │ │ ├── ztypes_linux_mips64.go │ │ │ ├── ztypes_linux_mips64le.go │ │ │ ├── ztypes_linux_mipsle.go │ │ │ ├── ztypes_linux_ppc.go │ │ │ ├── ztypes_linux_ppc64.go │ │ │ ├── ztypes_linux_ppc64le.go │ │ │ ├── ztypes_linux_riscv64.go │ │ │ ├── ztypes_linux_s390x.go │ │ │ ├── ztypes_linux_sparc64.go │ │ │ ├── ztypes_netbsd_386.go │ │ │ ├── ztypes_netbsd_amd64.go │ │ │ ├── ztypes_netbsd_arm.go │ │ │ ├── ztypes_netbsd_arm64.go │ │ │ ├── ztypes_openbsd_386.go │ │ │ ├── ztypes_openbsd_amd64.go │ │ │ ├── ztypes_openbsd_arm.go │ │ │ ├── ztypes_openbsd_arm64.go │ │ │ ├── ztypes_openbsd_mips64.go │ │ │ ├── ztypes_openbsd_ppc64.go │ │ │ ├── ztypes_openbsd_riscv64.go │ │ │ ├── ztypes_solaris_amd64.go │ │ │ └── ztypes_zos_s390x.go │ │ └── windows │ │ │ ├── aliases.go │ │ │ ├── dll_windows.go │ │ │ ├── env_windows.go │ │ │ ├── eventlog.go │ │ │ ├── exec_windows.go │ │ │ ├── memory_windows.go │ │ │ ├── mkerrors.bash │ │ │ ├── mkknownfolderids.bash │ │ │ ├── mksyscall.go │ │ │ ├── race.go │ │ │ ├── race0.go │ │ │ ├── security_windows.go │ │ │ ├── service.go │ │ │ ├── setupapi_windows.go │ │ │ ├── str.go │ │ │ ├── syscall.go │ │ │ ├── syscall_windows.go │ │ │ ├── types_windows.go │ │ │ ├── types_windows_386.go │ │ │ ├── types_windows_amd64.go │ │ │ ├── types_windows_arm.go │ │ │ ├── types_windows_arm64.go │ │ │ ├── zerrors_windows.go │ │ │ ├── zknownfolderids_windows.go │ │ │ └── zsyscall_windows.go │ │ └── text │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── LICENSE │ │ ├── PATENTS │ │ ├── secure │ │ └── bidirule │ │ │ ├── bidirule.go │ │ │ ├── bidirule10.0.0.go │ │ │ └── bidirule9.0.0.go │ │ ├── transform │ │ └── transform.go │ │ └── unicode │ │ ├── bidi │ │ ├── bidi.go │ │ ├── bracket.go │ │ ├── core.go │ │ ├── prop.go │ │ ├── tables10.0.0.go │ │ ├── tables11.0.0.go │ │ ├── tables12.0.0.go │ │ ├── tables13.0.0.go │ │ ├── tables9.0.0.go │ │ └── trieval.go │ │ └── norm │ │ ├── composition.go │ │ ├── forminfo.go │ │ ├── input.go │ │ ├── iter.go │ │ ├── normalize.go │ │ ├── readwriter.go │ │ ├── tables10.0.0.go │ │ ├── tables11.0.0.go │ │ ├── tables12.0.0.go │ │ ├── tables13.0.0.go │ │ ├── tables9.0.0.go │ │ ├── transform.go │ │ └── trie.go ├── google.golang.org │ ├── appengine │ │ ├── .travis.yml │ │ ├── CONTRIBUTING.md │ │ ├── LICENSE │ │ ├── README.md │ │ ├── appengine.go │ │ ├── appengine_vm.go │ │ ├── datastore │ │ │ ├── datastore.go │ │ │ ├── doc.go │ │ │ ├── internal │ │ │ │ ├── cloudkey │ │ │ │ │ └── cloudkey.go │ │ │ │ └── cloudpb │ │ │ │ │ └── entity.pb.go │ │ │ ├── key.go │ │ │ ├── keycompat.go │ │ │ ├── load.go │ │ │ ├── metadata.go │ │ │ ├── prop.go │ │ │ ├── query.go │ │ │ ├── save.go │ │ │ └── transaction.go │ │ ├── errors.go │ │ ├── identity.go │ │ ├── internal │ │ │ ├── api.go │ │ │ ├── api_classic.go │ │ │ ├── api_common.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_flex.go │ │ │ ├── identity_vm.go │ │ │ ├── internal.go │ │ │ ├── log │ │ │ │ ├── log_service.pb.go │ │ │ │ └── log_service.proto │ │ │ ├── main.go │ │ │ ├── main_common.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 │ │ │ └── transaction.go │ │ ├── namespace.go │ │ ├── timeout.go │ │ ├── travis_install.sh │ │ └── travis_test.sh │ ├── genproto │ │ ├── LICENSE │ │ └── googleapis │ │ │ └── rpc │ │ │ └── status │ │ │ └── status.pb.go │ ├── grpc │ │ ├── AUTHORS │ │ ├── CODE-OF-CONDUCT.md │ │ ├── CONTRIBUTING.md │ │ ├── GOVERNANCE.md │ │ ├── LICENSE │ │ ├── MAINTAINERS.md │ │ ├── Makefile │ │ ├── NOTICE.txt │ │ ├── README.md │ │ ├── SECURITY.md │ │ ├── attributes │ │ │ └── attributes.go │ │ ├── backoff.go │ │ ├── backoff │ │ │ └── backoff.go │ │ ├── balancer │ │ │ ├── balancer.go │ │ │ ├── base │ │ │ │ ├── balancer.go │ │ │ │ └── base.go │ │ │ ├── grpclb │ │ │ │ └── state │ │ │ │ │ └── state.go │ │ │ └── roundrobin │ │ │ │ └── roundrobin.go │ │ ├── balancer_conn_wrappers.go │ │ ├── binarylog │ │ │ └── grpc_binarylog_v1 │ │ │ │ └── binarylog.pb.go │ │ ├── call.go │ │ ├── channelz │ │ │ └── channelz.go │ │ ├── clientconn.go │ │ ├── codec.go │ │ ├── codegen.sh │ │ ├── codes │ │ │ ├── code_string.go │ │ │ └── codes.go │ │ ├── connectivity │ │ │ └── connectivity.go │ │ ├── credentials │ │ │ ├── credentials.go │ │ │ ├── insecure │ │ │ │ └── insecure.go │ │ │ └── tls.go │ │ ├── dialoptions.go │ │ ├── doc.go │ │ ├── encoding │ │ │ ├── encoding.go │ │ │ └── proto │ │ │ │ └── proto.go │ │ ├── grpclog │ │ │ ├── component.go │ │ │ ├── grpclog.go │ │ │ ├── logger.go │ │ │ └── loggerv2.go │ │ ├── health │ │ │ ├── client.go │ │ │ ├── grpc_health_v1 │ │ │ │ ├── health.pb.go │ │ │ │ └── health_grpc.pb.go │ │ │ ├── logging.go │ │ │ └── server.go │ │ ├── interceptor.go │ │ ├── internal │ │ │ ├── backoff │ │ │ │ └── backoff.go │ │ │ ├── balancer │ │ │ │ └── gracefulswitch │ │ │ │ │ └── gracefulswitch.go │ │ │ ├── balancerload │ │ │ │ └── load.go │ │ │ ├── binarylog │ │ │ │ ├── binarylog.go │ │ │ │ ├── binarylog_testutil.go │ │ │ │ ├── env_config.go │ │ │ │ ├── method_logger.go │ │ │ │ └── sink.go │ │ │ ├── buffer │ │ │ │ └── unbounded.go │ │ │ ├── channelz │ │ │ │ ├── funcs.go │ │ │ │ ├── id.go │ │ │ │ ├── logging.go │ │ │ │ ├── types.go │ │ │ │ ├── types_linux.go │ │ │ │ ├── types_nonlinux.go │ │ │ │ ├── util_linux.go │ │ │ │ └── util_nonlinux.go │ │ │ ├── credentials │ │ │ │ ├── credentials.go │ │ │ │ ├── spiffe.go │ │ │ │ ├── syscallconn.go │ │ │ │ └── util.go │ │ │ ├── envconfig │ │ │ │ ├── envconfig.go │ │ │ │ └── xds.go │ │ │ ├── grpclog │ │ │ │ ├── grpclog.go │ │ │ │ └── prefixLogger.go │ │ │ ├── grpcrand │ │ │ │ └── grpcrand.go │ │ │ ├── grpcsync │ │ │ │ └── event.go │ │ │ ├── grpcutil │ │ │ │ ├── encode_duration.go │ │ │ │ ├── grpcutil.go │ │ │ │ ├── metadata.go │ │ │ │ ├── method.go │ │ │ │ └── regex.go │ │ │ ├── internal.go │ │ │ ├── metadata │ │ │ │ └── metadata.go │ │ │ ├── pretty │ │ │ │ └── pretty.go │ │ │ ├── resolver │ │ │ │ ├── config_selector.go │ │ │ │ ├── dns │ │ │ │ │ └── dns_resolver.go │ │ │ │ ├── passthrough │ │ │ │ │ └── passthrough.go │ │ │ │ └── unix │ │ │ │ │ └── unix.go │ │ │ ├── serviceconfig │ │ │ │ └── serviceconfig.go │ │ │ ├── status │ │ │ │ └── status.go │ │ │ ├── syscall │ │ │ │ ├── syscall_linux.go │ │ │ │ └── syscall_nonlinux.go │ │ │ ├── transport │ │ │ │ ├── bdp_estimator.go │ │ │ │ ├── controlbuf.go │ │ │ │ ├── defaults.go │ │ │ │ ├── flowcontrol.go │ │ │ │ ├── handler_server.go │ │ │ │ ├── http2_client.go │ │ │ │ ├── http2_server.go │ │ │ │ ├── http_util.go │ │ │ │ ├── networktype │ │ │ │ │ └── networktype.go │ │ │ │ ├── proxy.go │ │ │ │ └── transport.go │ │ │ └── xds_handshake_cluster.go │ │ ├── keepalive │ │ │ └── keepalive.go │ │ ├── metadata │ │ │ └── metadata.go │ │ ├── peer │ │ │ └── peer.go │ │ ├── picker_wrapper.go │ │ ├── pickfirst.go │ │ ├── preloader.go │ │ ├── reflection │ │ │ ├── README.md │ │ │ ├── grpc_reflection_v1alpha │ │ │ │ ├── reflection.pb.go │ │ │ │ ├── reflection.proto │ │ │ │ └── reflection_grpc.pb.go │ │ │ └── serverreflection.go │ │ ├── regenerate.sh │ │ ├── resolver │ │ │ ├── map.go │ │ │ └── resolver.go │ │ ├── resolver_conn_wrapper.go │ │ ├── rpc_util.go │ │ ├── server.go │ │ ├── service_config.go │ │ ├── serviceconfig │ │ │ └── serviceconfig.go │ │ ├── stats │ │ │ ├── handlers.go │ │ │ └── stats.go │ │ ├── status │ │ │ └── status.go │ │ ├── stream.go │ │ ├── tap │ │ │ └── tap.go │ │ ├── trace.go │ │ ├── version.go │ │ └── vet.sh │ └── protobuf │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── LICENSE │ │ ├── PATENTS │ │ ├── encoding │ │ ├── protojson │ │ │ ├── decode.go │ │ │ ├── doc.go │ │ │ ├── encode.go │ │ │ └── well_known_types.go │ │ ├── prototext │ │ │ ├── decode.go │ │ │ ├── doc.go │ │ │ └── encode.go │ │ └── protowire │ │ │ └── wire.go │ │ ├── internal │ │ ├── descfmt │ │ │ └── stringer.go │ │ ├── descopts │ │ │ └── options.go │ │ ├── detrand │ │ │ └── rand.go │ │ ├── encoding │ │ │ ├── defval │ │ │ │ └── default.go │ │ │ ├── json │ │ │ │ ├── decode.go │ │ │ │ ├── decode_number.go │ │ │ │ ├── decode_string.go │ │ │ │ ├── decode_token.go │ │ │ │ └── encode.go │ │ │ ├── messageset │ │ │ │ └── messageset.go │ │ │ ├── tag │ │ │ │ └── tag.go │ │ │ └── text │ │ │ │ ├── decode.go │ │ │ │ ├── decode_number.go │ │ │ │ ├── decode_string.go │ │ │ │ ├── decode_token.go │ │ │ │ ├── doc.go │ │ │ │ └── encode.go │ │ ├── errors │ │ │ ├── errors.go │ │ │ ├── is_go112.go │ │ │ └── is_go113.go │ │ ├── filedesc │ │ │ ├── build.go │ │ │ ├── desc.go │ │ │ ├── desc_init.go │ │ │ ├── desc_lazy.go │ │ │ ├── desc_list.go │ │ │ ├── desc_list_gen.go │ │ │ └── placeholder.go │ │ ├── filetype │ │ │ └── build.go │ │ ├── flags │ │ │ ├── flags.go │ │ │ ├── proto_legacy_disable.go │ │ │ └── proto_legacy_enable.go │ │ ├── genid │ │ │ ├── any_gen.go │ │ │ ├── api_gen.go │ │ │ ├── descriptor_gen.go │ │ │ ├── doc.go │ │ │ ├── duration_gen.go │ │ │ ├── empty_gen.go │ │ │ ├── field_mask_gen.go │ │ │ ├── goname.go │ │ │ ├── map_entry.go │ │ │ ├── source_context_gen.go │ │ │ ├── struct_gen.go │ │ │ ├── timestamp_gen.go │ │ │ ├── type_gen.go │ │ │ ├── wrappers.go │ │ │ └── wrappers_gen.go │ │ ├── impl │ │ │ ├── api_export.go │ │ │ ├── checkinit.go │ │ │ ├── codec_extension.go │ │ │ ├── codec_field.go │ │ │ ├── codec_gen.go │ │ │ ├── codec_map.go │ │ │ ├── codec_map_go111.go │ │ │ ├── codec_map_go112.go │ │ │ ├── codec_message.go │ │ │ ├── codec_messageset.go │ │ │ ├── codec_reflect.go │ │ │ ├── codec_tables.go │ │ │ ├── codec_unsafe.go │ │ │ ├── convert.go │ │ │ ├── convert_list.go │ │ │ ├── convert_map.go │ │ │ ├── decode.go │ │ │ ├── encode.go │ │ │ ├── enum.go │ │ │ ├── extension.go │ │ │ ├── legacy_enum.go │ │ │ ├── legacy_export.go │ │ │ ├── legacy_extension.go │ │ │ ├── legacy_file.go │ │ │ ├── legacy_message.go │ │ │ ├── merge.go │ │ │ ├── merge_gen.go │ │ │ ├── message.go │ │ │ ├── message_reflect.go │ │ │ ├── message_reflect_field.go │ │ │ ├── message_reflect_gen.go │ │ │ ├── pointer_reflect.go │ │ │ ├── pointer_unsafe.go │ │ │ ├── validate.go │ │ │ └── weak.go │ │ ├── order │ │ │ ├── order.go │ │ │ └── range.go │ │ ├── pragma │ │ │ └── pragma.go │ │ ├── set │ │ │ └── ints.go │ │ ├── strs │ │ │ ├── strings.go │ │ │ ├── strings_pure.go │ │ │ └── strings_unsafe.go │ │ └── version │ │ │ └── version.go │ │ ├── proto │ │ ├── checkinit.go │ │ ├── decode.go │ │ ├── decode_gen.go │ │ ├── doc.go │ │ ├── encode.go │ │ ├── encode_gen.go │ │ ├── equal.go │ │ ├── extension.go │ │ ├── merge.go │ │ ├── messageset.go │ │ ├── proto.go │ │ ├── proto_methods.go │ │ ├── proto_reflect.go │ │ ├── reset.go │ │ ├── size.go │ │ ├── size_gen.go │ │ └── wrappers.go │ │ ├── reflect │ │ ├── protodesc │ │ │ ├── desc.go │ │ │ ├── desc_init.go │ │ │ ├── desc_resolve.go │ │ │ ├── desc_validate.go │ │ │ └── proto.go │ │ ├── protoreflect │ │ │ ├── methods.go │ │ │ ├── proto.go │ │ │ ├── source.go │ │ │ ├── source_gen.go │ │ │ ├── type.go │ │ │ ├── value.go │ │ │ ├── value_pure.go │ │ │ ├── value_union.go │ │ │ └── value_unsafe.go │ │ └── protoregistry │ │ │ └── registry.go │ │ ├── runtime │ │ ├── protoiface │ │ │ ├── legacy.go │ │ │ └── methods.go │ │ └── protoimpl │ │ │ ├── impl.go │ │ │ └── version.go │ │ └── types │ │ ├── descriptorpb │ │ └── descriptor.pb.go │ │ └── known │ │ ├── anypb │ │ └── any.pb.go │ │ ├── durationpb │ │ └── duration.pb.go │ │ ├── emptypb │ │ └── empty.pb.go │ │ └── timestamppb │ │ └── timestamp.pb.go └── modules.txt └── website ├── docs ├── index.html.markdown └── r │ ├── statuspage_component.html.markdown │ ├── statuspage_component_group.html.markdown │ ├── statuspage_metrics.html.markdown │ └── statuspage_metrics_provider.html.markdown └── statuspage.erb /.gitconfig: -------------------------------------------------------------------------------- 1 | [safe] 2 | directory = /go/src/github.com/yannh/terraform-provider-statuspage 3 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.tf 2 | *.tfplan 3 | .terraform 4 | crash.log 5 | .envrc 6 | dist/ 7 | .idea/ 8 | -------------------------------------------------------------------------------- /bin/.gitignore: -------------------------------------------------------------------------------- 1 | terraform-provider-statuspage -------------------------------------------------------------------------------- /main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "github.com/hashicorp/terraform-plugin-sdk/v2/plugin" 5 | "github.com/yannh/terraform-provider-statuspage/statuspage" 6 | ) 7 | 8 | func main() { 9 | plugin.Serve(&plugin.ServeOpts{ 10 | ProviderFunc: statuspage.Provider, 11 | }) 12 | } 13 | -------------------------------------------------------------------------------- /statuspage/main.go: -------------------------------------------------------------------------------- 1 | package statuspage 2 | 3 | import ( 4 | "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" 5 | "github.com/hashicorp/terraform-plugin-sdk/v2/plugin" 6 | ) 7 | 8 | func main() { 9 | plugin.Serve(&plugin.ServeOpts{ 10 | ProviderFunc: func() *schema.Provider { 11 | return Provider() 12 | }, 13 | }) 14 | } 15 | -------------------------------------------------------------------------------- /statuspage/provider.go: -------------------------------------------------------------------------------- 1 | package statuspage 2 | 3 | import ( 4 | "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" 5 | sp "github.com/yannh/statuspage-go-sdk" 6 | ) 7 | 8 | func Provider() *schema.Provider { 9 | return &schema.Provider{ 10 | Schema: map[string]*schema.Schema{ 11 | "token": { 12 | Type: schema.TypeString, 13 | Required: true, 14 | DefaultFunc: schema.EnvDefaultFunc("STATUSPAGE_TOKEN", ""), 15 | }, 16 | }, 17 | ResourcesMap: map[string]*schema.Resource{ 18 | "statuspage_component": resourceComponent(), 19 | "statuspage_component_group": resourceComponentGroup(), 20 | "statuspage_metric": resourceMetric(), 21 | "statuspage_metrics_provider": resourceMetricsProvider(), 22 | }, 23 | ConfigureFunc: providerConfigure, 24 | } 25 | } 26 | 27 | func providerConfigure(d *schema.ResourceData) (interface{}, error) { 28 | return sp.NewClient(d.Get("token").(string)), nil 29 | } 30 | -------------------------------------------------------------------------------- /statuspage/utils.go: -------------------------------------------------------------------------------- 1 | package statuspage 2 | 3 | import "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" 4 | 5 | func getOptionalBool(d *schema.ResourceData, key string) *bool { 6 | if value, ok := d.GetOk(key); ok { 7 | b := value.(bool) 8 | return &b 9 | } 10 | return nil 11 | } 12 | 13 | func getOptionalFloat(d *schema.ResourceData, key string) *float64 { 14 | if value, ok := d.GetOk(key); ok { 15 | f := value.(float64) 16 | return &f 17 | } 18 | return nil 19 | } 20 | 21 | func getOptionalInt(d *schema.ResourceData, key string) *int { 22 | if value, exists := d.GetOk(key); exists { 23 | i := value.(int) 24 | return &i 25 | } 26 | return nil 27 | } 28 | 29 | func getOptionalString(d *schema.ResourceData, key string) *string { 30 | if value, exists := d.GetOk(key); exists { 31 | s := value.(string) 32 | return &s 33 | } 34 | return nil 35 | } 36 | -------------------------------------------------------------------------------- /terraform-registry-manifest.json: -------------------------------------------------------------------------------- 1 | { 2 | "version": 1, 3 | "metadata": { 4 | "protocol_versions": ["5.0"] 5 | } 6 | } 7 | -------------------------------------------------------------------------------- /vendor/github.com/agext/levenshtein/.gitignore: -------------------------------------------------------------------------------- 1 | # Ignore docs files 2 | _gh_pages 3 | _site 4 | 5 | # Ignore temporary files 6 | README.html 7 | coverage.out 8 | .tmp 9 | 10 | # Numerous always-ignore extensions 11 | *.diff 12 | *.err 13 | *.log 14 | *.orig 15 | *.rej 16 | *.swo 17 | *.swp 18 | *.vi 19 | *.zip 20 | *~ 21 | 22 | # OS or Editor folders 23 | ._* 24 | .cache 25 | .DS_Store 26 | .idea 27 | .project 28 | .settings 29 | .tmproj 30 | *.esproj 31 | *.sublime-project 32 | *.sublime-workspace 33 | nbproject 34 | Thumbs.db 35 | 36 | # Komodo 37 | .komodotools 38 | *.komodoproject 39 | 40 | # SCSS-Lint 41 | scss-lint-report.xml 42 | 43 | # grunt-contrib-sass cache 44 | .sass-cache 45 | 46 | # Jekyll metadata 47 | docs/.jekyll-metadata 48 | 49 | # Folders to ignore 50 | .build 51 | .test 52 | bower_components 53 | node_modules 54 | -------------------------------------------------------------------------------- /vendor/github.com/agext/levenshtein/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | sudo: false 3 | matrix: 4 | fast_finish: true 5 | include: 6 | - go: 1.14.x 7 | env: TEST_METHOD=goveralls 8 | - go: 1.13.x 9 | - go: 1.12.x 10 | - go: 1.11.x 11 | - go: 1.10.x 12 | - go: tip 13 | - go: 1.9.x 14 | - go: 1.8.x 15 | - go: 1.7.x 16 | - go: 1.6.x 17 | - go: 1.5.x 18 | allow_failures: 19 | - go: tip 20 | - go: 1.11.x 21 | - go: 1.10.x 22 | - go: 1.9.x 23 | - go: 1.8.x 24 | - go: 1.7.x 25 | - go: 1.6.x 26 | - go: 1.5.x 27 | script: ./test.sh $TEST_METHOD 28 | notifications: 29 | email: 30 | on_success: never 31 | -------------------------------------------------------------------------------- /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/agext/levenshtein/test.sh: -------------------------------------------------------------------------------- 1 | set -ev 2 | 3 | if [[ "$1" == "goveralls" ]]; then 4 | echo "Testing with goveralls..." 5 | go get github.com/mattn/goveralls 6 | $HOME/gopath/bin/goveralls -service=travis-ci 7 | else 8 | echo "Testing with go test..." 9 | go test -v ./... 10 | fi 11 | -------------------------------------------------------------------------------- /vendor/github.com/apparentlymart/go-textseg/v13/textseg/all_tokens.go: -------------------------------------------------------------------------------- 1 | package textseg 2 | 3 | import ( 4 | "bufio" 5 | "bytes" 6 | ) 7 | 8 | // AllTokens is a utility that uses a bufio.SplitFunc to produce a slice of 9 | // all of the recognized tokens in the given buffer. 10 | func AllTokens(buf []byte, splitFunc bufio.SplitFunc) ([][]byte, error) { 11 | scanner := bufio.NewScanner(bytes.NewReader(buf)) 12 | scanner.Split(splitFunc) 13 | var ret [][]byte 14 | for scanner.Scan() { 15 | ret = append(ret, scanner.Bytes()) 16 | } 17 | return ret, scanner.Err() 18 | } 19 | 20 | // TokenCount is a utility that uses a bufio.SplitFunc to count the number of 21 | // recognized tokens in the given buffer. 22 | func TokenCount(buf []byte, splitFunc bufio.SplitFunc) (int, error) { 23 | scanner := bufio.NewScanner(bytes.NewReader(buf)) 24 | scanner.Split(splitFunc) 25 | var ret int 26 | for scanner.Scan() { 27 | ret++ 28 | } 29 | return ret, scanner.Err() 30 | } 31 | -------------------------------------------------------------------------------- /vendor/github.com/apparentlymart/go-textseg/v13/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=https://www.unicode.org/Public/13.0.0/ucd/auxiliary/GraphemeBreakProperty.txt -m GraphemeCluster -p "Prepend,CR,LF,Control,Extend,Regional_Indicator,SpacingMark,L,V,T,LV,LVT,ZWJ" -o grapheme_clusters_table.rl 6 | //go:generate ruby unicode2ragel.rb --url=https://www.unicode.org/Public/13.0.0/ucd/emoji/emoji-data.txt -m Emoji -p "Extended_Pictographic" -o emoji_table.rl 7 | //go:generate ragel -Z grapheme_clusters.rl 8 | //go:generate gofmt -w grapheme_clusters.go 9 | -------------------------------------------------------------------------------- /vendor/github.com/apparentlymart/go-textseg/v13/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/davecgh/go-spew/LICENSE: -------------------------------------------------------------------------------- 1 | ISC License 2 | 3 | Copyright (c) 2012-2016 Dave Collins 4 | 5 | Permission to use, copy, modify, and/or 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/color_windows.go: -------------------------------------------------------------------------------- 1 | package color 2 | 3 | import ( 4 | "os" 5 | 6 | "golang.org/x/sys/windows" 7 | ) 8 | 9 | func init() { 10 | // Opt-in for ansi color support for current process. 11 | // https://learn.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences#output-sequences 12 | var outMode uint32 13 | out := windows.Handle(os.Stdout.Fd()) 14 | if err := windows.GetConsoleMode(out, &outMode); err != nil { 15 | return 16 | } 17 | outMode |= windows.ENABLE_PROCESSED_OUTPUT | windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING 18 | _ = windows.SetConsoleMode(out, outMode) 19 | } 20 | -------------------------------------------------------------------------------- /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/golang/protobuf/ptypes/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 ptypes provides functionality for interacting with well-known types. 6 | // 7 | // Deprecated: Well-known types have specialized functionality directly 8 | // injected into the generated packages for each message type. 9 | // See the deprecation notice for each function for the suggested alternative. 10 | package ptypes 11 | -------------------------------------------------------------------------------- /vendor/github.com/google/go-cmp/cmp/export_panic.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 | //go:build purego 6 | // +build purego 7 | 8 | package cmp 9 | 10 | import "reflect" 11 | 12 | const supportExporters = false 13 | 14 | func retrieveUnexportedField(reflect.Value, reflect.StructField, bool) reflect.Value { 15 | panic("no support for forcibly accessing unexported fields") 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/google/go-cmp/cmp/internal/diff/debug_disable.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 | //go:build !cmp_debug 6 | // +build !cmp_debug 7 | 8 | package diff 9 | 10 | var debug debugger 11 | 12 | type debugger struct{} 13 | 14 | func (debugger) Begin(_, _ int, f EqualFunc, _, _ *EditScript) EqualFunc { 15 | return f 16 | } 17 | func (debugger) Update() {} 18 | func (debugger) Finish() {} 19 | -------------------------------------------------------------------------------- /vendor/github.com/google/go-cmp/cmp/internal/flags/flags.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019, 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 flags 6 | 7 | // Deterministic controls whether the output of Diff should be deterministic. 8 | // This is only used for testing. 9 | var Deterministic bool 10 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-cty/cty/convert/conversion_capsule.go: -------------------------------------------------------------------------------- 1 | package convert 2 | 3 | import ( 4 | "github.com/hashicorp/go-cty/cty" 5 | ) 6 | 7 | func conversionToCapsule(inTy, outTy cty.Type, fn func(inTy cty.Type) func(cty.Value, cty.Path) (interface{}, error)) conversion { 8 | rawConv := fn(inTy) 9 | if rawConv == nil { 10 | return nil 11 | } 12 | 13 | return func(in cty.Value, path cty.Path) (cty.Value, error) { 14 | rawV, err := rawConv(in, path) 15 | if err != nil { 16 | return cty.NilVal, err 17 | } 18 | return cty.CapsuleVal(outTy, rawV), nil 19 | } 20 | } 21 | 22 | func conversionFromCapsule(inTy, outTy cty.Type, fn func(outTy cty.Type) func(interface{}, cty.Path) (cty.Value, error)) conversion { 23 | rawConv := fn(outTy) 24 | if rawConv == nil { 25 | return nil 26 | } 27 | 28 | return func(in cty.Value, path cty.Path) (cty.Value, error) { 29 | return rawConv(in.EncapsulatedValue(), path) 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-cty/cty/convert/doc.go: -------------------------------------------------------------------------------- 1 | // Package convert contains some routines for converting between cty types. 2 | // The intent of providing this package is to encourage applications using 3 | // cty to have consistent type conversion behavior for maximal interoperability 4 | // when Values pass from one application to another. 5 | // 6 | // The conversions are categorized into two categories. "Safe" conversions are 7 | // ones that are guaranteed to succeed if given a non-null value of the 8 | // appropriate source type. "Unsafe" conversions, on the other hand, are valid 9 | // for only a subset of input values, and thus may fail with an error when 10 | // called for values outside of that valid subset. 11 | // 12 | // The functions whose names end in Unsafe support all of the conversions that 13 | // are supported by the corresponding functions whose names do not have that 14 | // suffix, and then additional unsafe conversions as well. 15 | package convert 16 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/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/hashicorp/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/hashicorp/go-cty/cty/json/type.go: -------------------------------------------------------------------------------- 1 | package json 2 | 3 | import ( 4 | "github.com/hashicorp/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/hashicorp/go-cty/cty/msgpack/doc.go: -------------------------------------------------------------------------------- 1 | // Package msgpack provides functions for serializing cty values in the 2 | // msgpack encoding, and decoding them again. 3 | // 4 | // If the same type information is provided both at encoding and decoding time 5 | // then values can be round-tripped without loss, except for capsule types 6 | // which are not currently supported. 7 | // 8 | // If any unknown values are passed to Marshal then they will be represented 9 | // using a msgpack extension with type code zero, which is understood by 10 | // the Unmarshal function within this package but will not be understood by 11 | // a generic (non-cty-aware) msgpack decoder. Ensure that no unknown values 12 | // are used if interoperability with other msgpack implementations is 13 | // required. 14 | package msgpack 15 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-cty/cty/msgpack/dynamic.go: -------------------------------------------------------------------------------- 1 | package msgpack 2 | 3 | import ( 4 | "bytes" 5 | 6 | "github.com/hashicorp/go-cty/cty" 7 | "github.com/vmihailenco/msgpack" 8 | ) 9 | 10 | type dynamicVal struct { 11 | Value cty.Value 12 | Path cty.Path 13 | } 14 | 15 | func (dv *dynamicVal) MarshalMsgpack() ([]byte, error) { 16 | // Rather than defining a msgpack-specific serialization of types, 17 | // instead we use the existing JSON serialization. 18 | typeJSON, err := dv.Value.Type().MarshalJSON() 19 | if err != nil { 20 | return nil, dv.Path.NewErrorf("failed to serialize type: %s", err) 21 | } 22 | var buf bytes.Buffer 23 | enc := msgpack.NewEncoder(&buf) 24 | enc.EncodeArrayLen(2) 25 | enc.EncodeBytes(typeJSON) 26 | err = marshal(dv.Value, dv.Value.Type(), dv.Path, enc) 27 | if err != nil { 28 | return nil, err 29 | } 30 | return buf.Bytes(), nil 31 | } 32 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-cty/cty/msgpack/infinity.go: -------------------------------------------------------------------------------- 1 | package msgpack 2 | 3 | import ( 4 | "math" 5 | ) 6 | 7 | var negativeInfinity = math.Inf(-1) 8 | var positiveInfinity = math.Inf(1) 9 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-cty/cty/msgpack/unknown.go: -------------------------------------------------------------------------------- 1 | package msgpack 2 | 3 | type unknownType struct{} 4 | 5 | var unknownVal = unknownType{} 6 | 7 | // unknownValBytes is the raw bytes of the msgpack fixext1 value we 8 | // write to represent an unknown value. It's an extension value of 9 | // type zero whose value is irrelevant. Since it's irrelevant, we 10 | // set it to a single byte whose value is also zero, since that's 11 | // the most compact possible representation. 12 | var unknownValBytes = []byte{0xd4, 0, 0} 13 | 14 | func (uv unknownType) MarshalMsgpack() ([]byte, error) { 15 | return unknownValBytes, nil 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/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/hashicorp/go-cty/cty/set/iterator.go: -------------------------------------------------------------------------------- 1 | package set 2 | 3 | type Iterator struct { 4 | vals []interface{} 5 | idx int 6 | } 7 | 8 | func (it *Iterator) Value() interface{} { 9 | return it.vals[it.idx] 10 | } 11 | 12 | func (it *Iterator) Next() bool { 13 | it.idx++ 14 | return it.idx < len(it.vals) 15 | } 16 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-hclog/.gitignore: -------------------------------------------------------------------------------- 1 | .idea* -------------------------------------------------------------------------------- /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\t* %s\n\n", 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\t%s\n\n", 26 | len(es), strings.Join(points, "\n\t")) 27 | } 28 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-multierror/group.go: -------------------------------------------------------------------------------- 1 | package multierror 2 | 3 | import "sync" 4 | 5 | // Group is a collection of goroutines which return errors that need to be 6 | // coalesced. 7 | type Group struct { 8 | mutex sync.Mutex 9 | err *Error 10 | wg sync.WaitGroup 11 | } 12 | 13 | // Go calls the given function in a new goroutine. 14 | // 15 | // If the function returns an error it is added to the group multierror which 16 | // is returned by Wait. 17 | func (g *Group) Go(f func() error) { 18 | g.wg.Add(1) 19 | 20 | go func() { 21 | defer g.wg.Done() 22 | 23 | if err := f(); err != nil { 24 | g.mutex.Lock() 25 | g.err = Append(g.err, err) 26 | g.mutex.Unlock() 27 | } 28 | }() 29 | } 30 | 31 | // Wait blocks until all function calls from the Go method have returned, then 32 | // returns the multierror. 33 | func (g *Group) Wait() *Error { 34 | g.wg.Wait() 35 | g.mutex.Lock() 36 | defer g.mutex.Unlock() 37 | return g.err 38 | } 39 | -------------------------------------------------------------------------------- /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 | .idea 3 | -------------------------------------------------------------------------------- /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_controller.go: -------------------------------------------------------------------------------- 1 | package plugin 2 | 3 | import ( 4 | "context" 5 | 6 | "github.com/hashicorp/go-plugin/internal/plugin" 7 | ) 8 | 9 | // GRPCControllerServer handles shutdown calls to terminate the server when the 10 | // plugin client is closed. 11 | type grpcControllerServer struct { 12 | server *GRPCServer 13 | } 14 | 15 | // Shutdown stops the grpc server. It first will attempt a graceful stop, then a 16 | // full stop on the server. 17 | func (s *grpcControllerServer) Shutdown(ctx context.Context, _ *plugin.Empty) (*plugin.Empty, error) { 18 | resp := &plugin.Empty{} 19 | 20 | // TODO: figure out why GracefullStop doesn't work. 21 | s.server.Stop() 22 | return resp, nil 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-plugin/internal/plugin/gen.go: -------------------------------------------------------------------------------- 1 | //go:generate protoc -I ./ ./grpc_broker.proto ./grpc_controller.proto ./grpc_stdio.proto --go_out=plugins=grpc:. 2 | 3 | package plugin 4 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-plugin/internal/plugin/grpc_broker.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | package plugin; 3 | option go_package = "plugin"; 4 | 5 | message ConnInfo { 6 | uint32 service_id = 1; 7 | string network = 2; 8 | string address = 3; 9 | } 10 | 11 | service GRPCBroker { 12 | rpc StartStream(stream ConnInfo) returns (stream ConnInfo); 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-plugin/internal/plugin/grpc_controller.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | package plugin; 3 | option go_package = "plugin"; 4 | 5 | message Empty { 6 | } 7 | 8 | // The GRPCController is responsible for telling the plugin server to shutdown. 9 | service GRPCController { 10 | rpc Shutdown(Empty) returns (Empty); 11 | } 12 | -------------------------------------------------------------------------------- /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 | //go:build !windows 2 | // +build !windows 3 | 4 | package plugin 5 | 6 | import ( 7 | "os" 8 | "syscall" 9 | ) 10 | 11 | // _pidAlive tests whether a process is alive or not by sending it Signal 0, 12 | // since Go otherwise has no way to test this. 13 | func _pidAlive(pid int) bool { 14 | proc, err := os.FindProcess(pid) 15 | if err == nil { 16 | err = proc.Signal(syscall.Signal(0)) 17 | } 18 | 19 | return err == nil 20 | } 21 | -------------------------------------------------------------------------------- /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 | defer syscall.CloseHandle(h) 23 | 24 | var ec uint32 25 | if e := syscall.GetExitCodeProcess(h, &ec); e != nil { 26 | return false 27 | } 28 | 29 | return ec == exit_STILL_ACTIVE 30 | } 31 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-plugin/server_mux.go: -------------------------------------------------------------------------------- 1 | package plugin 2 | 3 | import ( 4 | "fmt" 5 | "os" 6 | ) 7 | 8 | // ServeMuxMap is the type that is used to configure ServeMux 9 | type ServeMuxMap map[string]*ServeConfig 10 | 11 | // ServeMux is like Serve, but serves multiple types of plugins determined 12 | // by the argument given on the command-line. 13 | // 14 | // This command doesn't return until the plugin is done being executed. Any 15 | // errors are logged or output to stderr. 16 | func ServeMux(m ServeMuxMap) { 17 | if len(os.Args) != 2 { 18 | fmt.Fprintf(os.Stderr, 19 | "Invoked improperly. This is an internal command that shouldn't\n"+ 20 | "be manually invoked.\n") 21 | os.Exit(1) 22 | } 23 | 24 | opts, ok := m[os.Args[1]] 25 | if !ok { 26 | fmt.Fprintf(os.Stderr, "Unknown plugin: %s\n", os.Args[1]) 27 | os.Exit(1) 28 | } 29 | 30 | Serve(opts) 31 | } 32 | -------------------------------------------------------------------------------- /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-retryablehttp/.gitignore: -------------------------------------------------------------------------------- 1 | .idea/ 2 | *.iml 3 | *.test 4 | .vscode/ -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-retryablehttp/.go-version: -------------------------------------------------------------------------------- 1 | 1.22.2 2 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-retryablehttp/CODEOWNERS: -------------------------------------------------------------------------------- 1 | * @hashicorp/go-retryablehttp-maintainers 2 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-retryablehttp/Makefile: -------------------------------------------------------------------------------- 1 | default: test 2 | 3 | test: 4 | go vet ./... 5 | go test -v -race ./... 6 | 7 | updatedeps: 8 | go get -f -t -u ./... 9 | go get -f -u ./... 10 | 11 | .PHONY: default test updatedeps 12 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-retryablehttp/cert_error_go119.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) HashiCorp, Inc. 2 | // SPDX-License-Identifier: MPL-2.0 3 | 4 | //go:build !go1.20 5 | // +build !go1.20 6 | 7 | package retryablehttp 8 | 9 | import "crypto/x509" 10 | 11 | func isCertError(err error) bool { 12 | _, ok := err.(x509.UnknownAuthorityError) 13 | return ok 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/go-retryablehttp/cert_error_go120.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) HashiCorp, Inc. 2 | // SPDX-License-Identifier: MPL-2.0 3 | 4 | //go:build go1.20 5 | // +build go1.20 6 | 7 | package retryablehttp 8 | 9 | import "crypto/tls" 10 | 11 | func isCertError(err error) bool { 12 | _, ok := err.(*tls.CertificateVerificationError) 13 | return ok 14 | } 15 | -------------------------------------------------------------------------------- /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/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/hc-install/.go-version: -------------------------------------------------------------------------------- 1 | 1.17.3 2 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hc-install/.goreleaser.yml: -------------------------------------------------------------------------------- 1 | project_name: tfinstall 2 | builds: 3 | - env: 4 | - CGO_ENABLED=0 5 | main: ./cmd/hcinstall/main.go 6 | mod_timestamp: '{{ .CommitTimestamp }}' 7 | id: "tfinstall" 8 | binary: tfinstall 9 | flags: 10 | - -trimpath 11 | ldflags: 12 | - '-s -w -X main.version={{.Version}} -X main.commit={{.Commit}}' 13 | goos: 14 | - linux 15 | - darwin 16 | - windows 17 | goarch: 18 | - amd64 19 | - arm 20 | - arm64 21 | archives: 22 | - files: [] 23 | format: zip 24 | name_template: '{{ .ProjectName }}_{{ .Version }}_{{ .Os }}_{{ .Arch }}' 25 | checksum: 26 | name_template: '{{ .ProjectName }}_{{ .Version }}_SHA256SUMS' 27 | algorithm: sha256 28 | changelog: 29 | skip: true 30 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hc-install/errors/errors.go: -------------------------------------------------------------------------------- 1 | package errors 2 | 3 | type skippableErr struct { 4 | Err error 5 | } 6 | 7 | func (e skippableErr) Error() string { 8 | return e.Err.Error() 9 | } 10 | 11 | func SkippableErr(err error) skippableErr { 12 | return skippableErr{Err: err} 13 | } 14 | 15 | func IsErrorSkippable(err error) bool { 16 | _, ok := err.(skippableErr) 17 | return ok 18 | } 19 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hc-install/fs/fs.go: -------------------------------------------------------------------------------- 1 | package fs 2 | 3 | import ( 4 | "io/ioutil" 5 | "log" 6 | "time" 7 | ) 8 | 9 | var ( 10 | defaultTimeout = 10 * time.Second 11 | discardLogger = log.New(ioutil.Discard, "", 0) 12 | ) 13 | 14 | type fileCheckFunc func(path string) error 15 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hc-install/internal/build/go_is_installed.go: -------------------------------------------------------------------------------- 1 | package build 2 | 3 | import ( 4 | "context" 5 | "fmt" 6 | 7 | "github.com/hashicorp/go-version" 8 | ) 9 | 10 | // GoIsInstalled represents a checker of whether Go is installed locally 11 | type GoIsInstalled struct { 12 | RequiredVersion version.Constraints 13 | } 14 | 15 | // Check checks whether any Go version is installed locally 16 | func (gii *GoIsInstalled) Check(ctx context.Context) error { 17 | goVersion, err := GetGoVersion(ctx) 18 | if err != nil { 19 | return err 20 | } 21 | 22 | if gii.RequiredVersion != nil && !gii.RequiredVersion.Check(goVersion) { 23 | return fmt.Errorf("go %s required (%s available)", 24 | gii.RequiredVersion, goVersion) 25 | } 26 | 27 | return nil 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hc-install/internal/src/src.go: -------------------------------------------------------------------------------- 1 | package src 2 | 3 | type InstallSrcSigil struct{} 4 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hc-install/internal/validators/validators.go: -------------------------------------------------------------------------------- 1 | package validators 2 | 3 | import "regexp" 4 | 5 | var ( 6 | productNameRe = regexp.MustCompile(`^[a-z0-9-]+$`) 7 | binaryNameRe = regexp.MustCompile(`^[a-zA-Z0-9-_.]+$`) 8 | ) 9 | 10 | // IsProductNameValid provides early user-facing validation of a product name 11 | func IsProductNameValid(productName string) bool { 12 | return productNameRe.MatchString(productName) 13 | } 14 | 15 | // IsBinaryNameValid provides early user-facing validation of binary name 16 | func IsBinaryNameValid(binaryName string) bool { 17 | return binaryNameRe.MatchString(binaryName) 18 | } 19 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hc-install/internal/version/version.go: -------------------------------------------------------------------------------- 1 | package version 2 | 3 | const version = "0.1.0" 4 | 5 | // ModuleVersion returns the current version of the github.com/hashicorp/hc-install Go module. 6 | // This is a function to allow for future possible enhancement using debug.BuildInfo. 7 | func ModuleVersion() string { 8 | return version 9 | } 10 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hc-install/releases/releases.go: -------------------------------------------------------------------------------- 1 | package releases 2 | 3 | import ( 4 | "io/ioutil" 5 | "log" 6 | "time" 7 | ) 8 | 9 | var ( 10 | defaultInstallTimeout = 30 * time.Second 11 | defaultListTimeout = 10 * time.Second 12 | discardLogger = log.New(ioutil.Discard, "", 0) 13 | ) 14 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hc-install/src/src.go: -------------------------------------------------------------------------------- 1 | package src 2 | 3 | import ( 4 | "context" 5 | "log" 6 | 7 | isrc "github.com/hashicorp/hc-install/internal/src" 8 | ) 9 | 10 | // Source represents an installer, finder, or builder 11 | type Source interface { 12 | IsSourceImpl() isrc.InstallSrcSigil 13 | } 14 | 15 | type Installable interface { 16 | Source 17 | Install(ctx context.Context) (string, error) 18 | } 19 | 20 | type Findable interface { 21 | Source 22 | Find(ctx context.Context) (string, error) 23 | } 24 | 25 | type Buildable interface { 26 | Source 27 | Build(ctx context.Context) (string, error) 28 | } 29 | 30 | type Validatable interface { 31 | Source 32 | Validate() error 33 | } 34 | 35 | type Removable interface { 36 | Source 37 | Remove(ctx context.Context) error 38 | } 39 | 40 | type LoggerSettable interface { 41 | SetLogger(logger *log.Logger) 42 | } 43 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl/v2/didyoumean.go: -------------------------------------------------------------------------------- 1 | package hcl 2 | 3 | import ( 4 | "github.com/agext/levenshtein" 5 | ) 6 | 7 | // nameSuggestion tries to find a name from the given slice of suggested names 8 | // that is close to the given name and returns it if found. If no suggestion 9 | // is close enough, returns the empty string. 10 | // 11 | // The suggestions are tried in order, so earlier suggestions take precedence 12 | // if the given string is similar to two or more suggestions. 13 | // 14 | // This function is intended to be used with a relatively-small number of 15 | // suggestions. It's not optimized for hundreds or thousands of them. 16 | func nameSuggestion(given string, suggestions []string) string { 17 | for _, suggestion := range suggestions { 18 | dist := levenshtein.Distance(given, suggestion, nil) 19 | if dist < 3 { // threshold determined experimentally 20 | return suggestion 21 | } 22 | } 23 | return "" 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl/v2/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/hcl/v2/hclsyntax/diagnostics.go: -------------------------------------------------------------------------------- 1 | package hclsyntax 2 | 3 | import ( 4 | "github.com/hashicorp/hcl/v2" 5 | ) 6 | 7 | // setDiagEvalContext is an internal helper that will impose a particular 8 | // EvalContext on a set of diagnostics in-place, for any diagnostic that 9 | // does not already have an EvalContext set. 10 | // 11 | // We generally expect diagnostics to be immutable, but this is safe to use 12 | // on any Diagnostics where none of the contained Diagnostic objects have yet 13 | // been seen by a caller. Its purpose is to apply additional context to a 14 | // set of diagnostics produced by a "deeper" component as the stack unwinds 15 | // during expression evaluation. 16 | func setDiagEvalContext(diags hcl.Diagnostics, expr hcl.Expression, ctx *hcl.EvalContext) { 17 | for _, diag := range diags { 18 | if diag.Expression == nil { 19 | diag.Expression = expr 20 | diag.EvalContext = ctx 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl/v2/hclsyntax/didyoumean.go: -------------------------------------------------------------------------------- 1 | package hclsyntax 2 | 3 | import ( 4 | "github.com/agext/levenshtein" 5 | ) 6 | 7 | // nameSuggestion tries to find a name from the given slice of suggested names 8 | // that is close to the given name and returns it if found. If no suggestion 9 | // is close enough, returns the empty string. 10 | // 11 | // The suggestions are tried in order, so earlier suggestions take precedence 12 | // if the given string is similar to two or more suggestions. 13 | // 14 | // This function is intended to be used with a relatively-small number of 15 | // suggestions. It's not optimized for hundreds or thousands of them. 16 | func nameSuggestion(given string, suggestions []string) string { 17 | for _, suggestion := range suggestions { 18 | dist := levenshtein.Distance(given, suggestion, nil) 19 | if dist < 3 { // threshold determined experimentally 20 | return suggestion 21 | } 22 | } 23 | return "" 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl/v2/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/hcl/v2/hclsyntax/file.go: -------------------------------------------------------------------------------- 1 | package hclsyntax 2 | 3 | import ( 4 | "github.com/hashicorp/hcl/v2" 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/hcl/v2/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/hcl/v2/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/hcl/v2/hclsyntax/node.go: -------------------------------------------------------------------------------- 1 | package hclsyntax 2 | 3 | import ( 4 | "github.com/hashicorp/hcl/v2" 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) 23 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/hcl/v2/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/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-exec/internal/version/version.go: -------------------------------------------------------------------------------- 1 | package version 2 | 3 | const version = "0.16.1" 4 | 5 | // ModuleVersion returns the current version of the github.com/hashicorp/terraform-exec Go module. 6 | // This is a function to allow for future possible enhancement using debug.BuildInfo. 7 | func ModuleVersion() string { 8 | return version 9 | } 10 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-exec/tfexec/doc.go: -------------------------------------------------------------------------------- 1 | // Package tfexec exposes functionality for constructing and running Terraform 2 | // CLI commands. Structured return values use the data types defined in the 3 | // github.com/hashicorp/terraform-json package. 4 | package tfexec 5 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-exec/tfexec/providers_schema.go: -------------------------------------------------------------------------------- 1 | package tfexec 2 | 3 | import ( 4 | "context" 5 | "os/exec" 6 | 7 | tfjson "github.com/hashicorp/terraform-json" 8 | ) 9 | 10 | // ProvidersSchema represents the terraform providers schema -json subcommand. 11 | func (tf *Terraform) ProvidersSchema(ctx context.Context) (*tfjson.ProviderSchemas, error) { 12 | schemaCmd := tf.providersSchemaCmd(ctx) 13 | 14 | var ret tfjson.ProviderSchemas 15 | err := tf.runTerraformCmdJSON(ctx, schemaCmd, &ret) 16 | if err != nil { 17 | return nil, err 18 | } 19 | 20 | err = ret.Validate() 21 | if err != nil { 22 | return nil, err 23 | } 24 | 25 | return &ret, nil 26 | } 27 | 28 | func (tf *Terraform) providersSchemaCmd(ctx context.Context, args ...string) *exec.Cmd { 29 | allArgs := []string{"providers", "schema", "-json", "-no-color"} 30 | allArgs = append(allArgs, args...) 31 | 32 | return tf.buildTerraformCmd(ctx, nil, allArgs...) 33 | } 34 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-exec/tfexec/workspace_select.go: -------------------------------------------------------------------------------- 1 | package tfexec 2 | 3 | import "context" 4 | 5 | // WorkspaceSelect represents the workspace select subcommand to the Terraform CLI. 6 | func (tf *Terraform) WorkspaceSelect(ctx context.Context, workspace string) error { 7 | // TODO: [DIR] param option 8 | 9 | return tf.runTerraformCmd(ctx, tf.buildTerraformCmd(ctx, nil, "workspace", "select", "-no-color", workspace)) 10 | } 11 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-json/.gitignore: -------------------------------------------------------------------------------- 1 | .terraform 2 | plan.tfplan 3 | terraform.tfstate.backup 4 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-json/.go-version: -------------------------------------------------------------------------------- 1 | 1.16 2 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-json/Makefile: -------------------------------------------------------------------------------- 1 | GOTOOLS = \ 2 | gotest.tools/gotestsum@latest 3 | 4 | test: tools 5 | gotestsum --format=short-verbose $(TEST) $(TESTARGS) 6 | 7 | generate: 8 | cd testdata && make generate 9 | 10 | modules: 11 | go mod download && go mod verify 12 | 13 | test-circle: 14 | mkdir -p test-results/terraform-json 15 | gotestsum --format=short-verbose --junitfile test-results/terraform-json/results.xml 16 | 17 | tools: 18 | @echo $(GOTOOLS) | xargs -t -n1 go install 19 | go mod tidy 20 | 21 | .PHONY: test generate modules test-circle tools 22 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-json/tfjson.go: -------------------------------------------------------------------------------- 1 | // Package tfjson is a de-coupled helper library containing types for 2 | // the plan format output by "terraform show -json" command. This 3 | // command is designed for the export of Terraform plan data in 4 | // a format that can be easily processed by tools unrelated to 5 | // Terraform. 6 | // 7 | // This format is stable and should be used over the binary plan data 8 | // whenever possible. 9 | package tfjson 10 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-json/version.go: -------------------------------------------------------------------------------- 1 | package tfjson 2 | 3 | // VersionOutput represents output from the version -json command 4 | // added in v0.13 5 | type VersionOutput struct { 6 | Version string `json:"terraform_version"` 7 | Revision string `json:"terraform_revision"` 8 | Platform string `json:"platform,omitempty"` 9 | ProviderSelections map[string]string `json:"provider_selections"` 10 | Outdated bool `json:"terraform_outdated"` 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-go/internal/logging/doc.go: -------------------------------------------------------------------------------- 1 | // Package logging contains shared environment variable and log functionality. 2 | package logging 3 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-go/internal/logging/protocol.go: -------------------------------------------------------------------------------- 1 | package logging 2 | 3 | import ( 4 | "context" 5 | 6 | "github.com/hashicorp/terraform-plugin-log/tfsdklog" 7 | ) 8 | 9 | const ( 10 | // SubsystemProto is the tfsdklog subsystem name for protocol logging. 11 | SubsystemProto = "proto" 12 | ) 13 | 14 | // ProtocolError emits a protocol subsystem log at ERROR level. 15 | func ProtocolError(ctx context.Context, msg string, additionalFields ...map[string]interface{}) { 16 | tfsdklog.SubsystemError(ctx, SubsystemProto, msg, additionalFields...) 17 | } 18 | 19 | // ProtocolTrace emits a protocol subsystem log at TRACE level. 20 | func ProtocolTrace(ctx context.Context, msg string, additionalFields ...map[string]interface{}) { 21 | tfsdklog.SubsystemTrace(ctx, SubsystemProto, msg, additionalFields...) 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-go/internal/logging/provider.go: -------------------------------------------------------------------------------- 1 | package logging 2 | 3 | import ( 4 | "log" 5 | "strings" 6 | 7 | tfaddr "github.com/hashicorp/terraform-registry-address" 8 | ) 9 | 10 | func ProviderLoggerName(providerAddress string) string { 11 | provider, err := tfaddr.ParseRawProviderSourceString(providerAddress) 12 | 13 | if err != nil { 14 | log.Printf("[ERROR] Error parsing provider name %q: %s", providerAddress, err) 15 | return "" 16 | } 17 | 18 | return strings.ReplaceAll(provider.Type, "-", "_") 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-go/tfprotov5/internal/fromproto/state.go: -------------------------------------------------------------------------------- 1 | package fromproto 2 | 3 | import ( 4 | "github.com/hashicorp/terraform-plugin-go/tfprotov5" 5 | "github.com/hashicorp/terraform-plugin-go/tfprotov5/internal/tfplugin5" 6 | ) 7 | 8 | func RawState(in *tfplugin5.RawState) *tfprotov5.RawState { 9 | return &tfprotov5.RawState{ 10 | JSON: in.Json, 11 | Flatmap: in.Flatmap, 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-go/tfprotov5/internal/fromproto/string_kind.go: -------------------------------------------------------------------------------- 1 | package fromproto 2 | 3 | import ( 4 | "github.com/hashicorp/terraform-plugin-go/tfprotov5" 5 | "github.com/hashicorp/terraform-plugin-go/tfprotov5/internal/tfplugin5" 6 | ) 7 | 8 | func StringKind(in tfplugin5.StringKind) tfprotov5.StringKind { 9 | return tfprotov5.StringKind(in) 10 | } 11 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-go/tfprotov5/internal/fromproto/types.go: -------------------------------------------------------------------------------- 1 | package fromproto 2 | 3 | import ( 4 | "github.com/hashicorp/terraform-plugin-go/tfprotov5" 5 | "github.com/hashicorp/terraform-plugin-go/tfprotov5/internal/tfplugin5" 6 | ) 7 | 8 | func DynamicValue(in *tfplugin5.DynamicValue) *tfprotov5.DynamicValue { 9 | return &tfprotov5.DynamicValue{ 10 | MsgPack: in.Msgpack, 11 | JSON: in.Json, 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-go/tfprotov5/internal/toproto/state.go: -------------------------------------------------------------------------------- 1 | package toproto 2 | 3 | import ( 4 | "github.com/hashicorp/terraform-plugin-go/tfprotov5" 5 | "github.com/hashicorp/terraform-plugin-go/tfprotov5/internal/tfplugin5" 6 | ) 7 | 8 | func RawState(in *tfprotov5.RawState) *tfplugin5.RawState { 9 | return &tfplugin5.RawState{ 10 | Json: in.JSON, 11 | Flatmap: in.Flatmap, 12 | } 13 | } 14 | 15 | // we have to say this next thing to get golint to stop yelling at us about the 16 | // underscores in the function names. We want the function names to match 17 | // actually-generated code, so it feels like fair play. It's just a shame we 18 | // lose golint for the entire file. 19 | // 20 | // This file is not actually generated. You can edit it. Ignore this next line. 21 | // Code generated by hand ignore this next bit DO NOT EDIT. 22 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-go/tfprotov5/internal/toproto/string_kind.go: -------------------------------------------------------------------------------- 1 | package toproto 2 | 3 | import ( 4 | "github.com/hashicorp/terraform-plugin-go/tfprotov5" 5 | "github.com/hashicorp/terraform-plugin-go/tfprotov5/internal/tfplugin5" 6 | ) 7 | 8 | func StringKind(in tfprotov5.StringKind) tfplugin5.StringKind { 9 | return tfplugin5.StringKind(in) 10 | } 11 | 12 | // we have to say this next thing to get golint to stop yelling at us about the 13 | // underscores in the function names. We want the function names to match 14 | // actually-generated code, so it feels like fair play. It's just a shame we 15 | // lose golint for the entire file. 16 | // 17 | // This file is not actually generated. You can edit it. Ignore this next line. 18 | // Code generated by hand ignore this next bit DO NOT EDIT. 19 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-go/tfprotov5/string_kind.go: -------------------------------------------------------------------------------- 1 | package tfprotov5 2 | 3 | const ( 4 | // StringKindPlain indicates a string is plaintext, and should be 5 | // interpreted as having no formatting information. 6 | StringKindPlain StringKind = 0 7 | 8 | // StringKindMarkdown indicates a string is markdown-formatted, and 9 | // should be rendered using a Markdown renderer to correctly display 10 | // its formatting. 11 | StringKindMarkdown StringKind = 1 12 | ) 13 | 14 | // StringKind indicates a formatting or encoding scheme for a string. 15 | type StringKind int32 16 | 17 | func (s StringKind) String() string { 18 | switch s { 19 | case 0: 20 | return "PLAIN" 21 | case 1: 22 | return "MARKDOWN" 23 | } 24 | return "UNKNOWN" 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-go/tfprotov5/tf5server/doc.go: -------------------------------------------------------------------------------- 1 | // Package tf5server implements a server implementation to run 2 | // tfprotov5.ProviderServers as gRPC servers. 3 | // 4 | // Providers will likely be calling tf5server.Serve from their main function to 5 | // start the server so Terraform can connect to it. 6 | package tf5server 7 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-go/tfprotov6/internal/fromproto/state.go: -------------------------------------------------------------------------------- 1 | package fromproto 2 | 3 | import ( 4 | "github.com/hashicorp/terraform-plugin-go/tfprotov6" 5 | "github.com/hashicorp/terraform-plugin-go/tfprotov6/internal/tfplugin6" 6 | ) 7 | 8 | func RawState(in *tfplugin6.RawState) *tfprotov6.RawState { 9 | return &tfprotov6.RawState{ 10 | JSON: in.Json, 11 | Flatmap: in.Flatmap, 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-go/tfprotov6/internal/fromproto/string_kind.go: -------------------------------------------------------------------------------- 1 | package fromproto 2 | 3 | import ( 4 | "github.com/hashicorp/terraform-plugin-go/tfprotov6" 5 | "github.com/hashicorp/terraform-plugin-go/tfprotov6/internal/tfplugin6" 6 | ) 7 | 8 | func StringKind(in tfplugin6.StringKind) tfprotov6.StringKind { 9 | return tfprotov6.StringKind(in) 10 | } 11 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-go/tfprotov6/internal/fromproto/types.go: -------------------------------------------------------------------------------- 1 | package fromproto 2 | 3 | import ( 4 | "github.com/hashicorp/terraform-plugin-go/tfprotov6" 5 | "github.com/hashicorp/terraform-plugin-go/tfprotov6/internal/tfplugin6" 6 | ) 7 | 8 | func DynamicValue(in *tfplugin6.DynamicValue) *tfprotov6.DynamicValue { 9 | return &tfprotov6.DynamicValue{ 10 | MsgPack: in.Msgpack, 11 | JSON: in.Json, 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-go/tfprotov6/internal/toproto/state.go: -------------------------------------------------------------------------------- 1 | package toproto 2 | 3 | import ( 4 | "github.com/hashicorp/terraform-plugin-go/tfprotov6" 5 | "github.com/hashicorp/terraform-plugin-go/tfprotov6/internal/tfplugin6" 6 | ) 7 | 8 | func RawState(in *tfprotov6.RawState) *tfplugin6.RawState { 9 | return &tfplugin6.RawState{ 10 | Json: in.JSON, 11 | Flatmap: in.Flatmap, 12 | } 13 | } 14 | 15 | // we have to say this next thing to get golint to stop yelling at us about the 16 | // underscores in the function names. We want the function names to match 17 | // actually-generated code, so it feels like fair play. It's just a shame we 18 | // lose golint for the entire file. 19 | // 20 | // This file is not actually generated. You can edit it. Ignore this next line. 21 | // Code generated by hand ignore this next bit DO NOT EDIT. 22 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-go/tfprotov6/internal/toproto/string_kind.go: -------------------------------------------------------------------------------- 1 | package toproto 2 | 3 | import ( 4 | "github.com/hashicorp/terraform-plugin-go/tfprotov6" 5 | "github.com/hashicorp/terraform-plugin-go/tfprotov6/internal/tfplugin6" 6 | ) 7 | 8 | func StringKind(in tfprotov6.StringKind) tfplugin6.StringKind { 9 | return tfplugin6.StringKind(in) 10 | } 11 | 12 | // we have to say this next thing to get golint to stop yelling at us about the 13 | // underscores in the function names. We want the function names to match 14 | // actually-generated code, so it feels like fair play. It's just a shame we 15 | // lose golint for the entire file. 16 | // 17 | // This file is not actually generated. You can edit it. Ignore this next line. 18 | // Code generated by hand ignore this next bit DO NOT EDIT. 19 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-go/tfprotov6/string_kind.go: -------------------------------------------------------------------------------- 1 | package tfprotov6 2 | 3 | const ( 4 | // StringKindPlain indicates a string is plaintext, and should be 5 | // interpreted as having no formatting information. 6 | StringKindPlain StringKind = 0 7 | 8 | // StringKindMarkdown indicates a string is markdown-formatted, and 9 | // should be rendered using a Markdown renderer to correctly display 10 | // its formatting. 11 | StringKindMarkdown StringKind = 1 12 | ) 13 | 14 | // StringKind indicates a formatting or encoding scheme for a string. 15 | type StringKind int32 16 | 17 | func (s StringKind) String() string { 18 | switch s { 19 | case 0: 20 | return "PLAIN" 21 | case 1: 22 | return "MARKDOWN" 23 | } 24 | return "UNKNOWN" 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-go/tfprotov6/tf6server/doc.go: -------------------------------------------------------------------------------- 1 | // Package tf6server implements a server implementation to run 2 | // tfprotov6.ProviderServers as gRPC servers. 3 | // 4 | // Providers will likely be calling tf6server.Serve from their main function to 5 | // start the server so Terraform can connect to it. 6 | package tf6server 7 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-go/tftypes/unknown_value.go: -------------------------------------------------------------------------------- 1 | package tftypes 2 | 3 | const ( 4 | // UnknownValue represents a value that is not yet known. It can be the 5 | // value of any type. 6 | UnknownValue = unknown(0) 7 | ) 8 | 9 | type unknown byte 10 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-log/tflog/doc.go: -------------------------------------------------------------------------------- 1 | // Package tflog provides helper functions for writing log output and creating 2 | // loggers for Terraform plugins. 3 | // 4 | // For most plugin authors, building on an SDK or framework, the SDK or 5 | // framework will take care of injecting a logger using New. 6 | // 7 | // tflog also allows plugin authors to create subsystem loggers, which are 8 | // loggers for sufficiently distinct areas of the codebase or concerns. The 9 | // benefit of using distinct loggers for these concerns is doing so allows 10 | // plugin authors and practitioners to configure different log levels for each 11 | // subsystem's log, allowing log output to be turned on or off without 12 | // recompiling. 13 | package tflog 14 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-log/tfsdklog/doc.go: -------------------------------------------------------------------------------- 1 | // Package tfsdklog provides helper functions for logging from SDKs and 2 | // frameworks for building Terraform plugins. 3 | // 4 | // Plugin authors shouldn't need to use this package; it is meant for authors 5 | // of the frameworks and SDKs for plugins. Plugin authors should use the tflog 6 | // package. 7 | // 8 | // This package provides very similar functionality to tflog, except it uses a 9 | // separate namespace for its logs. 10 | package tfsdklog 11 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource/json.go: -------------------------------------------------------------------------------- 1 | package resource 2 | 3 | import ( 4 | "bytes" 5 | "encoding/json" 6 | ) 7 | 8 | func unmarshalJSON(data []byte, v interface{}) error { 9 | dec := json.NewDecoder(bytes.NewReader(data)) 10 | dec.UseNumber() 11 | return dec.Decode(v) 12 | } 13 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource/testing_config.go: -------------------------------------------------------------------------------- 1 | package resource 2 | 3 | import ( 4 | "context" 5 | "errors" 6 | "fmt" 7 | 8 | "github.com/hashicorp/terraform-plugin-sdk/v2/internal/logging" 9 | "github.com/hashicorp/terraform-plugin-sdk/v2/terraform" 10 | ) 11 | 12 | func testStepTaint(ctx context.Context, state *terraform.State, step TestStep) error { 13 | if len(step.Taint) == 0 { 14 | return nil 15 | } 16 | 17 | logging.HelperResourceTrace(ctx, fmt.Sprintf("Using TestStep Taint: %v", step.Taint)) 18 | 19 | for _, p := range step.Taint { 20 | m := state.RootModule() 21 | if m == nil { 22 | return errors.New("no state") 23 | } 24 | rs, ok := m.Resources[p] 25 | if !ok { 26 | return fmt.Errorf("resource %q not found in state", p) 27 | } 28 | logging.HelperResourceWarn(ctx, fmt.Sprintf("Explicitly tainting resource %q", p)) 29 | rs.Taint() 30 | } 31 | return nil 32 | } 33 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-sdk/v2/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-plugin-sdk/v2/helper/schema/context.go: -------------------------------------------------------------------------------- 1 | package schema 2 | 3 | type Key string 4 | 5 | var ( 6 | StopContextKey = Key("StopContext") 7 | ) 8 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-sdk/v2/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-plugin-sdk/v2/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-plugin-sdk/v2/helper/schema/json.go: -------------------------------------------------------------------------------- 1 | package schema 2 | 3 | import ( 4 | "bytes" 5 | "encoding/json" 6 | ) 7 | 8 | func unmarshalJSON(data []byte, v interface{}) error { 9 | dec := json.NewDecoder(bytes.NewReader(data)) 10 | dec.UseNumber() 11 | return dec.Decode(v) 12 | } 13 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema/resource_data_get_source.go: -------------------------------------------------------------------------------- 1 | package schema 2 | 3 | //go:generate go run golang.org/x/tools/cmd/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-plugin-sdk/v2/helper/schema/testing.go: -------------------------------------------------------------------------------- 1 | package schema 2 | 3 | import ( 4 | "context" 5 | 6 | testing "github.com/mitchellh/go-testing-interface" 7 | 8 | "github.com/hashicorp/terraform-plugin-sdk/v2/terraform" 9 | ) 10 | 11 | // TestResourceDataRaw creates a ResourceData from a raw configuration map. 12 | func TestResourceDataRaw(t testing.T, schema map[string]*Schema, raw map[string]interface{}) *ResourceData { 13 | t.Helper() 14 | 15 | c := terraform.NewResourceConfigRaw(raw) 16 | 17 | sm := schemaMap(schema) 18 | diff, err := sm.Diff(context.Background(), nil, c, nil, nil, true) 19 | if err != nil { 20 | t.Fatalf("err: %s", err) 21 | } 22 | 23 | result, err := sm.Data(nil, diff) 24 | if err != nil { 25 | t.Fatalf("err: %s", err) 26 | } 27 | 28 | return result 29 | } 30 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema/valuetype.go: -------------------------------------------------------------------------------- 1 | package schema 2 | 3 | //go:generate go run golang.org/x/tools/cmd/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-plugin-sdk/v2/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-plugin-sdk/v2/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-plugin-sdk/v2/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-plugin-sdk/v2/helper/structure/suppress_json_diff.go: -------------------------------------------------------------------------------- 1 | package structure 2 | 3 | import ( 4 | "reflect" 5 | 6 | "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" 7 | ) 8 | 9 | func SuppressJsonDiff(k, oldValue, newValue string, d *schema.ResourceData) bool { 10 | oldMap, err := ExpandJsonFromString(oldValue) 11 | if err != nil { 12 | return false 13 | } 14 | 15 | newMap, err := ExpandJsonFromString(newValue) 16 | if err != nil { 17 | return false 18 | } 19 | 20 | return reflect.DeepEqual(oldMap, newMap) 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation/uuid.go: -------------------------------------------------------------------------------- 1 | package validation 2 | 3 | import ( 4 | "fmt" 5 | 6 | "github.com/hashicorp/go-uuid" 7 | ) 8 | 9 | // IsUUID is a ValidateFunc that ensures a string can be parsed as UUID 10 | func IsUUID(i interface{}, k string) (warnings []string, errors []error) { 11 | v, ok := i.(string) 12 | if !ok { 13 | errors = append(errors, fmt.Errorf("expected type of %q to be string", k)) 14 | return 15 | } 16 | 17 | if _, err := uuid.ParseUUID(v); err != nil { 18 | errors = append(errors, fmt.Errorf("expected %q to be a valid UUID, got %v", k, v)) 19 | } 20 | 21 | return warnings, errors 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-sdk/v2/internal/addrs/module.go: -------------------------------------------------------------------------------- 1 | package addrs 2 | 3 | // Module is an address for a module call within configuration. This is 4 | // the static counterpart of ModuleInstance, representing a traversal through 5 | // the static module call tree in configuration and does not take into account 6 | // the potentially-multiple instances of a module that might be created by 7 | // "count" and "for_each" arguments within those calls. 8 | // 9 | // This type should be used only in very specialized cases when working with 10 | // the static module call tree. Type ModuleInstance is appropriate in more cases. 11 | // 12 | // Although Module is a slice, it should be treated as immutable after creation. 13 | type Module []string 14 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-sdk/v2/internal/configs/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-plugin-sdk/v2/internal/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-plugin-sdk/v2/internal/plugintest/doc.go: -------------------------------------------------------------------------------- 1 | // Package plugintest contains utilities to help with writing tests for 2 | // Terraform plugins. 3 | // 4 | // This is not a package for testing configurations or modules written in the 5 | // Terraform language. It is for testing the plugins that allow Terraform to 6 | // manage various cloud services and other APIs. 7 | package plugintest 8 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-sdk/v2/internal/tfdiags/diagnostic.go: -------------------------------------------------------------------------------- 1 | package tfdiags 2 | 3 | type Diagnostic interface { 4 | Severity() Severity 5 | Description() Description 6 | } 7 | 8 | type Severity rune 9 | 10 | //go:generate go run golang.org/x/tools/cmd/stringer -type=Severity 11 | 12 | const ( 13 | Error Severity = 'E' 14 | Warning Severity = 'W' 15 | ) 16 | 17 | type Description struct { 18 | Summary string 19 | Detail string 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-sdk/v2/internal/tfdiags/doc.go: -------------------------------------------------------------------------------- 1 | // Package tfdiags is a utility package for representing errors and 2 | // warnings in a manner that allows us to produce good messages for the 3 | // user. 4 | // 5 | // "diag" is short for "diagnostics", and is meant as a general word for 6 | // feedback to a user about potential or actual problems. 7 | // 8 | // A design goal for this package is for it to be able to provide rich 9 | // messaging where possible but to also be pragmatic about dealing with 10 | // generic errors produced by system components that _can't_ provide 11 | // such rich messaging. As a consequence, the main types in this package -- 12 | // Diagnostics and Diagnostic -- are designed so that they can be "smuggled" 13 | // over an error channel and then be unpacked at the other end, so that 14 | // error diagnostics (at least) can transit through APIs that are not 15 | // aware of this package. 16 | package tfdiags 17 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-sdk/v2/internal/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: FormatError(e.err), 17 | } 18 | } 19 | 20 | func FromError(err error) Diagnostic { 21 | return &nativeError{ 22 | err: err, 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-sdk/v2/internal/tfdiags/severity_string.go: -------------------------------------------------------------------------------- 1 | // Code generated by "stringer -type=Severity"; DO NOT EDIT. 2 | 3 | package tfdiags 4 | 5 | import "strconv" 6 | 7 | func _() { 8 | // An "invalid array index" compiler error signifies that the constant values have changed. 9 | // Re-run the stringer command to generate them again. 10 | var x [1]struct{} 11 | _ = x[Error-69] 12 | _ = x[Warning-87] 13 | } 14 | 15 | const ( 16 | _Severity_name_0 = "Error" 17 | _Severity_name_1 = "Warning" 18 | ) 19 | 20 | func (i Severity) String() string { 21 | switch { 22 | case i == 69: 23 | return _Severity_name_0 24 | case i == 87: 25 | return _Severity_name_1 26 | default: 27 | return "Severity(" + strconv.FormatInt(int64(i), 10) + ")" 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-sdk/v2/internal/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 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-sdk/v2/terraform/instancetype.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | //go:generate go run golang.org/x/tools/cmd/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-plugin-sdk/v2/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 | func _() { 8 | // An "invalid array index" compiler error signifies that the constant values have changed. 9 | // Re-run the stringer command to generate them again. 10 | var x [1]struct{} 11 | _ = x[typeInvalid-0] 12 | _ = x[typePrimary-1] 13 | _ = x[typeTainted-2] 14 | _ = x[typeDeposed-3] 15 | } 16 | 17 | const _instanceType_name = "typeInvalidtypePrimarytypeTaintedtypeDeposed" 18 | 19 | var _instanceType_index = [...]uint8{0, 11, 22, 33, 44} 20 | 21 | func (i instanceType) String() string { 22 | if i < 0 || i >= instanceType(len(_instanceType_index)-1) { 23 | return "instanceType(" + strconv.FormatInt(int64(i), 10) + ")" 24 | } 25 | return _instanceType_name[_instanceType_index[i]:_instanceType_index[i+1]] 26 | } 27 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-sdk/v2/terraform/resource_mode.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | //go:generate go run golang.org/x/tools/cmd/stringer -type=ResourceMode -output=resource_mode_string.go resource_mode.go 4 | 5 | // ResourceMode is deprecated, use addrs.ResourceMode instead. 6 | // It has been preserved for backwards compatibility. 7 | type ResourceMode int 8 | 9 | const ( 10 | ManagedResourceMode ResourceMode = iota 11 | DataResourceMode 12 | ) 13 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-sdk/v2/terraform/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 terraform 4 | 5 | import "strconv" 6 | 7 | func _() { 8 | // An "invalid array index" compiler error signifies that the constant values have changed. 9 | // Re-run the stringer command to generate them again. 10 | var x [1]struct{} 11 | _ = x[ManagedResourceMode-0] 12 | _ = x[DataResourceMode-1] 13 | } 14 | 15 | const _ResourceMode_name = "ManagedResourceModeDataResourceMode" 16 | 17 | var _ResourceMode_index = [...]uint8{0, 19, 35} 18 | 19 | func (i ResourceMode) String() string { 20 | if i < 0 || i >= ResourceMode(len(_ResourceMode_index)-1) { 21 | return "ResourceMode(" + strconv.FormatInt(int64(i), 10) + ")" 22 | } 23 | return _ResourceMode_name[_ResourceMode_index[i]:_ResourceMode_index[i+1]] 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-plugin-sdk/v2/terraform/util.go: -------------------------------------------------------------------------------- 1 | package terraform 2 | 3 | import ( 4 | "sort" 5 | ) 6 | 7 | // deduplicate a slice of strings 8 | func uniqueStrings(s []string) []string { 9 | if len(s) < 2 { 10 | return s 11 | } 12 | 13 | sort.Strings(s) 14 | result := make([]string, 1, len(s)) 15 | result[0] = s[0] 16 | for i := 1; i < len(s); i++ { 17 | if s[i] != result[len(result)-1] { 18 | result = append(result, s[i]) 19 | } 20 | } 21 | return result 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-registry-address/.go-version: -------------------------------------------------------------------------------- 1 | 1.18 2 | -------------------------------------------------------------------------------- /vendor/github.com/hashicorp/terraform-registry-address/errors.go: -------------------------------------------------------------------------------- 1 | package tfaddr 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | type ParserError struct { 8 | Summary string 9 | Detail string 10 | } 11 | 12 | func (pe *ParserError) Error() string { 13 | return fmt.Sprintf("%s: %s", pe.Summary, pe.Detail) 14 | } 15 | -------------------------------------------------------------------------------- /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/mattn/go-colorable/go.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 -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 13 | -------------------------------------------------------------------------------- /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/go.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 -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 13 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/isatty_bsd.go: -------------------------------------------------------------------------------- 1 | //go:build (darwin || freebsd || openbsd || netbsd || dragonfly || hurd) && !appengine && !tinygo 2 | // +build darwin freebsd openbsd netbsd dragonfly hurd 3 | // +build !appengine 4 | // +build !tinygo 5 | 6 | package isatty 7 | 8 | import "golang.org/x/sys/unix" 9 | 10 | // IsTerminal return true if the file descriptor is terminal. 11 | func IsTerminal(fd uintptr) bool { 12 | _, err := unix.IoctlGetTermios(int(fd), unix.TIOCGETA) 13 | return err == nil 14 | } 15 | 16 | // IsCygwinTerminal return true if the file descriptor is a cygwin or msys2 17 | // terminal. This is also always false on this environment. 18 | func IsCygwinTerminal(fd uintptr) bool { 19 | return false 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/isatty_others.go: -------------------------------------------------------------------------------- 1 | //go:build (appengine || js || nacl || tinygo || wasm) && !windows 2 | // +build appengine js nacl tinygo wasm 3 | // +build !windows 4 | 5 | package isatty 6 | 7 | // IsTerminal returns true if the file descriptor is terminal which 8 | // is always false on js and appengine classic which is a sandboxed PaaS. 9 | func IsTerminal(fd uintptr) bool { 10 | return false 11 | } 12 | 13 | // IsCygwinTerminal() return true if the file descriptor is a cygwin or msys2 14 | // terminal. This is also always false on this environment. 15 | func IsCygwinTerminal(fd uintptr) bool { 16 | return false 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/isatty_plan9.go: -------------------------------------------------------------------------------- 1 | //go:build plan9 2 | // +build plan9 3 | 4 | package isatty 5 | 6 | import ( 7 | "syscall" 8 | ) 9 | 10 | // IsTerminal returns true if the given file descriptor is a terminal. 11 | func IsTerminal(fd uintptr) bool { 12 | path, err := syscall.Fd2path(int(fd)) 13 | if err != nil { 14 | return false 15 | } 16 | return path == "/dev/cons" || path == "/mnt/term/dev/cons" 17 | } 18 | 19 | // IsCygwinTerminal return true if the file descriptor is a cygwin or msys2 20 | // terminal. This is also always false on this environment. 21 | func IsCygwinTerminal(fd uintptr) bool { 22 | return false 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/isatty_solaris.go: -------------------------------------------------------------------------------- 1 | //go:build solaris && !appengine 2 | // +build solaris,!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: https://src.illumos.org/source/xref/illumos-gate/usr/src/lib/libc/port/gen/isatty.c 12 | func IsTerminal(fd uintptr) bool { 13 | _, err := unix.IoctlGetTermio(int(fd), unix.TCGETA) 14 | return err == nil 15 | } 16 | 17 | // IsCygwinTerminal return true if the file descriptor is a cygwin or msys2 18 | // terminal. This is also always false on this environment. 19 | func IsCygwinTerminal(fd uintptr) bool { 20 | return false 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-isatty/isatty_tcgets.go: -------------------------------------------------------------------------------- 1 | //go:build (linux || aix || zos) && !appengine && !tinygo 2 | // +build linux aix zos 3 | // +build !appengine 4 | // +build !tinygo 5 | 6 | package isatty 7 | 8 | import "golang.org/x/sys/unix" 9 | 10 | // IsTerminal return true if the file descriptor is terminal. 11 | func IsTerminal(fd uintptr) bool { 12 | _, err := unix.IoctlGetTermios(int(fd), unix.TCGETS) 13 | return err == nil 14 | } 15 | 16 | // IsCygwinTerminal return true if the file descriptor is a cygwin or msys2 17 | // terminal. This is also always false on this environment. 18 | func IsCygwinTerminal(fd uintptr) bool { 19 | return false 20 | } 21 | -------------------------------------------------------------------------------- /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-testing-interface/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | go: 4 | - 1.x 5 | - tip 6 | 7 | script: 8 | - go test 9 | 10 | matrix: 11 | allow_failures: 12 | - go: tip 13 | -------------------------------------------------------------------------------- /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/vmihailenco/msgpack/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | language: go 3 | 4 | go: 5 | - 1.7.x 6 | - 1.8.x 7 | - 1.9.x 8 | - 1.10.x 9 | - 1.11.x 10 | - 1.12.x 11 | - tip 12 | 13 | matrix: 14 | allow_failures: 15 | - go: tip 16 | 17 | install: 18 | - go get gopkg.in/check.v1 19 | -------------------------------------------------------------------------------- /vendor/github.com/vmihailenco/msgpack/Makefile: -------------------------------------------------------------------------------- 1 | all: 2 | go test ./... 3 | env GOOS=linux GOARCH=386 go test ./... 4 | go test ./... -short -race 5 | go test ./... -run=nothing -bench=. -benchmem 6 | go vet 7 | -------------------------------------------------------------------------------- /vendor/github.com/vmihailenco/msgpack/msgpack.go: -------------------------------------------------------------------------------- 1 | package msgpack 2 | 3 | type Marshaler interface { 4 | MarshalMsgpack() ([]byte, error) 5 | } 6 | 7 | type Unmarshaler interface { 8 | UnmarshalMsgpack([]byte) error 9 | } 10 | 11 | type CustomEncoder interface { 12 | EncodeMsgpack(*Encoder) error 13 | } 14 | 15 | type CustomDecoder interface { 16 | DecodeMsgpack(*Decoder) error 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/vmihailenco/msgpack/tag.go: -------------------------------------------------------------------------------- 1 | package msgpack 2 | 3 | import ( 4 | "strings" 5 | ) 6 | 7 | type tagOptions string 8 | 9 | func (o tagOptions) Get(name string) (string, bool) { 10 | s := string(o) 11 | for len(s) > 0 { 12 | var next string 13 | idx := strings.IndexByte(s, ',') 14 | if idx >= 0 { 15 | s, next = s[:idx], s[idx+1:] 16 | } 17 | if strings.HasPrefix(s, name) { 18 | return s[len(name):], true 19 | } 20 | s = next 21 | } 22 | return "", false 23 | } 24 | 25 | func (o tagOptions) Contains(name string) bool { 26 | _, ok := o.Get(name) 27 | return ok 28 | } 29 | 30 | func parseTag(tag string) (string, tagOptions) { 31 | if idx := strings.IndexByte(tag, ','); idx != -1 { 32 | name := tag[:idx] 33 | if strings.IndexByte(name, ':') == -1 { 34 | return name, tagOptions(tag[idx+1:]) 35 | } 36 | } 37 | 38 | if strings.IndexByte(tag, ':') == -1 { 39 | return tag, "" 40 | } 41 | return "", tagOptions(tag) 42 | } 43 | -------------------------------------------------------------------------------- /vendor/github.com/vmihailenco/msgpack/v4/.golangci.yml: -------------------------------------------------------------------------------- 1 | run: 2 | concurrency: 8 3 | deadline: 5m 4 | tests: false 5 | linters: 6 | enable-all: true 7 | disable: 8 | - gochecknoglobals 9 | - gocognit 10 | - godox 11 | - wsl 12 | - funlen 13 | -------------------------------------------------------------------------------- /vendor/github.com/vmihailenco/msgpack/v4/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | language: go 3 | 4 | go: 5 | - 1.11.x 6 | - 1.12.x 7 | - 1.13.x 8 | - 1.14.x 9 | - tip 10 | 11 | matrix: 12 | allow_failures: 13 | - go: tip 14 | 15 | env: 16 | - GO111MODULE=on 17 | 18 | go_import_path: github.com/vmihailenco/msgpack 19 | 20 | before_install: 21 | - curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | sh -s -- -b $(go env GOPATH)/bin v1.21.0 22 | -------------------------------------------------------------------------------- /vendor/github.com/vmihailenco/msgpack/v4/Makefile: -------------------------------------------------------------------------------- 1 | all: 2 | go test ./... 3 | go test ./... -short -race 4 | go test ./... -run=NONE -bench=. -benchmem 5 | env GOOS=linux GOARCH=386 go test ./... 6 | golangci-lint run 7 | -------------------------------------------------------------------------------- /vendor/github.com/vmihailenco/msgpack/v4/msgpack.go: -------------------------------------------------------------------------------- 1 | package msgpack 2 | 3 | type Marshaler interface { 4 | MarshalMsgpack() ([]byte, error) 5 | } 6 | 7 | type Unmarshaler interface { 8 | UnmarshalMsgpack([]byte) error 9 | } 10 | 11 | type CustomEncoder interface { 12 | EncodeMsgpack(*Encoder) error 13 | } 14 | 15 | type CustomDecoder interface { 16 | DecodeMsgpack(*Decoder) error 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/vmihailenco/msgpack/v4/safe.go: -------------------------------------------------------------------------------- 1 | // +build appengine 2 | 3 | package msgpack 4 | 5 | // bytesToString converts byte slice to string. 6 | func bytesToString(b []byte) string { 7 | return string(b) 8 | } 9 | 10 | // stringToBytes converts string to byte slice. 11 | func stringToBytes(s string) []byte { 12 | return []byte(s) 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/vmihailenco/msgpack/v4/unsafe.go: -------------------------------------------------------------------------------- 1 | // +build !appengine 2 | 3 | package msgpack 4 | 5 | import ( 6 | "unsafe" 7 | ) 8 | 9 | // bytesToString converts byte slice to string. 10 | func bytesToString(b []byte) string { //nolint:deadcode,unused 11 | return *(*string)(unsafe.Pointer(&b)) 12 | } 13 | 14 | // stringToBytes converts string to byte slice. 15 | func stringToBytes(s string) []byte { 16 | return *(*[]byte)(unsafe.Pointer( 17 | &struct { 18 | string 19 | Cap int 20 | }{s, len(s)}, 21 | )) 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/vmihailenco/tagparser/.travis.yml: -------------------------------------------------------------------------------- 1 | dist: xenial 2 | sudo: false 3 | language: go 4 | 5 | go: 6 | - 1.11.x 7 | - 1.12.x 8 | - tip 9 | 10 | matrix: 11 | allow_failures: 12 | - go: tip 13 | 14 | env: 15 | - GO111MODULE=on 16 | 17 | go_import_path: github.com/vmihailenco/tagparser 18 | 19 | before_install: 20 | - curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | sh -s -- -b $(go env GOPATH)/bin v1.17.1 21 | 22 | script: 23 | - make 24 | - golangci-lint run 25 | -------------------------------------------------------------------------------- /vendor/github.com/vmihailenco/tagparser/Makefile: -------------------------------------------------------------------------------- 1 | all: 2 | go test ./... 3 | go test ./... -short -race 4 | go test ./... -run=NONE -bench=. -benchmem 5 | env GOOS=linux GOARCH=386 go test ./... 6 | go vet ./... 7 | go get github.com/gordonklaus/ineffassign 8 | ineffassign . 9 | -------------------------------------------------------------------------------- /vendor/github.com/vmihailenco/tagparser/README.md: -------------------------------------------------------------------------------- 1 | # Opinionated Golang tag parser 2 | 3 | [![Build Status](https://travis-ci.org/vmihailenco/tagparser.png?branch=master)](https://travis-ci.org/vmihailenco/tagparser) 4 | [![GoDoc](https://godoc.org/github.com/vmihailenco/tagparser?status.svg)](https://godoc.org/github.com/vmihailenco/tagparser) 5 | 6 | ## Installation 7 | 8 | Install: 9 | 10 | ```shell 11 | go get -u github.com/vmihailenco/tagparser 12 | ``` 13 | 14 | ## Quickstart 15 | 16 | ```go 17 | func ExampleParse() { 18 | tag := tagparser.Parse("some_name,key:value,key2:'complex value'") 19 | fmt.Println(tag.Name) 20 | fmt.Println(tag.Options) 21 | // Output: some_name 22 | // map[key:value key2:'complex value'] 23 | } 24 | ``` 25 | -------------------------------------------------------------------------------- /vendor/github.com/vmihailenco/tagparser/internal/safe.go: -------------------------------------------------------------------------------- 1 | // +build appengine 2 | 3 | package internal 4 | 5 | func BytesToString(b []byte) string { 6 | return string(b) 7 | } 8 | 9 | func StringToBytes(s string) []byte { 10 | return []byte(s) 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/vmihailenco/tagparser/internal/unsafe.go: -------------------------------------------------------------------------------- 1 | // +build !appengine 2 | 3 | package internal 4 | 5 | import ( 6 | "unsafe" 7 | ) 8 | 9 | // BytesToString converts byte slice to string. 10 | func BytesToString(b []byte) string { 11 | return *(*string)(unsafe.Pointer(&b)) 12 | } 13 | 14 | // StringToBytes converts string to byte slice. 15 | func StringToBytes(s string) []byte { 16 | return *(*[]byte)(unsafe.Pointer( 17 | &struct { 18 | string 19 | Cap int 20 | }{s, len(s)}, 21 | )) 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/yannh/statuspage-go-sdk/README.md: -------------------------------------------------------------------------------- 1 | # Golang SDK for Statuspage.io 2 | 3 | Currently built as support for https://github.com/yannh/terraform-provider-statuspage 4 | -------------------------------------------------------------------------------- /vendor/github.com/zclconf/go-cty/cty/convert/conversion_capsule.go: -------------------------------------------------------------------------------- 1 | package convert 2 | 3 | import ( 4 | "github.com/zclconf/go-cty/cty" 5 | ) 6 | 7 | func conversionToCapsule(inTy, outTy cty.Type, fn func(inTy cty.Type) func(cty.Value, cty.Path) (interface{}, error)) conversion { 8 | rawConv := fn(inTy) 9 | if rawConv == nil { 10 | return nil 11 | } 12 | 13 | return func(in cty.Value, path cty.Path) (cty.Value, error) { 14 | rawV, err := rawConv(in, path) 15 | if err != nil { 16 | return cty.NilVal, err 17 | } 18 | return cty.CapsuleVal(outTy, rawV), nil 19 | } 20 | } 21 | 22 | func conversionFromCapsule(inTy, outTy cty.Type, fn func(outTy cty.Type) func(interface{}, cty.Path) (cty.Value, error)) conversion { 23 | rawConv := fn(outTy) 24 | if rawConv == nil { 25 | return nil 26 | } 27 | 28 | return func(in cty.Value, path cty.Path) (cty.Value, error) { 29 | return rawConv(in.EncapsulatedValue(), path) 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /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 | vals []interface{} 5 | idx int 6 | } 7 | 8 | func (it *Iterator) Value() interface{} { 9 | return it.vals[it.idx] 10 | } 11 | 12 | func (it *Iterator) Next() bool { 13 | it.idx++ 14 | return it.idx < len(it.vals) 15 | } 16 | -------------------------------------------------------------------------------- /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/chacha20/chacha_arm64.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 | //go:build go1.11 && gc && !purego 6 | // +build go1.11,gc,!purego 7 | 8 | package chacha20 9 | 10 | const bufSize = 256 11 | 12 | //go:noescape 13 | func xorKeyStreamVX(dst, src []byte, key *[8]uint32, nonce *[3]uint32, counter *uint32) 14 | 15 | func (c *Cipher) xorKeyStreamBlocks(dst, src []byte) { 16 | xorKeyStreamVX(dst, src, &c.key, &c.nonce, &c.counter) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/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 | //go:build (!arm64 && !s390x && !ppc64le) || (arm64 && !go1.11) || !gc || purego 6 | // +build !arm64,!s390x,!ppc64le arm64,!go1.11 !gc purego 7 | 8 | package chacha20 9 | 10 | const bufSize = blockSize 11 | 12 | func (s *Cipher) xorKeyStreamBlocks(dst, src []byte) { 13 | s.xorKeyStreamBlocksGeneric(dst, src) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/chacha20/chacha_ppc64le.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 | //go:build gc && !purego 6 | // +build gc,!purego 7 | 8 | package chacha20 9 | 10 | const bufSize = 256 11 | 12 | //go:noescape 13 | func chaCha20_ctr32_vsx(out, inp *byte, len int, key *[8]uint32, counter *uint32) 14 | 15 | func (c *Cipher) xorKeyStreamBlocks(dst, src []byte) { 16 | chaCha20_ctr32_vsx(&dst[0], &src[0], len(src), &c.key, &c.counter) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/chacha20/chacha_s390x.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 | //go:build gc && !purego 6 | // +build gc,!purego 7 | 8 | package chacha20 9 | 10 | import "golang.org/x/sys/cpu" 11 | 12 | var haveAsm = cpu.S390X.HasVX 13 | 14 | const bufSize = 256 15 | 16 | // xorKeyStreamVX is an assembly implementation of XORKeyStream. It must only 17 | // be called when the vector facility is available. Implementation in asm_s390x.s. 18 | //go:noescape 19 | func xorKeyStreamVX(dst, src []byte, key *[8]uint32, nonce *[3]uint32, counter *uint32) 20 | 21 | func (c *Cipher) xorKeyStreamBlocks(dst, src []byte) { 22 | if cpu.S390X.HasVX { 23 | xorKeyStreamVX(dst, src, &c.key, &c.nonce, &c.counter) 24 | } else { 25 | c.xorKeyStreamBlocksGeneric(dst, src) 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/README: -------------------------------------------------------------------------------- 1 | This package is kept in sync with crypto/ed25519/internal/edwards25519/field in 2 | the standard library. 3 | 4 | If there are any changes in the standard library that need to be synced to this 5 | package, run sync.sh. It will not overwrite any local changes made since the 6 | previous sync, so it's ok to land changes in this package first, and then sync 7 | to the standard library later. 8 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64.go: -------------------------------------------------------------------------------- 1 | // Code generated by command: go run fe_amd64_asm.go -out ../fe_amd64.s -stubs ../fe_amd64.go -pkg field. DO NOT EDIT. 2 | 3 | // +build amd64,gc,!purego 4 | 5 | package field 6 | 7 | // feMul sets out = a * b. It works like feMulGeneric. 8 | //go:noescape 9 | func feMul(out *Element, a *Element, b *Element) 10 | 11 | // feSquare sets out = a * a. It works like feSquareGeneric. 12 | //go:noescape 13 | func feSquare(out *Element, a *Element) 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64_noasm.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2019 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 | //go:build !amd64 || !gc || purego 6 | // +build !amd64 !gc purego 7 | 8 | package field 9 | 10 | func feMul(v, x, y *Element) { feMulGeneric(v, x, y) } 11 | 12 | func feSquare(v, x *Element) { feSquareGeneric(v, x) } 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2020 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 | //go:build arm64 && gc && !purego 6 | // +build arm64,gc,!purego 7 | 8 | package field 9 | 10 | //go:noescape 11 | func carryPropagate(v *Element) 12 | 13 | func (v *Element) carryPropagate() *Element { 14 | carryPropagate(v) 15 | return v 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64_noasm.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2021 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 | //go:build !arm64 || !gc || purego 6 | // +build !arm64 !gc purego 7 | 8 | package field 9 | 10 | func (v *Element) carryPropagate() *Element { 11 | return v.carryPropagateGeneric() 12 | } 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/sync.checkpoint: -------------------------------------------------------------------------------- 1 | b0c49ae9f59d233526f8934262c5bbbe14d4358d 2 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/sync.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash 2 | set -euo pipefail 3 | 4 | cd "$(git rev-parse --show-toplevel)" 5 | 6 | STD_PATH=src/crypto/ed25519/internal/edwards25519/field 7 | LOCAL_PATH=curve25519/internal/field 8 | LAST_SYNC_REF=$(cat $LOCAL_PATH/sync.checkpoint) 9 | 10 | git fetch https://go.googlesource.com/go master 11 | 12 | if git diff --quiet $LAST_SYNC_REF:$STD_PATH FETCH_HEAD:$STD_PATH; then 13 | echo "No changes." 14 | else 15 | NEW_REF=$(git rev-parse FETCH_HEAD | tee $LOCAL_PATH/sync.checkpoint) 16 | echo "Applying changes from $LAST_SYNC_REF to $NEW_REF..." 17 | git diff $LAST_SYNC_REF:$STD_PATH FETCH_HEAD:$STD_PATH | \ 18 | git apply -3 --directory=$LOCAL_PATH 19 | fi 20 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/poly1305/bits_go1.13.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 | //go:build go1.13 6 | // +build go1.13 7 | 8 | package poly1305 9 | 10 | import "math/bits" 11 | 12 | func bitsAdd64(x, y, carry uint64) (sum, carryOut uint64) { 13 | return bits.Add64(x, y, carry) 14 | } 15 | 16 | func bitsSub64(x, y, borrow uint64) (diff, borrowOut uint64) { 17 | return bits.Sub64(x, y, borrow) 18 | } 19 | 20 | func bitsMul64(x, y uint64) (hi, lo uint64) { 21 | return bits.Mul64(x, y) 22 | } 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/poly1305/mac_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 | //go:build (!amd64 && !ppc64le && !s390x) || !gc || purego 6 | // +build !amd64,!ppc64le,!s390x !gc purego 7 | 8 | package poly1305 9 | 10 | type mac struct{ macGeneric } 11 | -------------------------------------------------------------------------------- /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 | //go:build go1.9 6 | // +build go1.9 7 | 8 | package context 9 | 10 | import "context" // standard library's context, as of Go 1.7 11 | 12 | // A Context carries a deadline, a cancelation signal, and other values across 13 | // API boundaries. 14 | // 15 | // Context's methods may be called by multiple goroutines simultaneously. 16 | type Context = context.Context 17 | 18 | // A CancelFunc tells an operation to abandon its work. 19 | // A CancelFunc does not wait for the work to stop. 20 | // After the first call, subsequent calls to a CancelFunc do nothing. 21 | type CancelFunc = context.CancelFunc 22 | -------------------------------------------------------------------------------- /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/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 | //go:build go1.11 6 | // +build go1.11 7 | 8 | package http2 9 | 10 | import ( 11 | "net/http/httptrace" 12 | "net/textproto" 13 | ) 14 | 15 | func traceHasWroteHeaderField(trace *httptrace.ClientTrace) bool { 16 | return trace != nil && trace.WroteHeaderField != nil 17 | } 18 | 19 | func traceWroteHeaderField(trace *httptrace.ClientTrace, k, v string) { 20 | if trace != nil && trace.WroteHeaderField != nil { 21 | trace.WroteHeaderField(k, []string{v}) 22 | } 23 | } 24 | 25 | func traceGot1xxResponseFunc(trace *httptrace.ClientTrace) func(int, textproto.MIMEHeader) error { 26 | if trace != nil { 27 | return trace.Got1xxResponse 28 | } 29 | return nil 30 | } 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/go115.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 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 | //go:build go1.15 6 | // +build go1.15 7 | 8 | package http2 9 | 10 | import ( 11 | "context" 12 | "crypto/tls" 13 | ) 14 | 15 | // dialTLSWithContext uses tls.Dialer, added in Go 1.15, to open a TLS 16 | // connection. 17 | func (t *Transport) dialTLSWithContext(ctx context.Context, network, addr string, cfg *tls.Config) (*tls.Conn, error) { 18 | dialer := &tls.Dialer{ 19 | Config: cfg, 20 | } 21 | cn, err := dialer.DialContext(ctx, network, addr) 22 | if err != nil { 23 | return nil, err 24 | } 25 | tlsCn := cn.(*tls.Conn) // DialContext comment promises this will always succeed 26 | return tlsCn, nil 27 | } 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/go118.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 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 | //go:build go1.18 6 | // +build go1.18 7 | 8 | package http2 9 | 10 | import ( 11 | "crypto/tls" 12 | "net" 13 | ) 14 | 15 | func tlsUnderlyingConn(tc *tls.Conn) net.Conn { 16 | return tc.NetConn() 17 | } 18 | -------------------------------------------------------------------------------- /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 | //go:build !go1.11 6 | // +build !go1.11 7 | 8 | package http2 9 | 10 | import ( 11 | "net/http/httptrace" 12 | "net/textproto" 13 | ) 14 | 15 | func traceHasWroteHeaderField(trace *httptrace.ClientTrace) bool { return false } 16 | 17 | func traceWroteHeaderField(trace *httptrace.ClientTrace, k, v string) {} 18 | 19 | func traceGot1xxResponseFunc(trace *httptrace.ClientTrace) func(int, textproto.MIMEHeader) error { 20 | return nil 21 | } 22 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/not_go115.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 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 | //go:build !go1.15 6 | // +build !go1.15 7 | 8 | package http2 9 | 10 | import ( 11 | "context" 12 | "crypto/tls" 13 | ) 14 | 15 | // dialTLSWithContext opens a TLS connection. 16 | func (t *Transport) dialTLSWithContext(ctx context.Context, network, addr string, cfg *tls.Config) (*tls.Conn, error) { 17 | cn, err := tls.Dial(network, addr, cfg) 18 | if err != nil { 19 | return nil, err 20 | } 21 | if err := cn.Handshake(); err != nil { 22 | return nil, err 23 | } 24 | if cfg.InsecureSkipVerify { 25 | return cn, nil 26 | } 27 | if err := cn.VerifyHostname(cfg.ServerName); err != nil { 28 | return nil, err 29 | } 30 | return cn, nil 31 | } 32 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/not_go118.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 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 | //go:build !go1.18 6 | // +build !go1.18 7 | 8 | package http2 9 | 10 | import ( 11 | "crypto/tls" 12 | "net" 13 | ) 14 | 15 | func tlsUnderlyingConn(tc *tls.Conn) net.Conn { 16 | return nil 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/idna/go118.go: -------------------------------------------------------------------------------- 1 | // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT. 2 | 3 | // Copyright 2021 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 | //go:build go1.18 8 | // +build go1.18 9 | 10 | package idna 11 | 12 | // Transitional processing is disabled by default in Go 1.18. 13 | // https://golang.org/issue/47510 14 | const transitionalLookup = false 15 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/idna/pre_go118.go: -------------------------------------------------------------------------------- 1 | // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT. 2 | 3 | // Copyright 2021 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 | //go:build !go1.18 8 | // +build !go1.18 9 | 10 | package idna 11 | 12 | const transitionalLookup = true 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/asm_aix_ppc64.s: -------------------------------------------------------------------------------- 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 | //go:build gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for ppc64, AIX are implemented in runtime/syscall_aix.go 11 | // 12 | 13 | TEXT ·syscall6(SB),NOSPLIT,$0-88 14 | JMP syscall·syscall6(SB) 15 | 16 | TEXT ·rawSyscall6(SB),NOSPLIT,$0-88 17 | JMP syscall·rawSyscall6(SB) 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_aix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 | //go:build aix 6 | 7 | package cpu 8 | 9 | const ( 10 | // getsystemcfg constants 11 | _SC_IMPL = 2 12 | _IMPL_POWER8 = 0x10000 13 | _IMPL_POWER9 = 0x20000 14 | ) 15 | 16 | func archInit() { 17 | impl := getsystemcfg(_SC_IMPL) 18 | if impl&_IMPL_POWER8 != 0 { 19 | PPC64.IsPOWER8 = true 20 | } 21 | if impl&_IMPL_POWER9 != 0 { 22 | PPC64.IsPOWER8 = true 23 | PPC64.IsPOWER9 = true 24 | } 25 | 26 | Initialized = true 27 | } 28 | 29 | func getsystemcfg(label int) (n uint64) { 30 | r0, _ := callgetsystemcfg(label) 31 | n = uint64(r0) 32 | return 33 | } 34 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gc_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 | //go:build gc 6 | 7 | package cpu 8 | 9 | func getisar0() uint64 10 | func getisar1() uint64 11 | func getpfr0() uint64 12 | func getzfr0() uint64 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gc_s390x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 | //go:build gc 6 | 7 | package cpu 8 | 9 | // haveAsmFunctions reports whether the other functions in this file can 10 | // be safely called. 11 | func haveAsmFunctions() bool { return true } 12 | 13 | // The following feature detection functions are defined in cpu_s390x.s. 14 | // They are likely to be expensive to call so the results should be cached. 15 | func stfle() facilityList 16 | func kmQuery() queryResult 17 | func kmcQuery() queryResult 18 | func kmctrQuery() queryResult 19 | func kmaQuery() queryResult 20 | func kimdQuery() queryResult 21 | func klmdQuery() queryResult 22 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gc_x86.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 | //go:build (386 || amd64 || amd64p32) && gc 6 | 7 | package cpu 8 | 9 | // cpuid is implemented in cpu_x86.s for gc compiler 10 | // and in cpu_gccgo.c for gccgo. 11 | func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32) 12 | 13 | // xgetbv with ecx = 0 is implemented in cpu_x86.s for gc compiler 14 | // and in cpu_gccgo.c for gccgo. 15 | func xgetbv() (eax, edx uint32) 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gccgo_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 | //go:build gccgo 6 | 7 | package cpu 8 | 9 | func getisar0() uint64 { return 0 } 10 | func getisar1() uint64 { return 0 } 11 | func getpfr0() uint64 { return 0 } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.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 | //go:build (386 || amd64 || amd64p32) && gccgo 6 | 7 | package cpu 8 | 9 | //extern gccgoGetCpuidCount 10 | func gccgoGetCpuidCount(eaxArg, ecxArg uint32, eax, ebx, ecx, edx *uint32) 11 | 12 | func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32) { 13 | var a, b, c, d uint32 14 | gccgoGetCpuidCount(eaxArg, ecxArg, &a, &b, &c, &d) 15 | return a, b, c, d 16 | } 17 | 18 | //extern gccgoXgetbv 19 | func gccgoXgetbv(eax, edx *uint32) 20 | 21 | func xgetbv() (eax, edx uint32) { 22 | var a, d uint32 23 | gccgoXgetbv(&a, &d) 24 | return a, d 25 | } 26 | 27 | // gccgo doesn't build on Darwin, per: 28 | // https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/gcc.rb#L76 29 | func darwinSupportsAVX512() bool { 30 | return false 31 | } 32 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_linux.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 | //go:build !386 && !amd64 && !amd64p32 && !arm64 6 | 7 | package cpu 8 | 9 | func archInit() { 10 | if err := readHWCAP(); err != nil { 11 | return 12 | } 13 | doinit() 14 | Initialized = true 15 | } 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_linux_mips64x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 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 | //go:build linux && (mips64 || mips64le) 6 | 7 | package cpu 8 | 9 | // HWCAP bits. These are exposed by the Linux kernel 5.4. 10 | const ( 11 | // CPU features 12 | hwcap_MIPS_MSA = 1 << 1 13 | ) 14 | 15 | func doinit() { 16 | // HWCAP feature bits 17 | MIPS64X.HasMSA = isSet(hwCap, hwcap_MIPS_MSA) 18 | } 19 | 20 | func isSet(hwc uint, value uint) bool { 21 | return hwc&value != 0 22 | } 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 | //go:build linux && !arm && !arm64 && !mips64 && !mips64le && !ppc64 && !ppc64le && !s390x 6 | 7 | package cpu 8 | 9 | func doinit() {} 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_linux_ppc64x.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 | //go:build linux && (ppc64 || ppc64le) 6 | 7 | package cpu 8 | 9 | // HWCAP/HWCAP2 bits. These are exposed by the kernel. 10 | const ( 11 | // ISA Level 12 | _PPC_FEATURE2_ARCH_2_07 = 0x80000000 13 | _PPC_FEATURE2_ARCH_3_00 = 0x00800000 14 | 15 | // CPU features 16 | _PPC_FEATURE2_DARN = 0x00200000 17 | _PPC_FEATURE2_SCV = 0x00100000 18 | ) 19 | 20 | func doinit() { 21 | // HWCAP2 feature bits 22 | PPC64.IsPOWER8 = isSet(hwCap2, _PPC_FEATURE2_ARCH_2_07) 23 | PPC64.IsPOWER9 = isSet(hwCap2, _PPC_FEATURE2_ARCH_3_00) 24 | PPC64.HasDARN = isSet(hwCap2, _PPC_FEATURE2_DARN) 25 | PPC64.HasSCV = isSet(hwCap2, _PPC_FEATURE2_SCV) 26 | } 27 | 28 | func isSet(hwc uint, value uint) bool { 29 | return hwc&value != 0 30 | } 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_loong64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 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 | //go:build loong64 6 | 7 | package cpu 8 | 9 | const cacheLineSize = 64 10 | 11 | func initOptions() { 12 | } 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_mips64x.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 | //go:build mips64 || mips64le 6 | 7 | package cpu 8 | 9 | const cacheLineSize = 32 10 | 11 | func initOptions() { 12 | options = []option{ 13 | {Name: "msa", Feature: &MIPS64X.HasMSA}, 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_mipsx.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 | //go:build mips || mipsle 6 | 7 | package cpu 8 | 9 | const cacheLineSize = 32 10 | 11 | func initOptions() {} 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_openbsd_arm64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2022 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 | #include "textflag.h" 6 | 7 | TEXT libc_sysctl_trampoline<>(SB),NOSPLIT,$0-0 8 | JMP libc_sysctl(SB) 9 | 10 | GLOBL ·libc_sysctl_trampoline_addr(SB), RODATA, $8 11 | DATA ·libc_sysctl_trampoline_addr(SB)/8, $libc_sysctl_trampoline<>(SB) 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_other_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 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 | //go:build !linux && arm 6 | 7 | package cpu 8 | 9 | func archInit() {} 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_other_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 | //go:build !linux && !netbsd && !openbsd && arm64 6 | 7 | package cpu 8 | 9 | func doinit() {} 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_other_mips64x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 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 | //go:build !linux && (mips64 || mips64le) 6 | 7 | package cpu 8 | 9 | func archInit() { 10 | Initialized = true 11 | } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_other_ppc64x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 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 | //go:build !aix && !linux && (ppc64 || ppc64le) 6 | 7 | package cpu 8 | 9 | func archInit() { 10 | PPC64.IsPOWER8 = true 11 | Initialized = true 12 | } 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_other_riscv64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 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 | //go:build !linux && riscv64 6 | 7 | package cpu 8 | 9 | func archInit() { 10 | Initialized = true 11 | } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_ppc64x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 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 | //go:build ppc64 || ppc64le 6 | 7 | package cpu 8 | 9 | const cacheLineSize = 128 10 | 11 | func initOptions() { 12 | options = []option{ 13 | {Name: "darn", Feature: &PPC64.HasDARN}, 14 | {Name: "scv", Feature: &PPC64.HasSCV}, 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_riscv64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 | //go:build riscv64 6 | 7 | package cpu 8 | 9 | const cacheLineSize = 64 10 | 11 | func initOptions() {} 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_wasm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 | //go:build wasm 6 | 7 | package cpu 8 | 9 | // We're compiling the cpu package for an unknown (software-abstracted) CPU. 10 | // Make CacheLinePad an empty struct and hope that the usual struct alignment 11 | // rules are good enough. 12 | 13 | const cacheLineSize = 0 14 | 15 | func initOptions() {} 16 | 17 | func archInit() {} 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_x86.s: -------------------------------------------------------------------------------- 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 | //go:build (386 || amd64 || amd64p32) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32) 10 | TEXT ·cpuid(SB), NOSPLIT, $0-24 11 | MOVL eaxArg+0(FP), AX 12 | MOVL ecxArg+4(FP), CX 13 | CPUID 14 | MOVL AX, eax+8(FP) 15 | MOVL BX, ebx+12(FP) 16 | MOVL CX, ecx+16(FP) 17 | MOVL DX, edx+20(FP) 18 | RET 19 | 20 | // func xgetbv() (eax, edx uint32) 21 | TEXT ·xgetbv(SB),NOSPLIT,$0-8 22 | MOVL $0, CX 23 | XGETBV 24 | MOVL AX, eax+0(FP) 25 | MOVL DX, edx+4(FP) 26 | RET 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_zos.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 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 cpu 6 | 7 | func archInit() { 8 | doinit() 9 | Initialized = true 10 | } 11 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_zos_s390x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 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 cpu 6 | 7 | func initS390Xbase() { 8 | // get the facilities list 9 | facilities := stfle() 10 | 11 | // mandatory 12 | S390X.HasZARCH = facilities.Has(zarch) 13 | S390X.HasSTFLE = facilities.Has(stflef) 14 | S390X.HasLDISP = facilities.Has(ldisp) 15 | S390X.HasEIMM = facilities.Has(eimm) 16 | 17 | // optional 18 | S390X.HasETF3EH = facilities.Has(etf3eh) 19 | S390X.HasDFP = facilities.Has(dfp) 20 | S390X.HasMSA = facilities.Has(msa) 21 | S390X.HasVX = facilities.Has(vx) 22 | if S390X.HasVX { 23 | S390X.HasVXE = facilities.Has(vxe) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/endian_big.go: -------------------------------------------------------------------------------- 1 | // Copyright 2023 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 | //go:build armbe || arm64be || m68k || mips || mips64 || mips64p32 || ppc || ppc64 || s390 || s390x || shbe || sparc || sparc64 6 | 7 | package cpu 8 | 9 | // IsBigEndian records whether the GOARCH's byte order is big endian. 10 | const IsBigEndian = true 11 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/endian_little.go: -------------------------------------------------------------------------------- 1 | // Copyright 2023 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 | //go:build 386 || amd64 || amd64p32 || alpha || arm || arm64 || loong64 || mipsle || mips64le || mips64p32le || nios2 || ppc64le || riscv || riscv64 || sh || wasm 6 | 7 | package cpu 8 | 9 | // IsBigEndian records whether the GOARCH's byte order is big endian. 10 | const IsBigEndian = false 11 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/runtime_auxv.go: -------------------------------------------------------------------------------- 1 | // Copyright 2023 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 cpu 6 | 7 | // getAuxvFn is non-nil on Go 1.21+ (via runtime_auxv_go121.go init) 8 | // on platforms that use auxv. 9 | var getAuxvFn func() []uintptr 10 | 11 | func getAuxv() []uintptr { 12 | if getAuxvFn == nil { 13 | return nil 14 | } 15 | return getAuxvFn() 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/runtime_auxv_go121.go: -------------------------------------------------------------------------------- 1 | // Copyright 2023 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 | //go:build go1.21 6 | 7 | package cpu 8 | 9 | import ( 10 | _ "unsafe" // for linkname 11 | ) 12 | 13 | //go:linkname runtime_getAuxv runtime.getAuxv 14 | func runtime_getAuxv() []uintptr 15 | 16 | func init() { 17 | getAuxvFn = runtime_getAuxv 18 | } 19 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/syscall_aix_gccgo.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 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 | // Recreate a getsystemcfg syscall handler instead of 6 | // using the one provided by x/sys/unix to avoid having 7 | // the dependency between them. (See golang.org/issue/32102) 8 | // Moreover, this file will be used during the building of 9 | // gccgo's libgo and thus must not used a CGo method. 10 | 11 | //go:build aix && gccgo 12 | 13 | package cpu 14 | 15 | import ( 16 | "syscall" 17 | ) 18 | 19 | //extern getsystemcfg 20 | func gccgoGetsystemcfg(label uint32) (r uint64) 21 | 22 | func callgetsystemcfg(label int) (r1 uintptr, e1 syscall.Errno) { 23 | r1 = uintptr(gccgoGetsystemcfg(uint32(label))) 24 | e1 = syscall.GetErrno() 25 | return 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/.gitignore: -------------------------------------------------------------------------------- 1 | _obj/ 2 | unix.test 3 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/aliases.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 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | type Signal = syscall.Signal 12 | type Errno = syscall.Errno 13 | type SysProcAttr = syscall.SysProcAttr 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_aix_ppc64.s: -------------------------------------------------------------------------------- 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 | //go:build gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for ppc64, AIX are implemented in runtime/syscall_aix.go 11 | // 12 | 13 | TEXT ·syscall6(SB),NOSPLIT,$0-88 14 | JMP syscall·syscall6(SB) 15 | 16 | TEXT ·rawSyscall6(SB),NOSPLIT,$0-88 17 | JMP syscall·rawSyscall6(SB) 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_386.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 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 | //go:build (freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for 386 BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-28 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 21 | JMP syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 24 | JMP syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 27 | JMP syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 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 | //go:build (darwin || dragonfly || freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for AMD64 BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-56 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 21 | JMP syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 24 | JMP syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 27 | JMP syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_arm.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 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 | //go:build (freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for ARM BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-28 15 | B syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 18 | B syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 21 | B syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 24 | B syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 27 | B syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_arm64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 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 | //go:build (darwin || freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for ARM64 BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-56 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 21 | JMP syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 24 | JMP syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 27 | JMP syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_bsd_ppc64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2022 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 | //go:build (darwin || freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for ppc64, BSD 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_bsd_riscv64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2021 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 | //go:build (darwin || freebsd || netbsd || openbsd) && gc 6 | 7 | #include "textflag.h" 8 | 9 | // System call support for RISCV64 BSD 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-56 15 | JMP syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 18 | JMP syscall·Syscall6(SB) 19 | 20 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 21 | JMP syscall·Syscall9(SB) 22 | 23 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 24 | JMP syscall·RawSyscall(SB) 25 | 26 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 27 | JMP syscall·RawSyscall6(SB) 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_openbsd_mips64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 | //go:build gc 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for mips64, 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_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 | //go:build gc 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 | HCI_CHANNEL_LOGGING = 4 27 | ) 28 | 29 | // Socketoption Level 30 | const ( 31 | SOL_BLUETOOTH = 0x112 32 | SOL_HCI = 0x0 33 | SOL_L2CAP = 0x6 34 | SOL_RFCOMM = 0x12 35 | SOL_SCO = 0x11 36 | ) 37 | -------------------------------------------------------------------------------- /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 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 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/dev_aix_ppc.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 | //go:build aix && ppc 6 | 7 | // Functions to access/create device major and minor numbers matching the 8 | // encoding used by AIX. 9 | 10 | package unix 11 | 12 | // Major returns the major component of a Linux device number. 13 | func Major(dev uint64) uint32 { 14 | return uint32((dev >> 16) & 0xffff) 15 | } 16 | 17 | // Minor returns the minor component of a Linux device number. 18 | func Minor(dev uint64) uint32 { 19 | return uint32(dev & 0xffff) 20 | } 21 | 22 | // Mkdev returns a Linux device number generated from the given major and minor 23 | // components. 24 | func Mkdev(major, minor uint32) uint64 { 25 | return uint64(((major) << 16) | (minor)) 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/dev_darwin.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 | // Functions to access/create device major and minor numbers matching the 6 | // encoding used in Darwin's sys/types.h header. 7 | 8 | package unix 9 | 10 | // Major returns the major component of a Darwin device number. 11 | func Major(dev uint64) uint32 { 12 | return uint32((dev >> 24) & 0xff) 13 | } 14 | 15 | // Minor returns the minor component of a Darwin device number. 16 | func Minor(dev uint64) uint32 { 17 | return uint32(dev & 0xffffff) 18 | } 19 | 20 | // Mkdev returns a Darwin device number generated from the given major and minor 21 | // components. 22 | func Mkdev(major, minor uint32) uint64 { 23 | return (uint64(major) << 24) | uint64(minor) 24 | } 25 | -------------------------------------------------------------------------------- /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 | //go:build armbe || arm64be || m68k || mips || mips64 || mips64p32 || ppc || ppc64 || s390 || s390x || shbe || sparc || sparc64 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 | //go:build 386 || amd64 || amd64p32 || alpha || arm || arm64 || loong64 || mipsle || mips64le || mips64p32le || nios2 || ppc64le || riscv || riscv64 || sh 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 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 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_darwin.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 unix 6 | 7 | import "unsafe" 8 | 9 | // FcntlInt performs a fcntl syscall on fd with the provided command and argument. 10 | func FcntlInt(fd uintptr, cmd, arg int) (int, error) { 11 | return fcntl(int(fd), cmd, arg) 12 | } 13 | 14 | // FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command. 15 | func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error { 16 | _, err := fcntl(int(fd), cmd, int(uintptr(unsafe.Pointer(lk)))) 17 | return err 18 | } 19 | 20 | // FcntlFstore performs a fcntl syscall for the F_PREALLOCATE command. 21 | func FcntlFstore(fd uintptr, cmd int, fstore *Fstore_t) error { 22 | _, err := fcntl(int(fd), cmd, int(uintptr(unsafe.Pointer(fstore)))) 23 | return err 24 | } 25 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/fcntl_linux_32bit.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 | //go:build (linux && 386) || (linux && arm) || (linux && mips) || (linux && mipsle) || (linux && ppc) 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/fdset.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 6 | 7 | package unix 8 | 9 | // Set adds fd to the set fds. 10 | func (fds *FdSet) Set(fd int) { 11 | fds.Bits[fd/NFDBITS] |= (1 << (uintptr(fd) % NFDBITS)) 12 | } 13 | 14 | // Clear removes fd from the set fds. 15 | func (fds *FdSet) Clear(fd int) { 16 | fds.Bits[fd/NFDBITS] &^= (1 << (uintptr(fd) % NFDBITS)) 17 | } 18 | 19 | // IsSet returns whether fd is in the set fds. 20 | func (fds *FdSet) IsSet(fd int) bool { 21 | return fds.Bits[fd/NFDBITS]&(1<<(uintptr(fd)%NFDBITS)) != 0 22 | } 23 | 24 | // Zero clears the set fds. 25 | func (fds *FdSet) Zero() { 26 | for i := range fds.Bits { 27 | fds.Bits[i] = 0 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /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 | //go: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/mmap_nomremap.go: -------------------------------------------------------------------------------- 1 | // Copyright 2023 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 | //go:build aix || darwin || dragonfly || freebsd || openbsd || solaris || zos 6 | 7 | package unix 8 | 9 | var mapper = &mmapper{ 10 | active: make(map[*byte][]byte), 11 | mmap: mmap, 12 | munmap: munmap, 13 | } 14 | -------------------------------------------------------------------------------- /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 | //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos 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/ptrace_darwin.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 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 | //go:build darwin && !ios 6 | 7 | package unix 8 | 9 | func ptrace(request int, pid int, addr uintptr, data uintptr) error { 10 | return ptrace1(request, pid, addr, data) 11 | } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/ptrace_ios.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 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 | //go:build ios 6 | 7 | package unix 8 | 9 | func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) { 10 | return ENOTSUP 11 | } 12 | -------------------------------------------------------------------------------- /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 | //go: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 | //go:build aix || (darwin && !race) || (linux && !race) || (freebsd && !race) || netbsd || openbsd || solaris || dragonfly || zos 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/readdirent_getdents.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 | //go:build aix || dragonfly || freebsd || linux || netbsd || openbsd 6 | 7 | package unix 8 | 9 | // ReadDirent reads directory entries from fd and writes them into buf. 10 | func ReadDirent(fd int, buf []byte) (n int, err error) { 11 | return Getdents(fd, buf) 12 | } 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/readdirent_getdirentries.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 | //go:build darwin || zos 6 | 7 | package unix 8 | 9 | import "unsafe" 10 | 11 | // ReadDirent reads directory entries from fd and writes them into buf. 12 | func ReadDirent(fd int, buf []byte) (n int, err error) { 13 | // Final argument is (basep *uintptr) and the syscall doesn't take nil. 14 | // 64 bits should be enough. (32 bits isn't even on 386). Since the 15 | // actual system call is getdirentries64, 64 is a good guess. 16 | // TODO(rsc): Can we use a single global basep for all calls? 17 | var base = (*uintptr)(unsafe.Pointer(new(uint64))) 18 | return Getdirentries(fd, buf, base) 19 | } 20 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/sockcmsg_dragonfly.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 unix 6 | 7 | // Round the length of a raw sockaddr up to align it properly. 8 | func cmsgAlignOf(salen int) int { 9 | salign := SizeofPtr 10 | if SizeofPtr == 8 && !supportsABI(_dragonflyABIChangeVersion) { 11 | // 64-bit Dragonfly before the September 2019 ABI changes still requires 12 | // 32-bit aligned access to network subsystem. 13 | salign = 4 14 | } 15 | return (salen + salign - 1) & ^(salign - 1) 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_hurd.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 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 | //go:build hurd 6 | 7 | package unix 8 | 9 | /* 10 | #include 11 | int ioctl(int, unsigned long int, uintptr_t); 12 | */ 13 | import "C" 14 | 15 | func ioctl(fd int, req uint, arg uintptr) (err error) { 16 | r0, er := C.ioctl(C.int(fd), C.ulong(req), C.uintptr_t(arg)) 17 | if r0 == -1 && er != nil { 18 | err = er 19 | } 20 | return 21 | } 22 | 23 | func ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) { 24 | r0, er := C.ioctl(C.int(fd), C.ulong(req), C.uintptr_t(uintptr(arg))) 25 | if r0 == -1 && er != nil { 26 | err = er 27 | } 28 | return 29 | } 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_hurd_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 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 | //go:build 386 && hurd 6 | 7 | package unix 8 | 9 | const ( 10 | TIOCGETA = 0x62251713 11 | ) 12 | 13 | type Winsize struct { 14 | Row uint16 15 | Col uint16 16 | Xpixel uint16 17 | Ypixel uint16 18 | } 19 | 20 | type Termios struct { 21 | Iflag uint32 22 | Oflag uint32 23 | Cflag uint32 24 | Lflag uint32 25 | Cc [20]uint8 26 | Ispeed int32 27 | Ospeed int32 28 | } 29 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_alarm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 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 | //go:build linux && (386 || amd64 || mips || mipsle || mips64 || mipsle || ppc64 || ppc64le || ppc || s390x || sparc64) 6 | 7 | package unix 8 | 9 | // SYS_ALARM is not defined on arm or riscv, but is available for other GOARCH 10 | // values. 11 | 12 | //sys Alarm(seconds uint) (remaining uint, err error) 13 | -------------------------------------------------------------------------------- /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 | //go:build amd64 && linux && gc 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | //go:noescape 12 | func gettimeofday(tv *Timeval) (err syscall.Errno) 13 | -------------------------------------------------------------------------------- /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 | //go:build linux && gc 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 | //go:build linux && gc && 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_gc_arm.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 | //go:build arm && gc && linux 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 | -------------------------------------------------------------------------------- /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 | //go: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 | //go: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 (msghdr *Msghdr) SetIovlen(length int) { 22 | msghdr.Iovlen = int32(length) 23 | } 24 | 25 | func (cmsg *Cmsghdr) SetLen(length int) { 26 | cmsg.Len = uint32(length) 27 | } 28 | -------------------------------------------------------------------------------- /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 | //go:build (darwin || dragonfly || freebsd || (linux && !ppc64 && !ppc64le) || netbsd || openbsd || solaris) && gc 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) 12 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) 13 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) 14 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) 15 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_unix_gc_ppc64x.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 | //go:build linux && (ppc64le || ppc64) && gc 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) { 12 | return syscall.Syscall(trap, a1, a2, a3) 13 | } 14 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) { 15 | return syscall.Syscall6(trap, a1, a2, a3, a4, a5, a6) 16 | } 17 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) { 18 | return syscall.RawSyscall(trap, a1, a2, a3) 19 | } 20 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) { 21 | return syscall.RawSyscall6(trap, a1, a2, a3, a4, a5, a6) 22 | } 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/sysvshm_linux.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 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 | //go:build linux 6 | 7 | package unix 8 | 9 | import "runtime" 10 | 11 | // SysvShmCtl performs control operations on the shared memory segment 12 | // specified by id. 13 | func SysvShmCtl(id, cmd int, desc *SysvShmDesc) (result int, err error) { 14 | if runtime.GOARCH == "arm" || 15 | runtime.GOARCH == "mips64" || runtime.GOARCH == "mips64le" { 16 | cmd |= ipc_64 17 | } 18 | 19 | return shmctl(id, cmd, desc) 20 | } 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/sysvshm_unix_other.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 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 | //go:build (darwin && !ios) || zos 6 | 7 | package unix 8 | 9 | // SysvShmCtl performs control operations on the shared memory segment 10 | // specified by id. 11 | func SysvShmCtl(id, cmd int, desc *SysvShmDesc) (result int, err error) { 12 | return shmctl(id, cmd, desc) 13 | } 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/zptrace_linux_arm64.go: -------------------------------------------------------------------------------- 1 | // Code generated by linux/mkall.go generatePtraceRegSet("arm64"). DO NOT EDIT. 2 | 3 | package unix 4 | 5 | import "unsafe" 6 | 7 | // PtraceGetRegSetArm64 fetches the registers used by arm64 binaries. 8 | func PtraceGetRegSetArm64(pid, addr int, regsout *PtraceRegsArm64) error { 9 | iovec := Iovec{(*byte)(unsafe.Pointer(regsout)), uint64(unsafe.Sizeof(*regsout))} 10 | return ptracePtr(PTRACE_GETREGSET, pid, uintptr(addr), unsafe.Pointer(&iovec)) 11 | } 12 | 13 | // PtraceSetRegSetArm64 sets the registers used by arm64 binaries. 14 | func PtraceSetRegSetArm64(pid, addr int, regs *PtraceRegsArm64) error { 15 | iovec := Iovec{(*byte)(unsafe.Pointer(regs)), uint64(unsafe.Sizeof(*regs))} 16 | return ptracePtr(PTRACE_SETREGSET, pid, uintptr(addr), unsafe.Pointer(&iovec)) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/aliases.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 | //go:build windows 6 | 7 | package windows 8 | 9 | import "syscall" 10 | 11 | type Errno = syscall.Errno 12 | type SysProcAttr = syscall.SysProcAttr 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/eventlog.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 | //go:build windows 6 | 7 | package windows 8 | 9 | const ( 10 | EVENTLOG_SUCCESS = 0 11 | EVENTLOG_ERROR_TYPE = 1 12 | EVENTLOG_WARNING_TYPE = 2 13 | EVENTLOG_INFORMATION_TYPE = 4 14 | EVENTLOG_AUDIT_SUCCESS = 8 15 | EVENTLOG_AUDIT_FAILURE = 16 16 | ) 17 | 18 | //sys RegisterEventSource(uncServerName *uint16, sourceName *uint16) (handle Handle, err error) [failretval==0] = advapi32.RegisterEventSourceW 19 | //sys DeregisterEventSource(handle Handle) (err error) = advapi32.DeregisterEventSource 20 | //sys ReportEvent(log Handle, etype uint16, category uint16, eventId uint32, usrSId uintptr, numStrings uint16, dataSize uint32, strings **uint16, rawData *byte) (err error) = advapi32.ReportEventW 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/mksyscall.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 | //go:build generate 6 | 7 | package windows 8 | 9 | //go:generate go run golang.org/x/sys/windows/mkwinsyscall -output zsyscall_windows.go eventlog.go service.go syscall_windows.go security_windows.go setupapi_windows.go 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/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 | //go:build windows && race 6 | 7 | package windows 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/windows/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 | //go:build windows && !race 6 | 7 | package windows 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/windows/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 | //go:build windows 6 | 7 | package windows 8 | 9 | func itoa(val int) string { // do it here rather than with fmt to avoid dependency 10 | if val < 0 { 11 | return "-" + itoa(-val) 12 | } 13 | var buf [32]byte // big enough for int64 14 | i := len(buf) - 1 15 | for val >= 10 { 16 | buf[i] = byte(val%10 + '0') 17 | i-- 18 | val /= 10 19 | } 20 | buf[i] = byte(val + '0') 21 | return string(buf[i:]) 22 | } 23 | -------------------------------------------------------------------------------- /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/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 | //go:build go1.10 6 | // +build go1.10 7 | 8 | package bidirule 9 | 10 | func (t *Transformer) isFinal() bool { 11 | return t.state == ruleLTRFinal || t.state == ruleRTLFinal || t.state == ruleInitial 12 | } 13 | -------------------------------------------------------------------------------- /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 | //go:build !go1.10 6 | // +build !go1.10 7 | 8 | package bidirule 9 | 10 | func (t *Transformer) isFinal() bool { 11 | if !t.isRTL() { 12 | return true 13 | } 14 | return t.state == ruleLTRFinal || t.state == ruleRTLFinal || t.state == ruleInitial 15 | } 16 | -------------------------------------------------------------------------------- /vendor/google.golang.org/appengine/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | go_import_path: google.golang.org/appengine 4 | 5 | install: 6 | - ./travis_install.sh 7 | 8 | script: 9 | - ./travis_test.sh 10 | 11 | matrix: 12 | include: 13 | - go: 1.9.x 14 | env: GOAPP=true 15 | - go: 1.10.x 16 | env: GOAPP=false 17 | - go: 1.11.x 18 | env: GO111MODULE=on 19 | -------------------------------------------------------------------------------- /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_flex.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 Google LLC. 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 appenginevm 6 | 7 | package internal 8 | 9 | func init() { 10 | appengineFlex = true 11 | } 12 | -------------------------------------------------------------------------------- /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 | MainPath = "" 15 | appengine_internal.Main() 16 | } 17 | -------------------------------------------------------------------------------- /vendor/google.golang.org/appengine/internal/main_common.go: -------------------------------------------------------------------------------- 1 | package internal 2 | 3 | // MainPath stores the file path of the main package. On App Engine Standard 4 | // using Go version 1.9 and below, this will be unset. On App Engine Flex and 5 | // App Engine Standard second-gen (Go 1.11 and above), this will be the 6 | // filepath to package main. 7 | var MainPath string 8 | -------------------------------------------------------------------------------- /vendor/google.golang.org/appengine/namespace.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 appengine 6 | 7 | import ( 8 | "fmt" 9 | "regexp" 10 | 11 | "golang.org/x/net/context" 12 | 13 | "google.golang.org/appengine/internal" 14 | ) 15 | 16 | // Namespace returns a replacement context that operates within the given namespace. 17 | func Namespace(c context.Context, namespace string) (context.Context, error) { 18 | if !validNamespace.MatchString(namespace) { 19 | return nil, fmt.Errorf("appengine: namespace %q does not match /%s/", namespace, validNamespace) 20 | } 21 | return internal.NamespacedContext(c, namespace), nil 22 | } 23 | 24 | // validNamespace matches valid namespace names. 25 | var validNamespace = regexp.MustCompile(`^[0-9A-Za-z._-]{0,100}$`) 26 | -------------------------------------------------------------------------------- /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/appengine/travis_install.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | set -e 3 | 4 | if [[ $GO111MODULE == "on" ]]; then 5 | go get . 6 | else 7 | go get -u -v $(go list -f '{{join .Imports "\n"}}{{"\n"}}{{join .TestImports "\n"}}' ./... | sort | uniq | grep -v appengine) 8 | fi 9 | 10 | if [[ $GOAPP == "true" ]]; then 11 | mkdir /tmp/sdk 12 | curl -o /tmp/sdk.zip "https://storage.googleapis.com/appengine-sdks/featured/go_appengine_sdk_linux_amd64-1.9.68.zip" 13 | unzip -q /tmp/sdk.zip -d /tmp/sdk 14 | # NOTE: Set the following env vars in the test script: 15 | # export PATH="$PATH:/tmp/sdk/go_appengine" 16 | # export APPENGINE_DEV_APPSERVER=/tmp/sdk/go_appengine/dev_appserver.py 17 | fi 18 | 19 | -------------------------------------------------------------------------------- /vendor/google.golang.org/appengine/travis_test.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | set -e 3 | 4 | go version 5 | go test -v google.golang.org/appengine/... 6 | go test -v -race google.golang.org/appengine/... 7 | if [[ $GOAPP == "true" ]]; then 8 | export PATH="$PATH:/tmp/sdk/go_appengine" 9 | export APPENGINE_DEV_APPSERVER=/tmp/sdk/go_appengine/dev_appserver.py 10 | goapp version 11 | goapp test -v google.golang.org/appengine/... 12 | fi 13 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/AUTHORS: -------------------------------------------------------------------------------- 1 | Google Inc. 2 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/CODE-OF-CONDUCT.md: -------------------------------------------------------------------------------- 1 | ## Community Code of Conduct 2 | 3 | gRPC follows the [CNCF Code of Conduct](https://github.com/cncf/foundation/blob/master/code-of-conduct.md). 4 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/GOVERNANCE.md: -------------------------------------------------------------------------------- 1 | This repository is governed by the gRPC organization's [governance rules](https://github.com/grpc/grpc-community/blob/master/governance.md). 2 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/NOTICE.txt: -------------------------------------------------------------------------------- 1 | Copyright 2014 gRPC 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 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/SECURITY.md: -------------------------------------------------------------------------------- 1 | # Security Policy 2 | 3 | For information on gRPC Security Policy and reporting potentional security issues, please see [gRPC CVE Process](https://github.com/grpc/proposal/blob/master/P4-grpc-cve-process.md). 4 | -------------------------------------------------------------------------------- /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/doc.go: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright 2015 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 | //go:generate ./regenerate.sh 20 | 21 | /* 22 | Package grpc implements an RPC system called gRPC. 23 | 24 | See grpc.io for more information about gRPC. 25 | */ 26 | package grpc // import "google.golang.org/grpc" 27 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/health/logging.go: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright 2020 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 health 20 | 21 | import "google.golang.org/grpc/grpclog" 22 | 23 | var logger = grpclog.Component("health_service") 24 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/internal/channelz/util_nonlinux.go: -------------------------------------------------------------------------------- 1 | //go:build !linux 2 | // +build !linux 3 | 4 | /* 5 | * 6 | * Copyright 2018 gRPC authors. 7 | * 8 | * Licensed under the Apache License, Version 2.0 (the "License"); 9 | * you may not use this file except in compliance with the License. 10 | * You may obtain a copy of the License at 11 | * 12 | * http://www.apache.org/licenses/LICENSE-2.0 13 | * 14 | * Unless required by applicable law or agreed to in writing, software 15 | * distributed under the License is distributed on an "AS IS" BASIS, 16 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 17 | * See the License for the specific language governing permissions and 18 | * limitations under the License. 19 | * 20 | */ 21 | 22 | package channelz 23 | 24 | // GetSocketOption gets the socket option info of the conn. 25 | func GetSocketOption(c interface{}) *SocketOptionData { 26 | return nil 27 | } 28 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/internal/grpcutil/grpcutil.go: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * Copyright 2021 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 grpcutil provides utility functions used across the gRPC codebase. 20 | package grpcutil 21 | -------------------------------------------------------------------------------- /vendor/google.golang.org/grpc/reflection/README.md: -------------------------------------------------------------------------------- 1 | # Reflection 2 | 3 | Package reflection implements server reflection service. 4 | 5 | The service implemented is defined in: https://github.com/grpc/grpc/blob/master/src/proto/grpc/reflection/v1alpha/reflection.proto. 6 | 7 | To register server reflection on a gRPC server: 8 | ```go 9 | import "google.golang.org/grpc/reflection" 10 | 11 | s := grpc.NewServer() 12 | pb.RegisterYourOwnServer(s, &server{}) 13 | 14 | // Register reflection service on gRPC server. 15 | reflection.Register(s) 16 | 17 | s.Serve(lis) 18 | ``` 19 | -------------------------------------------------------------------------------- /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.46.0" 23 | -------------------------------------------------------------------------------- /vendor/google.golang.org/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 https://tip.golang.org/AUTHORS. 4 | -------------------------------------------------------------------------------- /vendor/google.golang.org/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 https://tip.golang.org/CONTRIBUTORS. 4 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/encoding/protojson/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 protojson marshals and unmarshals protocol buffer messages as JSON 6 | // format. It follows the guide at 7 | // https://developers.google.com/protocol-buffers/docs/proto3#json. 8 | // 9 | // This package produces a different output than the standard "encoding/json" 10 | // package, which does not operate correctly on protocol buffer messages. 11 | package protojson 12 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/encoding/prototext/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 prototext marshals and unmarshals protocol buffer messages as the 6 | // textproto format. 7 | package prototext 8 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/errors/is_go113.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 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 | //go:build go1.13 6 | // +build go1.13 7 | 8 | package errors 9 | 10 | import "errors" 11 | 12 | // Is is errors.Is. 13 | func Is(err, target error) bool { return errors.Is(err, target) } 14 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/flags/proto_legacy_disable.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 | //go:build !protolegacy 6 | // +build !protolegacy 7 | 8 | package flags 9 | 10 | const protoLegacy = false 11 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/flags/proto_legacy_enable.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 | //go:build protolegacy 6 | // +build protolegacy 7 | 8 | package flags 9 | 10 | const protoLegacy = true 11 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/genid/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 genid contains constants for declarations in descriptor.proto 6 | // and the well-known types. 7 | package genid 8 | 9 | import protoreflect "google.golang.org/protobuf/reflect/protoreflect" 10 | 11 | const GoogleProtobuf_package protoreflect.FullName = "google.protobuf" 12 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/genid/empty_gen.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 | // Code generated by generate-protos. DO NOT EDIT. 6 | 7 | package genid 8 | 9 | import ( 10 | protoreflect "google.golang.org/protobuf/reflect/protoreflect" 11 | ) 12 | 13 | const File_google_protobuf_empty_proto = "google/protobuf/empty.proto" 14 | 15 | // Names for google.protobuf.Empty. 16 | const ( 17 | Empty_message_name protoreflect.Name = "Empty" 18 | Empty_message_fullname protoreflect.FullName = "google.protobuf.Empty" 19 | ) 20 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/genid/goname.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 genid 6 | 7 | // Go names of implementation-specific struct fields in generated messages. 8 | const ( 9 | State_goname = "state" 10 | 11 | SizeCache_goname = "sizeCache" 12 | SizeCacheA_goname = "XXX_sizecache" 13 | 14 | WeakFields_goname = "weakFields" 15 | WeakFieldsA_goname = "XXX_weak" 16 | 17 | UnknownFields_goname = "unknownFields" 18 | UnknownFieldsA_goname = "XXX_unrecognized" 19 | 20 | ExtensionFields_goname = "extensionFields" 21 | ExtensionFieldsA_goname = "XXX_InternalExtensions" 22 | ExtensionFieldsB_goname = "XXX_extensions" 23 | 24 | WeakFieldPrefix_goname = "XXX_weak_" 25 | ) 26 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/genid/map_entry.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 genid 6 | 7 | import protoreflect "google.golang.org/protobuf/reflect/protoreflect" 8 | 9 | // Generic field names and numbers for synthetic map entry messages. 10 | const ( 11 | MapEntry_Key_field_name protoreflect.Name = "key" 12 | MapEntry_Value_field_name protoreflect.Name = "value" 13 | 14 | MapEntry_Key_field_number protoreflect.FieldNumber = 1 15 | MapEntry_Value_field_number protoreflect.FieldNumber = 2 16 | ) 17 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/genid/wrappers.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 genid 6 | 7 | import protoreflect "google.golang.org/protobuf/reflect/protoreflect" 8 | 9 | // Generic field name and number for messages in wrappers.proto. 10 | const ( 11 | WrapperValue_Value_field_name protoreflect.Name = "value" 12 | WrapperValue_Value_field_number protoreflect.FieldNumber = 1 13 | ) 14 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/impl/codec_map_go111.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 | //go:build !go1.12 6 | // +build !go1.12 7 | 8 | package impl 9 | 10 | import "reflect" 11 | 12 | type mapIter struct { 13 | v reflect.Value 14 | keys []reflect.Value 15 | } 16 | 17 | // mapRange provides a less-efficient equivalent to 18 | // the Go 1.12 reflect.Value.MapRange method. 19 | func mapRange(v reflect.Value) *mapIter { 20 | return &mapIter{v: v} 21 | } 22 | 23 | func (i *mapIter) Next() bool { 24 | if i.keys == nil { 25 | i.keys = i.v.MapKeys() 26 | } else { 27 | i.keys = i.keys[1:] 28 | } 29 | return len(i.keys) > 0 30 | } 31 | 32 | func (i *mapIter) Key() reflect.Value { 33 | return i.keys[0] 34 | } 35 | 36 | func (i *mapIter) Value() reflect.Value { 37 | return i.v.MapIndex(i.keys[0]) 38 | } 39 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/impl/codec_map_go112.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 | //go:build go1.12 6 | // +build go1.12 7 | 8 | package impl 9 | 10 | import "reflect" 11 | 12 | func mapRange(v reflect.Value) *reflect.MapIter { return v.MapRange() } 13 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/impl/codec_unsafe.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 | //go:build !purego && !appengine 6 | // +build !purego,!appengine 7 | 8 | package impl 9 | 10 | // When using unsafe pointers, we can just treat enum values as int32s. 11 | 12 | var ( 13 | coderEnumNoZero = coderInt32NoZero 14 | coderEnum = coderInt32 15 | coderEnumPtr = coderInt32Ptr 16 | coderEnumSlice = coderInt32Slice 17 | coderEnumPackedSlice = coderInt32PackedSlice 18 | ) 19 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/impl/enum.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 impl 6 | 7 | import ( 8 | "reflect" 9 | 10 | pref "google.golang.org/protobuf/reflect/protoreflect" 11 | ) 12 | 13 | type EnumInfo struct { 14 | GoReflectType reflect.Type // int32 kind 15 | Desc pref.EnumDescriptor 16 | } 17 | 18 | func (t *EnumInfo) New(n pref.EnumNumber) pref.Enum { 19 | return reflect.ValueOf(n).Convert(t.GoReflectType).Interface().(pref.Enum) 20 | } 21 | func (t *EnumInfo) Descriptor() pref.EnumDescriptor { return t.Desc } 22 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/internal/strs/strings_pure.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 | //go:build purego || appengine 6 | // +build purego appengine 7 | 8 | package strs 9 | 10 | import pref "google.golang.org/protobuf/reflect/protoreflect" 11 | 12 | func UnsafeString(b []byte) string { 13 | return string(b) 14 | } 15 | 16 | func UnsafeBytes(s string) []byte { 17 | return []byte(s) 18 | } 19 | 20 | type Builder struct{} 21 | 22 | func (*Builder) AppendFullName(prefix pref.FullName, name pref.Name) pref.FullName { 23 | return prefix.Append(name) 24 | } 25 | 26 | func (*Builder) MakeString(b []byte) string { 27 | return string(b) 28 | } 29 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/proto/proto_methods.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 | // The protoreflect build tag disables use of fast-path methods. 6 | //go:build !protoreflect 7 | // +build !protoreflect 8 | 9 | package proto 10 | 11 | import ( 12 | "google.golang.org/protobuf/reflect/protoreflect" 13 | "google.golang.org/protobuf/runtime/protoiface" 14 | ) 15 | 16 | const hasProtoMethods = true 17 | 18 | func protoMethods(m protoreflect.Message) *protoiface.Methods { 19 | return m.ProtoMethods() 20 | } 21 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/proto/proto_reflect.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 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 | // The protoreflect build tag disables use of fast-path methods. 6 | //go:build protoreflect 7 | // +build protoreflect 8 | 9 | package proto 10 | 11 | import ( 12 | "google.golang.org/protobuf/reflect/protoreflect" 13 | "google.golang.org/protobuf/runtime/protoiface" 14 | ) 15 | 16 | const hasProtoMethods = false 17 | 18 | func protoMethods(m protoreflect.Message) *protoiface.Methods { 19 | return nil 20 | } 21 | -------------------------------------------------------------------------------- /vendor/google.golang.org/protobuf/runtime/protoiface/legacy.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 | package protoiface 6 | 7 | type MessageV1 interface { 8 | Reset() 9 | String() string 10 | ProtoMessage() 11 | } 12 | 13 | type ExtensionRangeV1 struct { 14 | Start, End int32 // both inclusive 15 | } 16 | --------------------------------------------------------------------------------