├── .dockerignore ├── .github └── pull_request_template.md ├── .gitignore ├── .gitlab-ci.yml ├── .godir ├── .travis.yml ├── CHANGELOG.md ├── CONTRIBUTING.md ├── Dockerfile ├── LICENSE ├── MAINTAINERS ├── Makefile ├── Makefile.inc ├── README.md ├── ROADMAP.md ├── appveyor.yml ├── circle.yml ├── cmd └── docker-machine │ ├── machine.go │ └── machine_test.go ├── commands ├── active.go ├── active_test.go ├── commands.go ├── commands_test.go ├── commandstest │ ├── fake_command_line.go │ └── stdout_capture.go ├── config.go ├── create.go ├── create_test.go ├── env.go ├── env_test.go ├── flag_sort.go ├── inspect.go ├── inspect_test.go ├── ip.go ├── ip_test.go ├── kill.go ├── kill_test.go ├── ls.go ├── ls_test.go ├── mcndirs │ ├── utils.go │ └── utils_test.go ├── mount.go ├── mount_test.go ├── provision.go ├── provision_test.go ├── regeneratecerts.go ├── restart.go ├── rm.go ├── rm_test.go ├── scp.go ├── scp_test.go ├── scp_unix.go ├── scp_windows.go ├── ssh.go ├── ssh_test.go ├── start.go ├── status.go ├── stop.go ├── stop_test.go ├── upgrade.go ├── url.go ├── url_test.go ├── version.go └── version_test.go ├── contrib └── completion │ ├── .gitignore │ ├── bash │ ├── docker-machine-prompt.bash │ ├── docker-machine-wrapper.bash │ └── docker-machine.bash │ └── zsh │ └── _docker-machine ├── doc.go ├── docs └── README.md ├── drivers ├── amazonec2 │ ├── amazonec2.go │ ├── amazonec2_test.go │ ├── awscredentials.go │ ├── awscredentials_test.go │ ├── ec2client.go │ ├── logger.go │ ├── region.go │ └── stub_test.go ├── azure │ ├── azure.go │ ├── azureutil │ │ ├── auth.go │ │ ├── authorizer.go │ │ ├── azureutil.go │ │ ├── cleanup.go │ │ ├── clients.go │ │ ├── context.go │ │ ├── inspector.go │ │ ├── naming.go │ │ ├── powerstate.go │ │ ├── tenantid.go │ │ └── util.go │ ├── logutil │ │ └── logfields.go │ ├── util.go │ └── util_test.go ├── digitalocean │ ├── digitalocean.go │ └── digitalocean_test.go ├── driverutil │ ├── util.go │ └── util_test.go ├── errdriver │ └── error.go ├── exoscale │ ├── exoscale.go │ └── exoscale_test.go ├── fakedriver │ └── fakedriver.go ├── generic │ ├── generic.go │ └── generic_test.go ├── google │ ├── compute_util.go │ ├── compute_util_test.go │ ├── google.go │ └── google_test.go ├── hyperv │ ├── hyperv.go │ ├── hyperv_test.go │ └── powershell.go ├── none │ └── driver.go ├── openstack │ ├── client.go │ ├── openstack.go │ └── openstack_test.go ├── rackspace │ ├── client.go │ ├── rackspace.go │ └── rackspace_test.go ├── softlayer │ ├── driver.go │ ├── driver_test.go │ └── softlayer.go ├── virtualbox │ ├── disk.go │ ├── disk_test.go │ ├── ip.go │ ├── misc.go │ ├── network.go │ ├── network_test.go │ ├── vbm.go │ ├── vbm_test.go │ ├── virtualbox.go │ ├── virtualbox_darwin.go │ ├── virtualbox_darwin_test.go │ ├── virtualbox_freebsd.go │ ├── virtualbox_linux.go │ ├── virtualbox_linux_test.go │ ├── virtualbox_openbsd.go │ ├── virtualbox_test.go │ ├── virtualbox_windows.go │ ├── vm.go │ ├── vm_test.go │ ├── vtx.go │ ├── vtx_intel.go │ ├── vtx_other.go │ └── vtx_test.go ├── vmwarefusion │ ├── fusion.go │ ├── fusion_darwin.go │ ├── fusion_darwin_test.go │ ├── vmrun_darwin.go │ └── vmx_darwin.go ├── vmwarevcloudair │ ├── vcloudair.go │ └── vcloudlair_test.go └── vmwarevsphere │ ├── vsphere.go │ └── vsphere_test.go ├── experimental ├── README.md ├── b2d_migration.md └── b2d_migration_tasks.md ├── go.mod ├── go.sum ├── its ├── cli │ ├── create_rm_test.go │ ├── driver_help_test.go │ ├── help_test.go │ ├── inspect_test.go │ ├── ls_test.go │ ├── status_test.go │ └── url_test.go ├── tester.go └── thirdparty │ └── commands_test.go ├── libmachine ├── auth │ └── auth.go ├── cert │ ├── bootstrap.go │ ├── cert.go │ └── cert_test.go ├── check │ ├── check.go │ └── check_test.go ├── crashreport │ ├── crash_report.go │ ├── crash_report_logger.go │ ├── crash_report_test.go │ ├── os_darwin.go │ ├── os_freebsd.go │ ├── os_linux.go │ ├── os_openbsd.go │ ├── os_windows.go │ └── os_windows_test.go ├── drivers │ ├── base.go │ ├── base_test.go │ ├── check.go │ ├── drivers.go │ ├── notsupported.go │ ├── plugin │ │ ├── localbinary │ │ │ ├── plugin.go │ │ │ └── plugin_test.go │ │ └── register_driver.go │ ├── rpc │ │ ├── client_driver.go │ │ ├── server_driver.go │ │ └── server_driver_test.go │ ├── serial.go │ ├── serial_test.go │ └── utils.go ├── engine │ └── engine.go ├── examples │ └── main.go ├── host │ ├── host.go │ ├── host_test.go │ ├── host_v0.go │ ├── host_v2.go │ ├── migrate.go │ ├── migrate_test.go │ ├── migrate_v0_v1.go │ ├── migrate_v0_v1_test.go │ ├── migrate_v0_v3_test.go │ ├── migrate_v1_v2.go │ ├── migrate_v1_v2_test.go │ └── migrate_v2_v3.go ├── hosttest │ └── default_test_host.go ├── libmachine.go ├── libmachinetest │ └── fake_api.go ├── log │ ├── fmt_machine_logger.go │ ├── fmt_machine_logger_test.go │ ├── history_recorder.go │ ├── history_recorder_test.go │ ├── log.go │ ├── log_test.go │ └── machine_logger.go ├── mcndockerclient │ ├── docker_client.go │ ├── docker_host.go │ ├── docker_versioner.go │ └── fake_docker_versioner.go ├── mcnerror │ └── errors.go ├── mcnflag │ └── flag.go ├── mcnutils │ ├── b2d.go │ ├── b2d_test.go │ ├── utils.go │ └── utils_test.go ├── persist │ ├── filestore.go │ ├── filestore_test.go │ ├── persisttest │ │ ├── fakestore.go │ │ └── fakestore_test.go │ └── store.go ├── provider │ └── provider.go ├── provision │ ├── arch.go │ ├── arch_test.go │ ├── boot2docker.go │ ├── centos.go │ ├── configure_swarm.go │ ├── coreos.go │ ├── debian.go │ ├── debian_test.go │ ├── engine_config_context.go │ ├── errors.go │ ├── fake_provisioner.go │ ├── fedora.go │ ├── generic.go │ ├── oraclelinux.go │ ├── os_release.go │ ├── os_release_test.go │ ├── pkgaction │ │ ├── pkg_action.go │ │ └── pkg_action_test.go │ ├── provisioner.go │ ├── provisiontest │ │ ├── sshcommander.go │ │ └── sshcommander_test.go │ ├── rancheros.go │ ├── redhat.go │ ├── redhat_ssh_commander.go │ ├── redhat_test.go │ ├── serviceaction │ │ ├── service_action.go │ │ └── service_action_test.go │ ├── suse.go │ ├── systemd.go │ ├── ubuntu_systemd.go │ ├── ubuntu_systemd_test.go │ ├── ubuntu_upstart.go │ ├── ubuntu_upstart_test.go │ ├── utils.go │ └── utils_test.go ├── shell │ ├── shell.go │ ├── shell_test.go │ ├── shell_unix_test.go │ ├── shell_windows.go │ └── shell_windows_test.go ├── ssh │ ├── client.go │ ├── client_test.go │ ├── keys.go │ ├── keys_test.go │ ├── ssh_test.go │ └── sshtest │ │ └── fake_client.go ├── state │ ├── state.go │ └── state_test.go ├── swarm │ └── swarm.go ├── version │ └── version.go └── versioncmp │ ├── compare.go │ └── compare_test.go ├── mk ├── build.mk ├── coverage.mk ├── dev.mk ├── main.mk ├── test.mk └── validate.mk ├── script ├── .validate ├── build_in_container.sh ├── release.sh ├── release │ └── github-release-template.md └── validate-dco ├── test ├── integration │ ├── .gitignore │ ├── amazonec2 │ │ ├── amazon.bats │ │ ├── create-ebsinstance.bats │ │ └── createwithkeypair.bats │ ├── core │ │ ├── certs-extra-san.bats │ │ ├── core-commands.bats │ │ ├── crashreport.bats │ │ ├── engine-options.bats │ │ ├── env_shell.bats │ │ ├── inspect_format.bats │ │ ├── regenerate-certs.bats │ │ ├── scp.bats │ │ ├── ssh-backends.bats │ │ └── swarm-options.bats │ ├── helpers.bash │ ├── run-bats.sh │ └── virtualbox │ │ ├── certs-checksum.bats │ │ ├── create-with-upgrading.bats │ │ ├── custom-mem-disk.bats │ │ ├── dns.bats │ │ ├── guards.bats │ │ ├── pause-save-start.bats │ │ └── upgrade.bats └── provision │ ├── rancheros.bats │ └── redhat.bats ├── vendor ├── github.com │ ├── Azure │ │ ├── azure-sdk-for-go │ │ │ ├── LICENSE │ │ │ ├── arm │ │ │ │ ├── compute │ │ │ │ │ ├── availabilitysets.go │ │ │ │ │ ├── client.go │ │ │ │ │ ├── models.go │ │ │ │ │ ├── usageoperations.go │ │ │ │ │ ├── version.go │ │ │ │ │ ├── virtualmachineextensionimages.go │ │ │ │ │ ├── virtualmachineextensions.go │ │ │ │ │ ├── virtualmachineimages.go │ │ │ │ │ ├── virtualmachines.go │ │ │ │ │ ├── virtualmachinescalesets.go │ │ │ │ │ ├── virtualmachinescalesetvms.go │ │ │ │ │ └── virtualmachinesizes.go │ │ │ │ ├── network │ │ │ │ │ ├── applicationgateways.go │ │ │ │ │ ├── client.go │ │ │ │ │ ├── expressroutecircuitauthorizations.go │ │ │ │ │ ├── expressroutecircuitpeerings.go │ │ │ │ │ ├── expressroutecircuits.go │ │ │ │ │ ├── expressrouteserviceproviders.go │ │ │ │ │ ├── interfaces.go │ │ │ │ │ ├── loadbalancers.go │ │ │ │ │ ├── localnetworkgateways.go │ │ │ │ │ ├── models.go │ │ │ │ │ ├── publicipaddresses.go │ │ │ │ │ ├── routes.go │ │ │ │ │ ├── routetables.go │ │ │ │ │ ├── securitygroups.go │ │ │ │ │ ├── securityrules.go │ │ │ │ │ ├── subnets.go │ │ │ │ │ ├── usages.go │ │ │ │ │ ├── version.go │ │ │ │ │ ├── virtualnetworkgatewayconnections.go │ │ │ │ │ ├── virtualnetworkgateways.go │ │ │ │ │ ├── virtualnetworkpeerings.go │ │ │ │ │ └── virtualnetworks.go │ │ │ │ ├── resources │ │ │ │ │ ├── resources │ │ │ │ │ │ ├── client.go │ │ │ │ │ │ ├── deploymentoperations.go │ │ │ │ │ │ ├── deployments.go │ │ │ │ │ │ ├── groups.go │ │ │ │ │ │ ├── models.go │ │ │ │ │ │ ├── providers.go │ │ │ │ │ │ ├── resources.go │ │ │ │ │ │ ├── tags.go │ │ │ │ │ │ └── version.go │ │ │ │ │ └── subscriptions │ │ │ │ │ │ ├── client.go │ │ │ │ │ │ ├── models.go │ │ │ │ │ │ ├── subscriptions.go │ │ │ │ │ │ ├── tenants.go │ │ │ │ │ │ └── version.go │ │ │ │ └── storage │ │ │ │ │ ├── accounts.go │ │ │ │ │ ├── client.go │ │ │ │ │ ├── models.go │ │ │ │ │ ├── usageoperations.go │ │ │ │ │ └── version.go │ │ │ └── storage │ │ │ │ ├── README.md │ │ │ │ ├── blob.go │ │ │ │ ├── client.go │ │ │ │ ├── file.go │ │ │ │ ├── queue.go │ │ │ │ ├── table.go │ │ │ │ ├── table_entities.go │ │ │ │ └── util.go │ │ ├── go-ansiterm │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── constants.go │ │ │ ├── context.go │ │ │ ├── csi_entry_state.go │ │ │ ├── csi_param_state.go │ │ │ ├── escape_intermediate_state.go │ │ │ ├── escape_state.go │ │ │ ├── event_handler.go │ │ │ ├── ground_state.go │ │ │ ├── osc_string_state.go │ │ │ ├── parser.go │ │ │ ├── parser_action_helpers.go │ │ │ ├── parser_actions.go │ │ │ ├── states.go │ │ │ ├── utilities.go │ │ │ └── winterm │ │ │ │ ├── ansi.go │ │ │ │ ├── api.go │ │ │ │ ├── attr_translation.go │ │ │ │ ├── cursor_helpers.go │ │ │ │ ├── erase_helpers.go │ │ │ │ ├── scroll_helper.go │ │ │ │ ├── utilities.go │ │ │ │ └── win_event_handler.go │ │ └── go-autorest │ │ │ ├── LICENSE │ │ │ └── autorest │ │ │ ├── autorest.go │ │ │ ├── azure │ │ │ ├── async.go │ │ │ ├── azure.go │ │ │ ├── config.go │ │ │ ├── devicetoken.go │ │ │ ├── environments.go │ │ │ ├── persist.go │ │ │ └── token.go │ │ │ ├── client.go │ │ │ ├── date │ │ │ ├── date.go │ │ │ ├── time.go │ │ │ ├── timerfc1123.go │ │ │ └── utility.go │ │ │ ├── error.go │ │ │ ├── preparer.go │ │ │ ├── responder.go │ │ │ ├── sender.go │ │ │ ├── to │ │ │ └── convert.go │ │ │ ├── utility.go │ │ │ ├── validation │ │ │ └── validation.go │ │ │ └── version.go │ ├── aws │ │ └── aws-sdk-go │ │ │ ├── LICENSE.txt │ │ │ ├── NOTICE.txt │ │ │ ├── aws │ │ │ ├── awserr │ │ │ │ ├── error.go │ │ │ │ └── types.go │ │ │ ├── awsutil │ │ │ │ ├── copy.go │ │ │ │ ├── equal.go │ │ │ │ ├── path_value.go │ │ │ │ ├── prettify.go │ │ │ │ └── string_value.go │ │ │ ├── client │ │ │ │ ├── client.go │ │ │ │ ├── default_retryer.go │ │ │ │ └── metadata │ │ │ │ │ └── client_info.go │ │ │ ├── config.go │ │ │ ├── convert_types.go │ │ │ ├── corehandlers │ │ │ │ ├── handlers.go │ │ │ │ └── param_validator.go │ │ │ ├── credentials │ │ │ │ ├── chain_provider.go │ │ │ │ ├── credentials.go │ │ │ │ ├── ec2rolecreds │ │ │ │ │ └── ec2_role_provider.go │ │ │ │ ├── endpointcreds │ │ │ │ │ └── provider.go │ │ │ │ ├── env_provider.go │ │ │ │ ├── example.ini │ │ │ │ ├── shared_credentials_provider.go │ │ │ │ ├── static_provider.go │ │ │ │ └── stscreds │ │ │ │ │ └── assume_role_provider.go │ │ │ ├── defaults │ │ │ │ └── defaults.go │ │ │ ├── ec2metadata │ │ │ │ ├── api.go │ │ │ │ └── service.go │ │ │ ├── errors.go │ │ │ ├── logger.go │ │ │ ├── request │ │ │ │ ├── handlers.go │ │ │ │ ├── http_request.go │ │ │ │ ├── http_request_1_4.go │ │ │ │ ├── offset_reader.go │ │ │ │ ├── request.go │ │ │ │ ├── request_pagination.go │ │ │ │ ├── retryer.go │ │ │ │ └── validation.go │ │ │ ├── session │ │ │ │ ├── doc.go │ │ │ │ ├── env_config.go │ │ │ │ ├── session.go │ │ │ │ └── shared_config.go │ │ │ ├── signer │ │ │ │ └── v4 │ │ │ │ │ ├── header_rules.go │ │ │ │ │ └── v4.go │ │ │ ├── types.go │ │ │ └── version.go │ │ │ ├── private │ │ │ ├── endpoints │ │ │ │ ├── endpoints.go │ │ │ │ ├── endpoints.json │ │ │ │ └── endpoints_map.go │ │ │ ├── protocol │ │ │ │ ├── ec2query │ │ │ │ │ ├── build.go │ │ │ │ │ └── unmarshal.go │ │ │ │ ├── idempotency.go │ │ │ │ ├── query │ │ │ │ │ ├── build.go │ │ │ │ │ ├── queryutil │ │ │ │ │ │ └── queryutil.go │ │ │ │ │ ├── unmarshal.go │ │ │ │ │ └── unmarshal_error.go │ │ │ │ ├── rest │ │ │ │ │ ├── build.go │ │ │ │ │ ├── payload.go │ │ │ │ │ └── unmarshal.go │ │ │ │ ├── unmarshal.go │ │ │ │ └── xml │ │ │ │ │ └── xmlutil │ │ │ │ │ ├── build.go │ │ │ │ │ ├── unmarshal.go │ │ │ │ │ └── xml_to_struct.go │ │ │ └── waiter │ │ │ │ └── waiter.go │ │ │ └── service │ │ │ ├── ec2 │ │ │ ├── api.go │ │ │ ├── customizations.go │ │ │ ├── service.go │ │ │ └── waiters.go │ │ │ └── sts │ │ │ ├── api.go │ │ │ ├── customizations.go │ │ │ └── service.go │ ├── bugsnag │ │ ├── bugsnag-go │ │ │ ├── .travis.yml │ │ │ ├── CHANGELOG.md │ │ │ ├── CONTRIBUTING.md │ │ │ ├── LICENSE.txt │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── appengine.go │ │ │ ├── bugsnag.go │ │ │ ├── configuration.go │ │ │ ├── doc.go │ │ │ ├── errors │ │ │ │ ├── README.md │ │ │ │ ├── error.go │ │ │ │ ├── parse_panic.go │ │ │ │ └── stackframe.go │ │ │ ├── event.go │ │ │ ├── json_tags.go │ │ │ ├── metadata.go │ │ │ ├── middleware.go │ │ │ ├── notifier.go │ │ │ ├── panicwrap.go │ │ │ └── payload.go │ │ ├── osext │ │ │ ├── LICENSE │ │ │ ├── osext.go │ │ │ ├── osext_plan9.go │ │ │ ├── osext_procfs.go │ │ │ ├── osext_sysctl.go │ │ │ └── osext_windows.go │ │ └── panicwrap │ │ │ ├── CHANGELOG.md │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── dup2.go │ │ │ ├── dup3.go │ │ │ ├── monitor.go │ │ │ ├── monitor_windows.go │ │ │ └── panicwrap.go │ ├── cenkalti │ │ └── backoff │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── backoff.go │ │ │ ├── exponential.go │ │ │ ├── retry.go │ │ │ └── ticker.go │ ├── codegangsta │ │ └── cli │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── app.go │ │ │ ├── cli.go │ │ │ ├── command.go │ │ │ ├── context.go │ │ │ ├── flag.go │ │ │ └── help.go │ ├── davecgh │ │ └── go-spew │ │ │ ├── LICENSE │ │ │ └── spew │ │ │ ├── bypass.go │ │ │ ├── bypasssafe.go │ │ │ ├── common.go │ │ │ ├── config.go │ │ │ ├── doc.go │ │ │ ├── dump.go │ │ │ ├── format.go │ │ │ └── spew.go │ ├── dgrijalva │ │ └── jwt-go │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── MIGRATION_GUIDE.md │ │ │ ├── README.md │ │ │ ├── VERSION_HISTORY.md │ │ │ ├── claims.go │ │ │ ├── doc.go │ │ │ ├── ecdsa.go │ │ │ ├── ecdsa_utils.go │ │ │ ├── errors.go │ │ │ ├── hmac.go │ │ │ ├── map_claims.go │ │ │ ├── none.go │ │ │ ├── parser.go │ │ │ ├── rsa.go │ │ │ ├── rsa_pss.go │ │ │ ├── rsa_utils.go │ │ │ ├── signing_method.go │ │ │ └── token.go │ ├── digitalocean │ │ └── godo │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── CHANGELOG.md │ │ │ ├── CONTRIBUTING.md │ │ │ ├── LICENSE.txt │ │ │ ├── README.md │ │ │ ├── account.go │ │ │ ├── action.go │ │ │ ├── certificates.go │ │ │ ├── doc.go │ │ │ ├── domains.go │ │ │ ├── droplet_actions.go │ │ │ ├── droplets.go │ │ │ ├── errors.go │ │ │ ├── floating_ips.go │ │ │ ├── floating_ips_actions.go │ │ │ ├── godo.go │ │ │ ├── image_actions.go │ │ │ ├── images.go │ │ │ ├── keys.go │ │ │ ├── links.go │ │ │ ├── load_balancers.go │ │ │ ├── regions.go │ │ │ ├── sizes.go │ │ │ ├── snapshots.go │ │ │ ├── storage.go │ │ │ ├── storage_actions.go │ │ │ ├── strings.go │ │ │ ├── tags.go │ │ │ └── timestamp.go │ ├── docker │ │ └── go-units │ │ │ ├── CONTRIBUTING.md │ │ │ ├── LICENSE.code │ │ │ ├── LICENSE.docs │ │ │ ├── MAINTAINERS │ │ │ ├── README.md │ │ │ ├── circle.yml │ │ │ ├── duration.go │ │ │ ├── size.go │ │ │ └── ulimit.go │ ├── exoscale │ │ └── egoscale │ │ │ ├── .codeclimate.yml │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── AUTHORS │ │ │ ├── CHANGELOG.md │ │ │ ├── Gopkg.lock │ │ │ ├── Gopkg.toml │ │ │ ├── LICENSE │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── accounts.go │ │ │ ├── accounts_type.go │ │ │ ├── accounttype_string.go │ │ │ ├── addresses.go │ │ │ ├── addresses_type.go │ │ │ ├── affinity_groups.go │ │ │ ├── apis.go │ │ │ ├── apis_type.go │ │ │ ├── async_jobs.go │ │ │ ├── async_jobs_type.go │ │ │ ├── client.go │ │ │ ├── client_type.go │ │ │ ├── dns.go │ │ │ ├── doc.go │ │ │ ├── errorcode_string.go │ │ │ ├── events.go │ │ │ ├── gopher.png │ │ │ ├── jobstatustype_string.go │ │ │ ├── keypairs.go │ │ │ ├── keypairs_type.go │ │ │ ├── limits.go │ │ │ ├── network_offerings.go │ │ │ ├── network_offerings_type.go │ │ │ ├── networks.go │ │ │ ├── networks_type.go │ │ │ ├── nics.go │ │ │ ├── nics_type.go │ │ │ ├── request.go │ │ │ ├── request_type.go │ │ │ ├── resource_metadata.go │ │ │ ├── resource_metadata_type.go │ │ │ ├── security_groups.go │ │ │ ├── security_groups_type.go │ │ │ ├── serialization.go │ │ │ ├── service_offerings.go │ │ │ ├── service_offerings_type.go │ │ │ ├── snapshots.go │ │ │ ├── snapshots_type.go │ │ │ ├── tags.go │ │ │ ├── tags_type.go │ │ │ ├── templates.go │ │ │ ├── templates_type.go │ │ │ ├── users.go │ │ │ ├── users_type.go │ │ │ ├── version.go │ │ │ ├── virtual_machines.go │ │ │ ├── virtual_machines_type.go │ │ │ ├── vm_groups.go │ │ │ ├── volumes.go │ │ │ ├── volumes_type.go │ │ │ ├── zones.go │ │ │ └── zones_type.go │ ├── go-ini │ │ └── ini │ │ │ ├── .gitignore │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── README_ZH.md │ │ │ ├── ini.go │ │ │ └── struct.go │ ├── golang │ │ └── protobuf │ │ │ ├── AUTHORS │ │ │ ├── CONTRIBUTORS │ │ │ ├── LICENSE │ │ │ └── proto │ │ │ ├── Makefile │ │ │ ├── clone.go │ │ │ ├── decode.go │ │ │ ├── encode.go │ │ │ ├── equal.go │ │ │ ├── extensions.go │ │ │ ├── lib.go │ │ │ ├── message_set.go │ │ │ ├── pointer_reflect.go │ │ │ ├── pointer_unsafe.go │ │ │ ├── properties.go │ │ │ ├── text.go │ │ │ └── text_parser.go │ ├── google │ │ └── go-querystring │ │ │ ├── LICENSE │ │ │ └── query │ │ │ └── encode.go │ ├── hectane │ │ └── go-acl │ │ │ ├── LICENSE.txt │ │ │ ├── README.md │ │ │ ├── api │ │ │ ├── acl.go │ │ │ ├── api.go │ │ │ ├── posix.go │ │ │ ├── secinfo.go │ │ │ └── sid.go │ │ │ ├── apply.go │ │ │ ├── appveyor.yml │ │ │ ├── chmod.go │ │ │ ├── go.mod │ │ │ ├── go.sum │ │ │ ├── posix.go │ │ │ └── util.go │ ├── intel-go │ │ └── cpuid │ │ │ ├── .gitignore │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── cpuid.go │ │ │ ├── cpuid_amd64.go │ │ │ └── cpuidlow_amd64.s │ ├── jinzhu │ │ └── copier │ │ │ ├── Guardfile │ │ │ ├── License │ │ │ ├── README.md │ │ │ ├── copier.go │ │ │ └── wercker.yml │ ├── jmespath │ │ └── go-jmespath │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── api.go │ │ │ ├── astnodetype_string.go │ │ │ ├── functions.go │ │ │ ├── interpreter.go │ │ │ ├── lexer.go │ │ │ ├── parser.go │ │ │ ├── toktype_string.go │ │ │ └── util.go │ ├── konsorten │ │ └── go-windows-terminal-sequences │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── go.mod │ │ │ └── sequences.go │ ├── mitchellh │ │ └── mapstructure │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── decode_hooks.go │ │ │ ├── error.go │ │ │ └── mapstructure.go │ ├── moby │ │ └── term │ │ │ ├── .gitignore │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── ascii.go │ │ │ ├── go.mod │ │ │ ├── go.sum │ │ │ ├── proxy.go │ │ │ ├── tc.go │ │ │ ├── term.go │ │ │ ├── term_windows.go │ │ │ ├── termios_bsd.go │ │ │ ├── termios_linux.go │ │ │ ├── windows │ │ │ ├── ansi_reader.go │ │ │ ├── ansi_writer.go │ │ │ ├── console.go │ │ │ └── windows.go │ │ │ └── winsize.go │ ├── pmezard │ │ └── go-difflib │ │ │ ├── LICENSE │ │ │ └── difflib │ │ │ └── difflib.go │ ├── rackspace │ │ └── gophercloud │ │ │ ├── .travis.yml │ │ │ ├── CONTRIBUTING.md │ │ │ ├── CONTRIBUTORS.md │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── UPGRADING.md │ │ │ ├── auth_options.go │ │ │ ├── auth_results.go │ │ │ ├── doc.go │ │ │ ├── endpoint_search.go │ │ │ ├── openstack │ │ │ ├── auth_env.go │ │ │ ├── client.go │ │ │ ├── compute │ │ │ │ └── v2 │ │ │ │ │ ├── extensions │ │ │ │ │ ├── floatingip │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── fixtures.go │ │ │ │ │ │ ├── requests.go │ │ │ │ │ │ ├── results.go │ │ │ │ │ │ └── urls.go │ │ │ │ │ ├── keypairs │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── fixtures.go │ │ │ │ │ │ ├── requests.go │ │ │ │ │ │ ├── results.go │ │ │ │ │ │ └── urls.go │ │ │ │ │ └── startstop │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── fixtures.go │ │ │ │ │ │ └── requests.go │ │ │ │ │ ├── flavors │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── requests.go │ │ │ │ │ ├── results.go │ │ │ │ │ └── urls.go │ │ │ │ │ ├── images │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── requests.go │ │ │ │ │ ├── results.go │ │ │ │ │ └── urls.go │ │ │ │ │ └── servers │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── fixtures.go │ │ │ │ │ ├── requests.go │ │ │ │ │ ├── results.go │ │ │ │ │ ├── urls.go │ │ │ │ │ └── util.go │ │ │ ├── endpoint_location.go │ │ │ ├── identity │ │ │ │ ├── v2 │ │ │ │ │ ├── tenants │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── fixtures.go │ │ │ │ │ │ ├── requests.go │ │ │ │ │ │ ├── results.go │ │ │ │ │ │ └── urls.go │ │ │ │ │ └── tokens │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── errors.go │ │ │ │ │ │ ├── fixtures.go │ │ │ │ │ │ ├── requests.go │ │ │ │ │ │ ├── results.go │ │ │ │ │ │ └── urls.go │ │ │ │ └── v3 │ │ │ │ │ └── tokens │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── errors.go │ │ │ │ │ ├── requests.go │ │ │ │ │ ├── results.go │ │ │ │ │ └── urls.go │ │ │ ├── networking │ │ │ │ └── v2 │ │ │ │ │ ├── extensions │ │ │ │ │ └── layer3 │ │ │ │ │ │ └── floatingips │ │ │ │ │ │ ├── requests.go │ │ │ │ │ │ ├── results.go │ │ │ │ │ │ └── urls.go │ │ │ │ │ ├── networks │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── errors.go │ │ │ │ │ ├── requests.go │ │ │ │ │ ├── results.go │ │ │ │ │ └── urls.go │ │ │ │ │ └── ports │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── errors.go │ │ │ │ │ ├── requests.go │ │ │ │ │ ├── results.go │ │ │ │ │ └── urls.go │ │ │ └── utils │ │ │ │ └── choose_version.go │ │ │ ├── pagination │ │ │ ├── http.go │ │ │ ├── linked.go │ │ │ ├── marker.go │ │ │ ├── null.go │ │ │ ├── pager.go │ │ │ ├── pkg.go │ │ │ └── single.go │ │ │ ├── params.go │ │ │ ├── provider_client.go │ │ │ ├── rackspace │ │ │ ├── auth_env.go │ │ │ ├── client.go │ │ │ └── identity │ │ │ │ └── v2 │ │ │ │ └── tokens │ │ │ │ ├── delegate.go │ │ │ │ └── doc.go │ │ │ ├── results.go │ │ │ ├── service_client.go │ │ │ ├── testhelper │ │ │ ├── client │ │ │ │ └── fake.go │ │ │ ├── convenience.go │ │ │ ├── doc.go │ │ │ └── http_responses.go │ │ │ └── util.go │ ├── samalba │ │ └── dockerclient │ │ │ ├── .gitignore │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── auth.go │ │ │ ├── dockerclient.go │ │ │ ├── example_responses.go │ │ │ ├── interface.go │ │ │ ├── tls.go │ │ │ ├── types.go │ │ │ └── utils.go │ ├── sirupsen │ │ └── logrus │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── CHANGELOG.md │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── alt_exit.go │ │ │ ├── appveyor.yml │ │ │ ├── doc.go │ │ │ ├── entry.go │ │ │ ├── exported.go │ │ │ ├── formatter.go │ │ │ ├── go.mod │ │ │ ├── go.sum │ │ │ ├── hooks.go │ │ │ ├── json_formatter.go │ │ │ ├── logger.go │ │ │ ├── logrus.go │ │ │ ├── terminal_check_appengine.go │ │ │ ├── terminal_check_bsd.go │ │ │ ├── terminal_check_no_terminal.go │ │ │ ├── terminal_check_notappengine.go │ │ │ ├── terminal_check_solaris.go │ │ │ ├── terminal_check_unix.go │ │ │ ├── terminal_check_windows.go │ │ │ ├── text_formatter.go │ │ │ └── writer.go │ ├── skarademir │ │ └── naturalsort │ │ │ ├── LICENSE.md │ │ │ ├── README.md │ │ │ └── naturalsort.go │ ├── stretchr │ │ ├── objx │ │ │ ├── .codeclimate.yml │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── Gopkg.lock │ │ │ ├── Gopkg.toml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── Taskfile.yml │ │ │ ├── accessors.go │ │ │ ├── constants.go │ │ │ ├── conversions.go │ │ │ ├── doc.go │ │ │ ├── map.go │ │ │ ├── mutations.go │ │ │ ├── security.go │ │ │ ├── tests.go │ │ │ ├── type_specific_codegen.go │ │ │ └── value.go │ │ └── testify │ │ │ ├── LICENSE │ │ │ ├── assert │ │ │ ├── assertion_format.go │ │ │ ├── assertion_format.go.tmpl │ │ │ ├── assertion_forward.go │ │ │ ├── assertion_forward.go.tmpl │ │ │ ├── assertions.go │ │ │ ├── doc.go │ │ │ ├── errors.go │ │ │ ├── forward_assertions.go │ │ │ └── http_assertions.go │ │ │ └── mock │ │ │ ├── doc.go │ │ │ └── mock.go │ ├── tent │ │ └── http-link-go │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ └── link.go │ └── vmware │ │ ├── govcloudair │ │ ├── .gitignore │ │ ├── .travis.yml │ │ ├── LICENSE │ │ ├── Readme.md │ │ ├── api.go │ │ ├── catalog.go │ │ ├── catalogitem.go │ │ ├── edgegateway.go │ │ ├── org.go │ │ ├── orgvdcnetwork.go │ │ ├── task.go │ │ ├── types │ │ │ └── v56 │ │ │ │ └── types.go │ │ ├── vapp.go │ │ ├── vapptemplate.go │ │ └── vdc.go │ │ └── govmomi │ │ ├── .drone.sec │ │ ├── .drone.yml │ │ ├── .gitignore │ │ ├── .travis.yml │ │ ├── CHANGELOG.md │ │ ├── CONTRIBUTING.md │ │ ├── CONTRIBUTORS │ │ ├── LICENSE.txt │ │ ├── Makefile │ │ ├── README.md │ │ ├── client.go │ │ ├── find │ │ ├── error.go │ │ └── finder.go │ │ ├── guest │ │ ├── auth_manager.go │ │ ├── file_manager.go │ │ ├── operations_manager.go │ │ └── process_manager.go │ │ ├── list │ │ ├── lister.go │ │ ├── path.go │ │ └── recurser.go │ │ ├── object │ │ ├── authorization_manager.go │ │ ├── cluster_compute_resource.go │ │ ├── common.go │ │ ├── compute_resource.go │ │ ├── custom_fields_manager.go │ │ ├── customization_spec_manager.go │ │ ├── datacenter.go │ │ ├── datastore.go │ │ ├── diagnostic_manager.go │ │ ├── distributed_virtual_portgroup.go │ │ ├── distributed_virtual_switch.go │ │ ├── extension_manager.go │ │ ├── file_manager.go │ │ ├── folder.go │ │ ├── history_collector.go │ │ ├── host_account_manager.go │ │ ├── host_config_manager.go │ │ ├── host_datastore_browser.go │ │ ├── host_datastore_system.go │ │ ├── host_firewall_system.go │ │ ├── host_network_system.go │ │ ├── host_storage_system.go │ │ ├── host_system.go │ │ ├── host_virtual_nic_manager.go │ │ ├── host_vsan_system.go │ │ ├── http_nfc_lease.go │ │ ├── list_view.go │ │ ├── network.go │ │ ├── network_reference.go │ │ ├── option_manager.go │ │ ├── ovf_manager.go │ │ ├── resource_pool.go │ │ ├── search_index.go │ │ ├── storage_pod.go │ │ ├── storage_resource_manager.go │ │ ├── task.go │ │ ├── types.go │ │ ├── virtual_app.go │ │ ├── virtual_device_list.go │ │ ├── virtual_disk_manager.go │ │ ├── virtual_machine.go │ │ └── vmware_distributed_virtual_switch.go │ │ ├── property │ │ ├── collector.go │ │ └── wait.go │ │ ├── session │ │ ├── keep_alive.go │ │ └── manager.go │ │ ├── task │ │ ├── error.go │ │ └── wait.go │ │ └── vim25 │ │ ├── client.go │ │ ├── debug │ │ └── debug.go │ │ ├── doc.go │ │ ├── methods │ │ ├── internal.go │ │ ├── methods.go │ │ └── service_content.go │ │ ├── mo │ │ ├── ancestors.go │ │ ├── entity.go │ │ ├── extra.go │ │ ├── mo.go │ │ ├── reference.go │ │ ├── registry.go │ │ ├── retrieve.go │ │ └── type_info.go │ │ ├── progress │ │ ├── aggregator.go │ │ ├── doc.go │ │ ├── prefix.go │ │ ├── reader.go │ │ ├── report.go │ │ ├── scale.go │ │ ├── sinker.go │ │ └── tee.go │ │ ├── retry.go │ │ ├── soap │ │ ├── client.go │ │ ├── debug.go │ │ ├── error.go │ │ └── soap.go │ │ ├── types │ │ ├── base.go │ │ ├── enum.go │ │ ├── fault.go │ │ ├── helpers.go │ │ ├── if.go │ │ ├── internal.go │ │ ├── registry.go │ │ └── types.go │ │ └── xml │ │ ├── LICENSE │ │ ├── extras.go │ │ ├── marshal.go │ │ ├── read.go │ │ ├── typeinfo.go │ │ └── xml.go ├── golang.org │ └── x │ │ ├── crypto │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── LICENSE │ │ ├── PATENTS │ │ ├── curve25519 │ │ │ ├── const_amd64.h │ │ │ ├── const_amd64.s │ │ │ ├── cswap_amd64.s │ │ │ ├── curve25519.go │ │ │ ├── doc.go │ │ │ ├── freeze_amd64.s │ │ │ ├── ladderstep_amd64.s │ │ │ ├── mont25519_amd64.go │ │ │ ├── mul_amd64.s │ │ │ └── square_amd64.s │ │ ├── ed25519 │ │ │ ├── ed25519.go │ │ │ └── internal │ │ │ │ └── edwards25519 │ │ │ │ ├── const.go │ │ │ │ └── edwards25519.go │ │ ├── internal │ │ │ ├── chacha20 │ │ │ │ ├── asm_arm64.s │ │ │ │ ├── chacha_arm64.go │ │ │ │ ├── chacha_generic.go │ │ │ │ ├── chacha_noasm.go │ │ │ │ ├── chacha_s390x.go │ │ │ │ ├── chacha_s390x.s │ │ │ │ └── xor.go │ │ │ └── subtle │ │ │ │ ├── aliasing.go │ │ │ │ └── aliasing_appengine.go │ │ ├── poly1305 │ │ │ ├── mac_noasm.go │ │ │ ├── poly1305.go │ │ │ ├── sum_amd64.go │ │ │ ├── sum_amd64.s │ │ │ ├── sum_arm.go │ │ │ ├── sum_arm.s │ │ │ ├── sum_generic.go │ │ │ ├── sum_noasm.go │ │ │ ├── sum_s390x.go │ │ │ ├── sum_s390x.s │ │ │ └── sum_vmsl_s390x.s │ │ └── ssh │ │ │ ├── buffer.go │ │ │ ├── certs.go │ │ │ ├── channel.go │ │ │ ├── cipher.go │ │ │ ├── client.go │ │ │ ├── client_auth.go │ │ │ ├── common.go │ │ │ ├── connection.go │ │ │ ├── doc.go │ │ │ ├── handshake.go │ │ │ ├── kex.go │ │ │ ├── keys.go │ │ │ ├── mac.go │ │ │ ├── messages.go │ │ │ ├── mux.go │ │ │ ├── server.go │ │ │ ├── session.go │ │ │ ├── streamlocal.go │ │ │ ├── tcpip.go │ │ │ ├── terminal │ │ │ ├── terminal.go │ │ │ ├── util.go │ │ │ ├── util_aix.go │ │ │ ├── util_bsd.go │ │ │ ├── util_linux.go │ │ │ ├── util_plan9.go │ │ │ ├── util_solaris.go │ │ │ └── util_windows.go │ │ │ └── transport.go │ │ ├── net │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── LICENSE │ │ ├── PATENTS │ │ └── context │ │ │ ├── context.go │ │ │ ├── ctxhttp │ │ │ └── ctxhttp.go │ │ │ ├── go17.go │ │ │ ├── go19.go │ │ │ ├── pre_go17.go │ │ │ └── pre_go19.go │ │ ├── oauth2 │ │ ├── .travis.yml │ │ ├── AUTHORS │ │ ├── CONTRIBUTING.md │ │ ├── CONTRIBUTORS │ │ ├── LICENSE │ │ ├── README.md │ │ ├── client_appengine.go │ │ ├── google │ │ │ ├── appengine.go │ │ │ ├── appengine_hook.go │ │ │ ├── appenginevm_hook.go │ │ │ ├── default.go │ │ │ ├── google.go │ │ │ ├── jwt.go │ │ │ └── sdk.go │ │ ├── internal │ │ │ ├── oauth2.go │ │ │ ├── token.go │ │ │ └── transport.go │ │ ├── jws │ │ │ └── jws.go │ │ ├── jwt │ │ │ └── jwt.go │ │ ├── oauth2.go │ │ ├── token.go │ │ └── transport.go │ │ └── sys │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── LICENSE │ │ ├── PATENTS │ │ ├── cpu │ │ ├── asm_aix_ppc64.s │ │ ├── byteorder.go │ │ ├── cpu.go │ │ ├── cpu_aix_ppc64.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_mips64x.go │ │ ├── cpu_mipsx.go │ │ ├── cpu_other_arm64.go │ │ ├── cpu_riscv64.go │ │ ├── cpu_s390x.s │ │ ├── cpu_wasm.go │ │ ├── cpu_x86.go │ │ ├── cpu_x86.s │ │ ├── hwcap_linux.go │ │ └── syscall_aix_ppc64_gc.go │ │ ├── unix │ │ ├── .gitignore │ │ ├── README.md │ │ ├── affinity_linux.go │ │ ├── aliases.go │ │ ├── asm_aix_ppc64.s │ │ ├── asm_darwin_386.s │ │ ├── asm_darwin_amd64.s │ │ ├── asm_darwin_arm.s │ │ ├── asm_darwin_arm64.s │ │ ├── asm_dragonfly_amd64.s │ │ ├── asm_freebsd_386.s │ │ ├── asm_freebsd_amd64.s │ │ ├── asm_freebsd_arm.s │ │ ├── asm_freebsd_arm64.s │ │ ├── asm_linux_386.s │ │ ├── asm_linux_amd64.s │ │ ├── asm_linux_arm.s │ │ ├── asm_linux_arm64.s │ │ ├── asm_linux_mips64x.s │ │ ├── asm_linux_mipsx.s │ │ ├── asm_linux_ppc64x.s │ │ ├── asm_linux_riscv64.s │ │ ├── asm_linux_s390x.s │ │ ├── asm_netbsd_386.s │ │ ├── asm_netbsd_amd64.s │ │ ├── asm_netbsd_arm.s │ │ ├── asm_netbsd_arm64.s │ │ ├── asm_openbsd_386.s │ │ ├── asm_openbsd_amd64.s │ │ ├── asm_openbsd_arm.s │ │ ├── asm_openbsd_arm64.s │ │ ├── asm_solaris_amd64.s │ │ ├── bluetooth_linux.go │ │ ├── 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 │ │ ├── dirent.go │ │ ├── endian_big.go │ │ ├── endian_little.go │ │ ├── env_unix.go │ │ ├── errors_freebsd_386.go │ │ ├── errors_freebsd_amd64.go │ │ ├── errors_freebsd_arm.go │ │ ├── fcntl.go │ │ ├── fcntl_darwin.go │ │ ├── fcntl_linux_32bit.go │ │ ├── fdset.go │ │ ├── gccgo.go │ │ ├── gccgo_c.c │ │ ├── gccgo_linux_amd64.go │ │ ├── ioctl.go │ │ ├── mkall.sh │ │ ├── mkerrors.sh │ │ ├── pagesize_unix.go │ │ ├── pledge_openbsd.go │ │ ├── race.go │ │ ├── race0.go │ │ ├── readdirent_getdents.go │ │ ├── readdirent_getdirentries.go │ │ ├── sockcmsg_dragonfly.go │ │ ├── sockcmsg_linux.go │ │ ├── sockcmsg_unix.go │ │ ├── sockcmsg_unix_other.go │ │ ├── str.go │ │ ├── syscall.go │ │ ├── syscall_aix.go │ │ ├── syscall_aix_ppc.go │ │ ├── syscall_aix_ppc64.go │ │ ├── syscall_bsd.go │ │ ├── syscall_darwin.1_12.go │ │ ├── syscall_darwin.1_13.go │ │ ├── syscall_darwin.go │ │ ├── syscall_darwin_386.1_11.go │ │ ├── syscall_darwin_386.go │ │ ├── syscall_darwin_amd64.1_11.go │ │ ├── syscall_darwin_amd64.go │ │ ├── syscall_darwin_arm.1_11.go │ │ ├── syscall_darwin_arm.go │ │ ├── syscall_darwin_arm64.1_11.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_linux.go │ │ ├── syscall_linux_386.go │ │ ├── syscall_linux_amd64.go │ │ ├── syscall_linux_amd64_gc.go │ │ ├── syscall_linux_arm.go │ │ ├── syscall_linux_arm64.go │ │ ├── syscall_linux_gc.go │ │ ├── syscall_linux_gc_386.go │ │ ├── syscall_linux_gccgo_386.go │ │ ├── syscall_linux_gccgo_arm.go │ │ ├── syscall_linux_mips64x.go │ │ ├── syscall_linux_mipsx.go │ │ ├── syscall_linux_ppc64x.go │ │ ├── syscall_linux_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_solaris.go │ │ ├── syscall_solaris_amd64.go │ │ ├── syscall_unix.go │ │ ├── syscall_unix_gc.go │ │ ├── syscall_unix_gc_ppc64x.go │ │ ├── timestruct.go │ │ ├── unveil_openbsd.go │ │ ├── xattr_bsd.go │ │ ├── zerrors_aix_ppc.go │ │ ├── zerrors_aix_ppc64.go │ │ ├── zerrors_darwin_386.go │ │ ├── zerrors_darwin_amd64.go │ │ ├── zerrors_darwin_arm.go │ │ ├── zerrors_darwin_arm64.go │ │ ├── zerrors_dragonfly_amd64.go │ │ ├── zerrors_freebsd_386.go │ │ ├── zerrors_freebsd_amd64.go │ │ ├── zerrors_freebsd_arm.go │ │ ├── zerrors_freebsd_arm64.go │ │ ├── zerrors_linux.go │ │ ├── zerrors_linux_386.go │ │ ├── zerrors_linux_amd64.go │ │ ├── zerrors_linux_arm.go │ │ ├── zerrors_linux_arm64.go │ │ ├── zerrors_linux_mips.go │ │ ├── zerrors_linux_mips64.go │ │ ├── zerrors_linux_mips64le.go │ │ ├── zerrors_linux_mipsle.go │ │ ├── zerrors_linux_ppc64.go │ │ ├── zerrors_linux_ppc64le.go │ │ ├── zerrors_linux_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_solaris_amd64.go │ │ ├── zptrace_armnn_linux.go │ │ ├── zptrace_linux_arm64.go │ │ ├── zptrace_mipsnn_linux.go │ │ ├── zptrace_mipsnnle_linux.go │ │ ├── zptrace_x86_linux.go │ │ ├── zsyscall_aix_ppc.go │ │ ├── zsyscall_aix_ppc64.go │ │ ├── zsyscall_aix_ppc64_gc.go │ │ ├── zsyscall_aix_ppc64_gccgo.go │ │ ├── zsyscall_darwin_386.1_11.go │ │ ├── zsyscall_darwin_386.1_13.go │ │ ├── zsyscall_darwin_386.1_13.s │ │ ├── zsyscall_darwin_386.go │ │ ├── zsyscall_darwin_386.s │ │ ├── zsyscall_darwin_amd64.1_11.go │ │ ├── zsyscall_darwin_amd64.1_13.go │ │ ├── zsyscall_darwin_amd64.1_13.s │ │ ├── zsyscall_darwin_amd64.go │ │ ├── zsyscall_darwin_amd64.s │ │ ├── zsyscall_darwin_arm.1_11.go │ │ ├── zsyscall_darwin_arm.1_13.go │ │ ├── zsyscall_darwin_arm.1_13.s │ │ ├── zsyscall_darwin_arm.go │ │ ├── zsyscall_darwin_arm.s │ │ ├── zsyscall_darwin_arm64.1_11.go │ │ ├── zsyscall_darwin_arm64.1_13.go │ │ ├── zsyscall_darwin_arm64.1_13.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_linux.go │ │ ├── zsyscall_linux_386.go │ │ ├── zsyscall_linux_amd64.go │ │ ├── zsyscall_linux_arm.go │ │ ├── zsyscall_linux_arm64.go │ │ ├── zsyscall_linux_mips.go │ │ ├── zsyscall_linux_mips64.go │ │ ├── zsyscall_linux_mips64le.go │ │ ├── zsyscall_linux_mipsle.go │ │ ├── zsyscall_linux_ppc64.go │ │ ├── zsyscall_linux_ppc64le.go │ │ ├── zsyscall_linux_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_amd64.go │ │ ├── zsyscall_openbsd_arm.go │ │ ├── zsyscall_openbsd_arm64.go │ │ ├── zsyscall_solaris_amd64.go │ │ ├── zsysctl_openbsd_386.go │ │ ├── zsysctl_openbsd_amd64.go │ │ ├── zsysctl_openbsd_arm.go │ │ ├── zsysctl_openbsd_arm64.go │ │ ├── zsysnum_darwin_386.go │ │ ├── zsysnum_darwin_amd64.go │ │ ├── zsysnum_darwin_arm.go │ │ ├── zsysnum_darwin_arm64.go │ │ ├── zsysnum_dragonfly_amd64.go │ │ ├── zsysnum_freebsd_386.go │ │ ├── zsysnum_freebsd_amd64.go │ │ ├── zsysnum_freebsd_arm.go │ │ ├── zsysnum_freebsd_arm64.go │ │ ├── zsysnum_linux_386.go │ │ ├── zsysnum_linux_amd64.go │ │ ├── zsysnum_linux_arm.go │ │ ├── zsysnum_linux_arm64.go │ │ ├── zsysnum_linux_mips.go │ │ ├── zsysnum_linux_mips64.go │ │ ├── zsysnum_linux_mips64le.go │ │ ├── zsysnum_linux_mipsle.go │ │ ├── zsysnum_linux_ppc64.go │ │ ├── zsysnum_linux_ppc64le.go │ │ ├── zsysnum_linux_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 │ │ ├── ztypes_aix_ppc.go │ │ ├── ztypes_aix_ppc64.go │ │ ├── ztypes_darwin_386.go │ │ ├── ztypes_darwin_amd64.go │ │ ├── ztypes_darwin_arm.go │ │ ├── ztypes_darwin_arm64.go │ │ ├── ztypes_dragonfly_amd64.go │ │ ├── ztypes_freebsd_386.go │ │ ├── ztypes_freebsd_amd64.go │ │ ├── ztypes_freebsd_arm.go │ │ ├── ztypes_freebsd_arm64.go │ │ ├── ztypes_linux.go │ │ ├── ztypes_linux_386.go │ │ ├── ztypes_linux_amd64.go │ │ ├── ztypes_linux_arm.go │ │ ├── ztypes_linux_arm64.go │ │ ├── ztypes_linux_mips.go │ │ ├── ztypes_linux_mips64.go │ │ ├── ztypes_linux_mips64le.go │ │ ├── ztypes_linux_mipsle.go │ │ ├── ztypes_linux_ppc64.go │ │ ├── ztypes_linux_ppc64le.go │ │ ├── ztypes_linux_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_solaris_amd64.go │ │ └── windows │ │ ├── aliases.go │ │ ├── dll_windows.go │ │ ├── empty.s │ │ ├── env_windows.go │ │ ├── eventlog.go │ │ ├── exec_windows.go │ │ ├── memory_windows.go │ │ ├── mkerrors.bash │ │ ├── mkknownfolderids.bash │ │ ├── mksyscall.go │ │ ├── race.go │ │ ├── race0.go │ │ ├── registry │ │ ├── key.go │ │ ├── mksyscall.go │ │ ├── syscall.go │ │ ├── value.go │ │ └── zsyscall_windows.go │ │ ├── security_windows.go │ │ ├── service.go │ │ ├── str.go │ │ ├── syscall.go │ │ ├── syscall_windows.go │ │ ├── types_windows.go │ │ ├── types_windows_386.go │ │ ├── types_windows_amd64.go │ │ ├── types_windows_arm.go │ │ ├── zerrors_windows.go │ │ ├── zknownfolderids_windows.go │ │ └── zsyscall_windows.go ├── google.golang.org │ ├── api │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── LICENSE │ │ ├── compute │ │ │ └── v1 │ │ │ │ ├── compute-api.json │ │ │ │ └── compute-gen.go │ │ ├── gensupport │ │ │ ├── backoff.go │ │ │ ├── buffer.go │ │ │ ├── doc.go │ │ │ ├── go18.go │ │ │ ├── header.go │ │ │ ├── json.go │ │ │ ├── jsonfloat.go │ │ │ ├── media.go │ │ │ ├── not_go18.go │ │ │ ├── params.go │ │ │ ├── resumable.go │ │ │ ├── retry.go │ │ │ └── send.go │ │ └── googleapi │ │ │ ├── googleapi.go │ │ │ ├── internal │ │ │ └── uritemplates │ │ │ │ ├── LICENSE │ │ │ │ ├── uritemplates.go │ │ │ │ └── utils.go │ │ │ └── types.go │ ├── appengine │ │ ├── .travis.yml │ │ ├── LICENSE │ │ ├── README.md │ │ ├── appengine.go │ │ ├── appengine_vm.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_vm.go │ │ │ ├── internal.go │ │ │ ├── log │ │ │ │ ├── log_service.pb.go │ │ │ │ └── log_service.proto │ │ │ ├── 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 │ │ │ └── urlfetch │ │ │ │ ├── urlfetch_service.pb.go │ │ │ │ └── urlfetch_service.proto │ │ ├── namespace.go │ │ ├── timeout.go │ │ └── urlfetch │ │ │ └── urlfetch.go │ └── cloud │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── LICENSE │ │ ├── compute │ │ └── metadata │ │ │ └── metadata.go │ │ └── internal │ │ └── cloud.go └── modules.txt └── version └── version.go /.dockerignore: -------------------------------------------------------------------------------- 1 | docker-machine* 2 | *.log 3 | bin 4 | cover -------------------------------------------------------------------------------- /.github/pull_request_template.md: -------------------------------------------------------------------------------- 1 | 12 | 13 | ## Description 14 | 15 | 16 | 17 | ## Related issue(s) 18 | 19 | 20 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.log 2 | *.iml 3 | .idea/ 4 | /bin/ 5 | cover 6 | -------------------------------------------------------------------------------- /.godir: -------------------------------------------------------------------------------- 1 | github.com/docker/machine 2 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: required 2 | dist: trusty 3 | language: bash 4 | services: docker 5 | env: 6 | matrix: 7 | - TARGET_OS=darwin TARGET_ARCH=amd64 TARGETS="build-x" 8 | - TARGET_OS=linux TARGET_ARCH=amd64 TARGETS="build validate" 9 | - TARGET_OS=openbsd TARGET_ARCH=amd64 TARGETS="build-x" 10 | - TARGET_OS=windows TARGET_ARCH=amd64 TARGETS="build-x" 11 | - TARGET_OS=linux TARGET_ARCH=arm TARGETS="build-x" 12 | - TARGET_OS=linux TARGET_ARCH=arm64 TARGETS="build-x" 13 | script: 14 | - USE_CONTAINER=true make "$TARGETS" 15 | - "[[ \"$(find bin -type f -name docker-machine*)\" != \"\" ]]" 16 | -------------------------------------------------------------------------------- /Dockerfile: -------------------------------------------------------------------------------- 1 | FROM golang:1.12.9 2 | 3 | RUN apt-get update && apt-get install -y --no-install-recommends \ 4 | openssh-client \ 5 | rsync \ 6 | fuse \ 7 | sshfs \ 8 | && rm -rf /var/lib/apt/lists/* 9 | 10 | RUN go get golang.org/x/lint/golint \ 11 | github.com/mattn/goveralls \ 12 | golang.org/x/tools/cover 13 | 14 | ENV USER root 15 | WORKDIR /go/src/github.com/docker/machine 16 | 17 | COPY . ./ 18 | RUN mkdir bin 19 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | # Plain make targets if not requested inside a container 2 | ifneq (,$(findstring test-integration,$(MAKECMDGOALS))) 3 | include Makefile.inc 4 | include mk/main.mk 5 | else ifneq ($(USE_CONTAINER), true) 6 | include Makefile.inc 7 | include mk/main.mk 8 | else 9 | # Otherwise, with docker, swallow all targets and forward into a container 10 | DOCKER_BUILD_DONE := "" 11 | 12 | test: .DEFAULT 13 | 14 | .DEFAULT: 15 | @test ! -z "$(DOCKER_BUILD_DONE)" || ./script/build_in_container.sh $(MAKECMDGOALS) 16 | $(eval DOCKER_BUILD_DONE := "done") 17 | 18 | endif 19 | -------------------------------------------------------------------------------- /appveyor.yml: -------------------------------------------------------------------------------- 1 | version: "{build}" 2 | 3 | skip_tags: true 4 | 5 | os: Windows Server 2012 R2 6 | 7 | environment: 8 | GOPATH: c:\gopath 9 | 10 | clone_folder: c:\gopath\src\github.com\docker\machine 11 | 12 | build_script: 13 | - go build -i -o ./bin/docker-machine.exe ./cmd/docker-machine 14 | 15 | test_script: 16 | - powershell -Command go test -v ./libmachine/shell 17 | 18 | deploy: off 19 | -------------------------------------------------------------------------------- /cmd/docker-machine/machine_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "os" 5 | "testing" 6 | 7 | "github.com/docker/machine/commands/mcndirs" 8 | ) 9 | 10 | func TestStorePathSetCorrectly(t *testing.T) { 11 | mcndirs.BaseDir = "" 12 | os.Args = []string{"docker-machine", "--storage-path", "/tmp/foo"} 13 | main() 14 | if mcndirs.BaseDir != "/tmp/foo" { 15 | t.Fatal("Expected MACHINE_STORAGE_PATH environment variable to be /tmp/foo but was ", os.Getenv("MACHINE_STORAGE_PATH")) 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /commands/flag_sort.go: -------------------------------------------------------------------------------- 1 | package commands 2 | 3 | import "github.com/codegangsta/cli" 4 | 5 | type ByFlagName []cli.Flag 6 | 7 | func (flags ByFlagName) Len() int { 8 | return len(flags) 9 | } 10 | 11 | func (flags ByFlagName) Swap(i, j int) { 12 | flags[i], flags[j] = flags[j], flags[i] 13 | } 14 | 15 | func (flags ByFlagName) Less(i, j int) bool { 16 | return flags[i].String() < flags[j].String() 17 | } 18 | -------------------------------------------------------------------------------- /commands/inspect_test.go: -------------------------------------------------------------------------------- 1 | package commands 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/docker/machine/commands/commandstest" 7 | "github.com/docker/machine/libmachine" 8 | "github.com/docker/machine/libmachine/libmachinetest" 9 | "github.com/stretchr/testify/assert" 10 | ) 11 | 12 | func TestCmdInspect(t *testing.T) { 13 | testCases := []struct { 14 | commandLine CommandLine 15 | api libmachine.API 16 | expectedErr error 17 | }{ 18 | { 19 | commandLine: &commandstest.FakeCommandLine{ 20 | CliArgs: []string{"foo", "bar"}, 21 | }, 22 | api: &libmachinetest.FakeAPI{}, 23 | expectedErr: ErrExpectedOneMachine, 24 | }, 25 | } 26 | 27 | for _, tc := range testCases { 28 | err := cmdInspect(tc.commandLine, tc.api) 29 | assert.Equal(t, tc.expectedErr, err) 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /commands/ip.go: -------------------------------------------------------------------------------- 1 | package commands 2 | 3 | import "github.com/docker/machine/libmachine" 4 | 5 | func cmdIP(c CommandLine, api libmachine.API) error { 6 | return runAction("ip", c, api) 7 | } 8 | -------------------------------------------------------------------------------- /commands/kill.go: -------------------------------------------------------------------------------- 1 | package commands 2 | 3 | import "github.com/docker/machine/libmachine" 4 | 5 | func cmdKill(c CommandLine, api libmachine.API) error { 6 | return runAction("kill", c, api) 7 | } 8 | -------------------------------------------------------------------------------- /commands/mcndirs/utils.go: -------------------------------------------------------------------------------- 1 | package mcndirs 2 | 3 | import ( 4 | "os" 5 | "path/filepath" 6 | 7 | "github.com/docker/machine/libmachine/mcnutils" 8 | ) 9 | 10 | var ( 11 | BaseDir = os.Getenv("MACHINE_STORAGE_PATH") 12 | ) 13 | 14 | func GetBaseDir() string { 15 | if BaseDir == "" { 16 | BaseDir = filepath.Join(mcnutils.GetHomeDir(), ".docker", "machine") 17 | } 18 | return BaseDir 19 | } 20 | 21 | func GetMachineDir() string { 22 | return filepath.Join(GetBaseDir(), "machines") 23 | } 24 | 25 | func GetMachineCertDir() string { 26 | return filepath.Join(GetBaseDir(), "certs") 27 | } 28 | -------------------------------------------------------------------------------- /commands/provision.go: -------------------------------------------------------------------------------- 1 | package commands 2 | 3 | import "github.com/docker/machine/libmachine" 4 | 5 | func cmdProvision(c CommandLine, api libmachine.API) error { 6 | return runAction("provision", c, api) 7 | } 8 | -------------------------------------------------------------------------------- /commands/regeneratecerts.go: -------------------------------------------------------------------------------- 1 | package commands 2 | 3 | import ( 4 | "github.com/docker/machine/libmachine" 5 | "github.com/docker/machine/libmachine/log" 6 | ) 7 | 8 | func cmdRegenerateCerts(c CommandLine, api libmachine.API) error { 9 | if !c.Bool("force") { 10 | ok, err := confirmInput("Regenerate TLS machine certs? Warning: this is irreversible.") 11 | if err != nil { 12 | return err 13 | } 14 | 15 | if !ok { 16 | return nil 17 | } 18 | } 19 | 20 | log.Infof("Regenerating TLS certificates") 21 | 22 | if c.Bool("client-certs") { 23 | return runAction("configureAllAuth", c, api) 24 | } 25 | return runAction("configureAuth", c, api) 26 | } 27 | -------------------------------------------------------------------------------- /commands/restart.go: -------------------------------------------------------------------------------- 1 | package commands 2 | 3 | import ( 4 | "github.com/docker/machine/libmachine" 5 | "github.com/docker/machine/libmachine/log" 6 | ) 7 | 8 | func cmdRestart(c CommandLine, api libmachine.API) error { 9 | if err := runAction("restart", c, api); err != nil { 10 | return err 11 | } 12 | 13 | log.Info("Restarted machines may have new IP addresses. You may need to re-run the `docker-machine env` command.") 14 | 15 | return nil 16 | } 17 | -------------------------------------------------------------------------------- /commands/scp_unix.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package commands 4 | 5 | import ( 6 | "github.com/docker/machine/libmachine" 7 | ) 8 | 9 | func cmdScp(c CommandLine, api libmachine.API) error { 10 | args := c.Args() 11 | if len(args) != 2 { 12 | c.ShowHelp() 13 | return errWrongNumberArguments 14 | } 15 | 16 | src := args[0] 17 | dest := args[1] 18 | 19 | hostInfoLoader := &storeHostInfoLoader{api} 20 | 21 | cmd, err := getScpCmd(src, dest, c.Bool("recursive"), c.Bool("delta"), c.Bool("quiet"), hostInfoLoader) 22 | if err != nil { 23 | return err 24 | } 25 | 26 | return runCmdWithStdIo(*cmd) 27 | } 28 | -------------------------------------------------------------------------------- /commands/start.go: -------------------------------------------------------------------------------- 1 | package commands 2 | 3 | import ( 4 | "github.com/docker/machine/libmachine" 5 | "github.com/docker/machine/libmachine/log" 6 | ) 7 | 8 | func cmdStart(c CommandLine, api libmachine.API) error { 9 | if err := runAction("start", c, api); err != nil { 10 | return err 11 | } 12 | 13 | log.Info("Started machines may have new IP addresses. You may need to re-run the `docker-machine env` command.") 14 | 15 | return nil 16 | } 17 | -------------------------------------------------------------------------------- /commands/status.go: -------------------------------------------------------------------------------- 1 | package commands 2 | 3 | import ( 4 | "fmt" 5 | "github.com/docker/machine/libmachine" 6 | "github.com/docker/machine/libmachine/log" 7 | ) 8 | 9 | func cmdStatus(c CommandLine, api libmachine.API) error { 10 | if len(c.Args()) > 1 { 11 | return ErrExpectedOneMachine 12 | } 13 | 14 | target, err := targetHost(c, api) 15 | if err != nil { 16 | return err 17 | } 18 | 19 | host, err := api.Load(target) 20 | if err != nil { 21 | return err 22 | } 23 | 24 | currentState, err := host.Driver.GetState() 25 | if err != nil { 26 | return fmt.Errorf("error getting state for host %s: %s", host.Name, err) 27 | } 28 | 29 | log.Info(currentState) 30 | 31 | return nil 32 | } 33 | -------------------------------------------------------------------------------- /commands/stop.go: -------------------------------------------------------------------------------- 1 | package commands 2 | 3 | import "github.com/docker/machine/libmachine" 4 | 5 | func cmdStop(c CommandLine, api libmachine.API) error { 6 | return runAction("stop", c, api) 7 | } 8 | -------------------------------------------------------------------------------- /commands/upgrade.go: -------------------------------------------------------------------------------- 1 | package commands 2 | 3 | import "github.com/docker/machine/libmachine" 4 | 5 | func cmdUpgrade(c CommandLine, api libmachine.API) error { 6 | return runAction("upgrade", c, api) 7 | } 8 | -------------------------------------------------------------------------------- /commands/url.go: -------------------------------------------------------------------------------- 1 | package commands 2 | 3 | import ( 4 | "fmt" 5 | 6 | "github.com/docker/machine/libmachine" 7 | ) 8 | 9 | func cmdURL(c CommandLine, api libmachine.API) error { 10 | if len(c.Args()) > 1 { 11 | return ErrExpectedOneMachine 12 | } 13 | 14 | target, err := targetHost(c, api) 15 | if err != nil { 16 | return err 17 | } 18 | 19 | host, err := api.Load(target) 20 | if err != nil { 21 | return err 22 | } 23 | 24 | url, err := host.URL() 25 | if err != nil { 26 | return err 27 | } 28 | 29 | fmt.Println(url) 30 | 31 | return nil 32 | } 33 | -------------------------------------------------------------------------------- /commands/version.go: -------------------------------------------------------------------------------- 1 | package commands 2 | 3 | import ( 4 | "fmt" 5 | 6 | "io" 7 | "os" 8 | 9 | "github.com/docker/machine/libmachine" 10 | "github.com/docker/machine/libmachine/mcndockerclient" 11 | ) 12 | 13 | func cmdVersion(c CommandLine, api libmachine.API) error { 14 | return printVersion(c, api, os.Stdout) 15 | } 16 | 17 | func printVersion(c CommandLine, api libmachine.API, out io.Writer) error { 18 | if len(c.Args()) == 0 { 19 | c.ShowVersion() 20 | return nil 21 | } 22 | 23 | if len(c.Args()) != 1 { 24 | return ErrExpectedOneMachine 25 | } 26 | 27 | host, err := api.Load(c.Args().First()) 28 | if err != nil { 29 | return err 30 | } 31 | 32 | version, err := mcndockerclient.DockerVersion(host) 33 | if err != nil { 34 | return err 35 | } 36 | 37 | fmt.Fprintln(out, version) 38 | 39 | return nil 40 | } 41 | -------------------------------------------------------------------------------- /contrib/completion/.gitignore: -------------------------------------------------------------------------------- 1 | !docker-machine* 2 | -------------------------------------------------------------------------------- /doc.go: -------------------------------------------------------------------------------- 1 | // Package machine defines interfaces to manage a variety of docker instances 2 | // deployed on different backends (VMs, baremetal). 3 | // The goal is to allow users get from zero to docker as fast as possible. 4 | package machine 5 | -------------------------------------------------------------------------------- /drivers/amazonec2/logger.go: -------------------------------------------------------------------------------- 1 | package amazonec2 2 | 3 | import ( 4 | "github.com/aws/aws-sdk-go/aws" 5 | "log" 6 | "os" 7 | ) 8 | 9 | type awslogger struct { 10 | logger *log.Logger 11 | } 12 | 13 | func AwsLogger() aws.Logger { 14 | return &awslogger{ 15 | logger: log.New(os.Stderr, "", log.LstdFlags), 16 | } 17 | } 18 | 19 | func (l awslogger) Log(args ...interface{}) { 20 | l.logger.Println(args...) 21 | } 22 | -------------------------------------------------------------------------------- /drivers/azure/azureutil/authorizer.go: -------------------------------------------------------------------------------- 1 | package azureutil 2 | 3 | import ( 4 | "fmt" 5 | 6 | "github.com/Azure/go-autorest/autorest" 7 | ) 8 | 9 | // accessToken is interim autorest.Authorizer until we figure out oauth token 10 | // handling. It holds the access token. 11 | type accessToken string 12 | 13 | func (a accessToken) WithAuthorization() autorest.PrepareDecorator { 14 | return autorest.WithHeader("Authorization", fmt.Sprintf("Bearer %s", string(a))) 15 | } 16 | -------------------------------------------------------------------------------- /drivers/azure/azureutil/context.go: -------------------------------------------------------------------------------- 1 | package azureutil 2 | 3 | import ( 4 | "github.com/Azure/azure-sdk-for-go/arm/network" 5 | "github.com/Azure/azure-sdk-for-go/arm/storage" 6 | ) 7 | 8 | // DeploymentContext contains references to various sources created and then 9 | // used in creating other resources. 10 | type DeploymentContext struct { 11 | VirtualNetworkExists bool 12 | StorageAccount *storage.AccountProperties 13 | PublicIPAddressID string 14 | NetworkSecurityGroupID string 15 | SubnetID string 16 | NetworkInterfaceID string 17 | SSHPublicKey string 18 | AvailabilitySetID string 19 | FirewallRules *[]network.SecurityRule 20 | } 21 | -------------------------------------------------------------------------------- /drivers/azure/azureutil/naming.go: -------------------------------------------------------------------------------- 1 | package azureutil 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | const ( 8 | fmtNIC = "%s-nic" 9 | fmtIP = "%s-ip" 10 | fmtNSG = "%s-firewall" 11 | fmtVM = "%s" 12 | ) 13 | 14 | // ResourceNaming provides methods to construct Azure resource names for a given 15 | // machine name. 16 | type ResourceNaming string 17 | 18 | func (r ResourceNaming) IP() string { return fmt.Sprintf(fmtIP, r) } 19 | func (r ResourceNaming) NIC() string { return fmt.Sprintf(fmtNIC, r) } 20 | func (r ResourceNaming) NSG() string { return fmt.Sprintf(fmtNSG, r) } 21 | func (r ResourceNaming) VM() string { return fmt.Sprintf(fmtVM, r) } 22 | -------------------------------------------------------------------------------- /drivers/azure/logutil/logfields.go: -------------------------------------------------------------------------------- 1 | package logutil 2 | 3 | import "fmt" 4 | 5 | type Fields map[string]interface{} 6 | 7 | func (f Fields) String() string { 8 | var s string 9 | for k, v := range f { 10 | if sv, ok := v.(string); ok { 11 | v = fmt.Sprintf("%q", sv) 12 | } 13 | s += fmt.Sprintf(" %s=%v", k, v) 14 | } 15 | return s 16 | } 17 | -------------------------------------------------------------------------------- /drivers/azure/util_test.go: -------------------------------------------------------------------------------- 1 | package azure 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/Azure/azure-sdk-for-go/arm/network" 7 | "github.com/stretchr/testify/assert" 8 | ) 9 | 10 | func TestParseSecurityRuleProtocol(t *testing.T) { 11 | tests := []struct { 12 | raw string 13 | expectedProto network.SecurityRuleProtocol 14 | expectedErr bool 15 | }{ 16 | {"tcp", network.TCP, false}, 17 | {"udp", network.UDP, false}, 18 | {"*", network.Asterisk, false}, 19 | {"Invalid", "", true}, 20 | } 21 | 22 | for _, tc := range tests { 23 | proto, err := parseSecurityRuleProtocol(tc.raw) 24 | assert.Equal(t, tc.expectedProto, proto) 25 | if tc.expectedErr { 26 | assert.Error(t, err) 27 | } else { 28 | assert.NoError(t, err) 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /drivers/driverutil/util.go: -------------------------------------------------------------------------------- 1 | package driverutil 2 | 3 | import "strings" 4 | 5 | // SplitPortProto splits a string in the format port/protocol, defaulting 6 | // protocol to "tcp" if not provided. 7 | func SplitPortProto(raw string) (port string, protocol string) { 8 | parts := strings.SplitN(raw, "/", 2) 9 | if len(parts) == 1 { 10 | return parts[0], "tcp" 11 | } 12 | return parts[0], parts[1] 13 | } 14 | -------------------------------------------------------------------------------- /drivers/driverutil/util_test.go: -------------------------------------------------------------------------------- 1 | package driverutil 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/stretchr/testify/assert" 7 | ) 8 | 9 | func TestSplitPortProtocol(t *testing.T) { 10 | tests := []struct { 11 | raw string 12 | expectedPort string 13 | expectedProto string 14 | }{ 15 | {"8080/tcp", "8080", "tcp"}, 16 | {"90/udp", "90", "udp"}, 17 | {"80", "80", "tcp"}, 18 | } 19 | 20 | for _, tc := range tests { 21 | port, proto := SplitPortProto(tc.raw) 22 | assert.Equal(t, tc.expectedPort, port) 23 | assert.Equal(t, tc.expectedProto, proto) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /drivers/exoscale/exoscale_test.go: -------------------------------------------------------------------------------- 1 | package exoscale 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/docker/machine/libmachine/drivers" 7 | "github.com/stretchr/testify/assert" 8 | ) 9 | 10 | func TestSetConfigFromFlags(t *testing.T) { 11 | driver := NewDriver("default", "path") 12 | 13 | checkFlags := &drivers.CheckDriverOptions{ 14 | FlagsValues: map[string]interface{}{ 15 | "exoscale-api-key": "API_KEY", 16 | "exoscale-api-secret-key": "API_SECRET_KEY", 17 | }, 18 | CreateFlags: driver.GetCreateFlags(), 19 | } 20 | 21 | err := driver.SetConfigFromFlags(checkFlags) 22 | 23 | assert.NoError(t, err) 24 | assert.Empty(t, checkFlags.InvalidFlags) 25 | } 26 | -------------------------------------------------------------------------------- /drivers/generic/generic_test.go: -------------------------------------------------------------------------------- 1 | package generic 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/docker/machine/libmachine/drivers" 7 | "github.com/stretchr/testify/assert" 8 | ) 9 | 10 | func TestSetConfigFromFlags(t *testing.T) { 11 | driver := NewDriver("default", "path") 12 | 13 | checkFlags := &drivers.CheckDriverOptions{ 14 | FlagsValues: map[string]interface{}{ 15 | "generic-engine-port": "3000", 16 | "generic-ip-address": "localhost", 17 | "generic-ssh-key": "path", 18 | }, 19 | CreateFlags: driver.GetCreateFlags(), 20 | } 21 | 22 | err := driver.SetConfigFromFlags(checkFlags) 23 | 24 | assert.NoError(t, err) 25 | assert.Empty(t, checkFlags.InvalidFlags) 26 | } 27 | -------------------------------------------------------------------------------- /drivers/google/google_test.go: -------------------------------------------------------------------------------- 1 | package google 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/docker/machine/libmachine/drivers" 7 | "github.com/stretchr/testify/assert" 8 | ) 9 | 10 | func TestSetConfigFromFlags(t *testing.T) { 11 | driver := NewDriver("", "") 12 | 13 | checkFlags := &drivers.CheckDriverOptions{ 14 | FlagsValues: map[string]interface{}{ 15 | "google-project": "PROJECT", 16 | }, 17 | CreateFlags: driver.GetCreateFlags(), 18 | } 19 | 20 | err := driver.SetConfigFromFlags(checkFlags) 21 | 22 | assert.NoError(t, err) 23 | assert.Empty(t, checkFlags.InvalidFlags) 24 | } 25 | -------------------------------------------------------------------------------- /drivers/openstack/openstack_test.go: -------------------------------------------------------------------------------- 1 | package openstack 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/docker/machine/libmachine/drivers" 7 | "github.com/stretchr/testify/assert" 8 | ) 9 | 10 | func TestSetConfigFromFlags(t *testing.T) { 11 | driver := NewDriver("default", "path") 12 | 13 | checkFlags := &drivers.CheckDriverOptions{ 14 | FlagsValues: map[string]interface{}{ 15 | "openstack-auth-url": "http://url", 16 | "openstack-username": "user", 17 | "openstack-password": "pwd", 18 | "openstack-tenant-id": "ID", 19 | "openstack-flavor-id": "ID", 20 | "openstack-image-id": "ID", 21 | }, 22 | CreateFlags: driver.GetCreateFlags(), 23 | } 24 | 25 | err := driver.SetConfigFromFlags(checkFlags) 26 | 27 | assert.NoError(t, err) 28 | assert.Empty(t, checkFlags.InvalidFlags) 29 | } 30 | -------------------------------------------------------------------------------- /drivers/rackspace/rackspace_test.go: -------------------------------------------------------------------------------- 1 | package rackspace 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/docker/machine/libmachine/drivers" 7 | "github.com/stretchr/testify/assert" 8 | ) 9 | 10 | func TestSetConfigFromFlags(t *testing.T) { 11 | driver := NewDriver("default", "path") 12 | 13 | checkFlags := &drivers.CheckDriverOptions{ 14 | FlagsValues: map[string]interface{}{ 15 | "rackspace-region": "REGION", 16 | "rackspace-username": "user", 17 | "rackspace-api-key": "KEY", 18 | "rackspace-endpoint-type": "publicURL", 19 | }, 20 | CreateFlags: driver.GetCreateFlags(), 21 | } 22 | 23 | err := driver.SetConfigFromFlags(checkFlags) 24 | 25 | assert.NoError(t, err) 26 | assert.Empty(t, checkFlags.InvalidFlags) 27 | } 28 | -------------------------------------------------------------------------------- /drivers/virtualbox/virtualbox_darwin.go: -------------------------------------------------------------------------------- 1 | package virtualbox 2 | 3 | func detectVBoxManageCmd() string { 4 | return detectVBoxManageCmdInPath() 5 | } 6 | 7 | func getShareDriveAndName() (string, string) { 8 | return "Users", "/Users" 9 | } 10 | 11 | func isHyperVInstalled() bool { 12 | return false 13 | } 14 | -------------------------------------------------------------------------------- /drivers/virtualbox/virtualbox_darwin_test.go: -------------------------------------------------------------------------------- 1 | package virtualbox 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/stretchr/testify/assert" 7 | ) 8 | 9 | func TestShareName(t *testing.T) { 10 | name, dir := getShareDriveAndName() 11 | 12 | assert.Equal(t, name, "Users") 13 | assert.Equal(t, dir, "/Users") 14 | 15 | } 16 | -------------------------------------------------------------------------------- /drivers/virtualbox/virtualbox_freebsd.go: -------------------------------------------------------------------------------- 1 | package virtualbox 2 | 3 | import "path/filepath" 4 | 5 | func detectVBoxManageCmd() string { 6 | return detectVBoxManageCmdInPath() 7 | } 8 | 9 | func getShareDriveAndName() (string, string) { 10 | path, err := filepath.EvalSymlinks("/home") 11 | if err != nil { 12 | path = "/home" 13 | } 14 | 15 | return "hosthome", path 16 | } 17 | 18 | func isHyperVInstalled() bool { 19 | return false 20 | } 21 | -------------------------------------------------------------------------------- /drivers/virtualbox/virtualbox_linux.go: -------------------------------------------------------------------------------- 1 | package virtualbox 2 | 3 | func detectVBoxManageCmd() string { 4 | return detectVBoxManageCmdInPath() 5 | } 6 | 7 | func getShareDriveAndName() (string, string) { 8 | return "hosthome", "/home" 9 | } 10 | 11 | func isHyperVInstalled() bool { 12 | return false 13 | } 14 | -------------------------------------------------------------------------------- /drivers/virtualbox/virtualbox_linux_test.go: -------------------------------------------------------------------------------- 1 | package virtualbox 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/stretchr/testify/assert" 7 | ) 8 | 9 | func TestShareName(t *testing.T) { 10 | name, dir := getShareDriveAndName() 11 | 12 | assert.Equal(t, name, "hosthome") 13 | assert.Equal(t, dir, "/home") 14 | } 15 | -------------------------------------------------------------------------------- /drivers/virtualbox/virtualbox_openbsd.go: -------------------------------------------------------------------------------- 1 | package virtualbox 2 | 3 | func detectVBoxManageCmd() string { 4 | return detectVBoxManageCmdInPath() 5 | } 6 | 7 | func getShareDriveAndName() (string, string) { 8 | return "hosthome", "/home" 9 | } 10 | 11 | func isHyperVInstalled() bool { 12 | return false 13 | } 14 | -------------------------------------------------------------------------------- /drivers/virtualbox/vm.go: -------------------------------------------------------------------------------- 1 | package virtualbox 2 | 3 | import "strconv" 4 | 5 | type VM struct { 6 | CPUs int 7 | Memory int 8 | } 9 | 10 | func getVMInfo(name string, vbox VBoxManager) (*VM, error) { 11 | out, err := vbox.vbmOut("showvminfo", name, "--machinereadable") 12 | if err != nil { 13 | return nil, err 14 | } 15 | 16 | vm := &VM{} 17 | 18 | err = parseKeyValues(out, reEqualLine, func(key, val string) error { 19 | switch key { 20 | case "cpus": 21 | v, err := strconv.Atoi(val) 22 | if err != nil { 23 | return err 24 | } 25 | vm.CPUs = v 26 | case "memory": 27 | v, err := strconv.Atoi(val) 28 | if err != nil { 29 | return err 30 | } 31 | vm.Memory = v 32 | } 33 | 34 | return nil 35 | }) 36 | if err != nil { 37 | return nil, err 38 | } 39 | 40 | return vm, nil 41 | } 42 | -------------------------------------------------------------------------------- /drivers/virtualbox/vtx_intel.go: -------------------------------------------------------------------------------- 1 | // +build 386 amd64 2 | 3 | package virtualbox 4 | 5 | import "github.com/intel-go/cpuid" 6 | 7 | // IsVTXDisabled checks if VT-x is disabled in the CPU. 8 | func (d *Driver) IsVTXDisabled() bool { 9 | if cpuid.HasFeature(cpuid.VMX) || cpuid.HasExtraFeature(cpuid.SVM) { 10 | return false 11 | } 12 | 13 | return true 14 | } 15 | -------------------------------------------------------------------------------- /drivers/virtualbox/vtx_other.go: -------------------------------------------------------------------------------- 1 | // +build !386,!amd64 2 | 3 | package virtualbox 4 | 5 | // IsVTXDisabled checks if VT-x is disabled in the CPU. 6 | func (d *Driver) IsVTXDisabled() bool { 7 | return true 8 | } 9 | -------------------------------------------------------------------------------- /drivers/vmwarefusion/fusion.go: -------------------------------------------------------------------------------- 1 | // +build !darwin 2 | 3 | package vmwarefusion 4 | 5 | import "github.com/docker/machine/libmachine/drivers" 6 | 7 | func NewDriver(hostName, storePath string) drivers.Driver { 8 | return drivers.NewDriverNotSupported("vmwarefusion", hostName, storePath) 9 | } 10 | -------------------------------------------------------------------------------- /drivers/vmwarefusion/fusion_darwin_test.go: -------------------------------------------------------------------------------- 1 | package vmwarefusion 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/docker/machine/libmachine/drivers" 7 | "github.com/stretchr/testify/assert" 8 | ) 9 | 10 | func TestSetConfigFromFlags(t *testing.T) { 11 | driver := NewDriver("default", "path") 12 | 13 | checkFlags := &drivers.CheckDriverOptions{ 14 | FlagsValues: map[string]interface{}{}, 15 | CreateFlags: driver.GetCreateFlags(), 16 | } 17 | 18 | err := driver.SetConfigFromFlags(checkFlags) 19 | 20 | assert.NoError(t, err) 21 | assert.Empty(t, checkFlags.InvalidFlags) 22 | } 23 | -------------------------------------------------------------------------------- /drivers/vmwarevcloudair/vcloudlair_test.go: -------------------------------------------------------------------------------- 1 | package vmwarevcloudair 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/docker/machine/libmachine/drivers" 7 | "github.com/stretchr/testify/assert" 8 | ) 9 | 10 | func TestSetConfigFromFlags(t *testing.T) { 11 | driver := NewDriver("default", "path") 12 | 13 | checkFlags := &drivers.CheckDriverOptions{ 14 | FlagsValues: map[string]interface{}{ 15 | "vmwarevcloudair-username": "root", 16 | "vmwarevcloudair-password": "pwd", 17 | "vmwarevcloudair-vdcid": "ID", 18 | "vmwarevcloudair-publicip": "IP", 19 | }, 20 | CreateFlags: driver.GetCreateFlags(), 21 | } 22 | 23 | err := driver.SetConfigFromFlags(checkFlags) 24 | 25 | assert.NoError(t, err) 26 | assert.Empty(t, checkFlags.InvalidFlags) 27 | } 28 | -------------------------------------------------------------------------------- /drivers/vmwarevsphere/vsphere_test.go: -------------------------------------------------------------------------------- 1 | package vmwarevsphere 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/docker/machine/libmachine/drivers" 7 | "github.com/stretchr/testify/assert" 8 | ) 9 | 10 | func TestSetConfigFromFlags(t *testing.T) { 11 | driver := NewDriver("default", "path") 12 | 13 | checkFlags := &drivers.CheckDriverOptions{ 14 | FlagsValues: map[string]interface{}{}, 15 | CreateFlags: driver.GetCreateFlags(), 16 | } 17 | 18 | err := driver.SetConfigFromFlags(checkFlags) 19 | 20 | assert.NoError(t, err) 21 | assert.Empty(t, checkFlags.InvalidFlags) 22 | } 23 | -------------------------------------------------------------------------------- /its/cli/driver_help_test.go: -------------------------------------------------------------------------------- 1 | package cli 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/docker/machine/its" 7 | ) 8 | 9 | func TestDriverHelp(t *testing.T) { 10 | test := its.NewTest(t) 11 | defer test.TearDown() 12 | 13 | test.SkipDriver("ci-test") 14 | 15 | test.Run("no --help flag or command specified", func() { 16 | test.Machine("create -d $DRIVER").Should().Fail("Error: No machine name specified") 17 | }) 18 | 19 | test.Run("-h flag specified", func() { 20 | test.Machine("create -d $DRIVER -h").Should().Succeed(test.DriverName()) 21 | }) 22 | 23 | test.Run("--help flag specified", func() { 24 | test.Machine("create -d $DRIVER --help").Should().Succeed(test.DriverName()) 25 | }) 26 | } 27 | -------------------------------------------------------------------------------- /its/cli/inspect_test.go: -------------------------------------------------------------------------------- 1 | package cli 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/docker/machine/its" 7 | ) 8 | 9 | func TestInspect(t *testing.T) { 10 | test := its.NewTest(t) 11 | defer test.TearDown() 12 | 13 | test.Run("inspect: show error in case of no args", func() { 14 | test.Machine("inspect").Should().Fail(`Error: No machine name(s) specified and no "default" machine exists`) 15 | }) 16 | } 17 | -------------------------------------------------------------------------------- /its/cli/status_test.go: -------------------------------------------------------------------------------- 1 | package cli 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/docker/machine/its" 7 | ) 8 | 9 | func TestStatus(t *testing.T) { 10 | test := its.NewTest(t) 11 | defer test.TearDown() 12 | 13 | test.Run("status: show error in case of no args", func() { 14 | test.Machine("status").Should().Fail(`Error: No machine name(s) specified and no "default" machine exists`) 15 | }) 16 | } 17 | -------------------------------------------------------------------------------- /its/cli/url_test.go: -------------------------------------------------------------------------------- 1 | package cli 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/docker/machine/its" 7 | ) 8 | 9 | func TestUrl(t *testing.T) { 10 | test := its.NewTest(t) 11 | defer test.TearDown() 12 | 13 | test.Run("url: show error in case of no args", func() { 14 | test.Machine("url").Should().Fail(`Error: No machine name(s) specified and no "default" machine exists`) 15 | }) 16 | } 17 | -------------------------------------------------------------------------------- /libmachine/auth/auth.go: -------------------------------------------------------------------------------- 1 | package auth 2 | 3 | type Options struct { 4 | CertDir string 5 | CaCertPath string 6 | CaPrivateKeyPath string 7 | CaCertRemotePath string 8 | ServerCertPath string 9 | ServerKeyPath string 10 | ClientKeyPath string 11 | ServerCertRemotePath string 12 | ServerKeyRemotePath string 13 | ClientCertPath string 14 | ServerCertSANs []string 15 | // StorePath is left in for historical reasons, but not really meant to 16 | // be used directly. 17 | StorePath string 18 | } 19 | -------------------------------------------------------------------------------- /libmachine/crashreport/crash_report_logger.go: -------------------------------------------------------------------------------- 1 | package crashreport 2 | 3 | import "github.com/docker/machine/libmachine/log" 4 | 5 | type logger struct{} 6 | 7 | func (d *logger) Printf(fmtString string, args ...interface{}) { 8 | log.Debugf(fmtString, args) 9 | } 10 | -------------------------------------------------------------------------------- /libmachine/crashreport/os_darwin.go: -------------------------------------------------------------------------------- 1 | package crashreport 2 | 3 | import "os/exec" 4 | 5 | func localOSVersion() string { 6 | command := exec.Command("bash", "-c", `sw_vers | grep ProductVersion | cut -d$'\t' -f2`) 7 | output, err := command.Output() 8 | if err != nil { 9 | return "" 10 | } 11 | return string(output) 12 | } 13 | -------------------------------------------------------------------------------- /libmachine/crashreport/os_freebsd.go: -------------------------------------------------------------------------------- 1 | package crashreport 2 | 3 | import "os/exec" 4 | 5 | func localOSVersion() string { 6 | command := exec.Command("uname", "-r") 7 | output, err := command.Output() 8 | if err != nil { 9 | return "" 10 | } 11 | return string(output) 12 | } 13 | -------------------------------------------------------------------------------- /libmachine/crashreport/os_linux.go: -------------------------------------------------------------------------------- 1 | package crashreport 2 | 3 | import "os/exec" 4 | 5 | func localOSVersion() string { 6 | command := exec.Command("bash", "-c", `cat /etc/os-release | grep 'VERSION=' | cut -d'=' -f2`) 7 | output, err := command.Output() 8 | if err != nil { 9 | return "" 10 | } 11 | return string(output) 12 | } 13 | -------------------------------------------------------------------------------- /libmachine/crashreport/os_openbsd.go: -------------------------------------------------------------------------------- 1 | package crashreport 2 | 3 | import "os/exec" 4 | 5 | func localOSVersion() string { 6 | command := exec.Command("uname", "-r") 7 | output, err := command.Output() 8 | if err != nil { 9 | return "" 10 | } 11 | return string(output) 12 | } 13 | -------------------------------------------------------------------------------- /libmachine/engine/engine.go: -------------------------------------------------------------------------------- 1 | package engine 2 | 3 | const ( 4 | DefaultPort = 2376 5 | ) 6 | 7 | type Options struct { 8 | ArbitraryFlags []string 9 | DNS []string `json:"Dns"` 10 | GraphDir string 11 | Env []string 12 | Ipv6 bool 13 | InsecureRegistry []string 14 | Labels []string 15 | LogLevel string 16 | StorageDriver string 17 | SelinuxEnabled bool 18 | TLSVerify bool `json:"TlsVerify"` 19 | RegistryMirror []string 20 | InstallURL string 21 | } 22 | -------------------------------------------------------------------------------- /libmachine/host/host_v0.go: -------------------------------------------------------------------------------- 1 | package host 2 | 3 | import "github.com/docker/machine/libmachine/drivers" 4 | 5 | type V0 struct { 6 | Name string `json:"-"` 7 | Driver drivers.Driver 8 | DriverName string 9 | ConfigVersion int 10 | HostOptions *Options 11 | 12 | StorePath string 13 | CaCertPath string 14 | PrivateKeyPath string 15 | ServerCertPath string 16 | ServerKeyPath string 17 | ClientCertPath string 18 | SwarmHost string 19 | SwarmMaster bool 20 | SwarmDiscovery string 21 | ClientKeyPath string 22 | } 23 | 24 | type MetadataV0 struct { 25 | HostOptions Options 26 | DriverName string 27 | 28 | ConfigVersion int 29 | StorePath string 30 | CaCertPath string 31 | PrivateKeyPath string 32 | ServerCertPath string 33 | ServerKeyPath string 34 | ClientCertPath string 35 | } 36 | -------------------------------------------------------------------------------- /libmachine/host/host_v2.go: -------------------------------------------------------------------------------- 1 | package host 2 | 3 | import "github.com/docker/machine/libmachine/drivers" 4 | 5 | type V2 struct { 6 | ConfigVersion int 7 | Driver drivers.Driver 8 | DriverName string 9 | HostOptions *Options 10 | Name string 11 | } 12 | -------------------------------------------------------------------------------- /libmachine/log/history_recorder.go: -------------------------------------------------------------------------------- 1 | package log 2 | 3 | import ( 4 | "fmt" 5 | "sync" 6 | ) 7 | 8 | type HistoryRecorder struct { 9 | lock *sync.Mutex 10 | records []string 11 | } 12 | 13 | func NewHistoryRecorder() *HistoryRecorder { 14 | return &HistoryRecorder{ 15 | lock: &sync.Mutex{}, 16 | records: []string{}, 17 | } 18 | } 19 | 20 | func (ml *HistoryRecorder) History() []string { 21 | return ml.records 22 | } 23 | 24 | func (ml *HistoryRecorder) Record(args ...interface{}) { 25 | ml.lock.Lock() 26 | defer ml.lock.Unlock() 27 | ml.records = append(ml.records, fmt.Sprint(args...)) 28 | } 29 | 30 | func (ml *HistoryRecorder) Recordf(fmtString string, args ...interface{}) { 31 | ml.lock.Lock() 32 | defer ml.lock.Unlock() 33 | ml.records = append(ml.records, fmt.Sprintf(fmtString, args...)) 34 | } 35 | -------------------------------------------------------------------------------- /libmachine/log/history_recorder_test.go: -------------------------------------------------------------------------------- 1 | package log 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/stretchr/testify/assert" 7 | ) 8 | 9 | func TestRecording(t *testing.T) { 10 | recorder := NewHistoryRecorder() 11 | recorder.Record("foo") 12 | recorder.Record("bar") 13 | recorder.Record("qix") 14 | assert.Equal(t, recorder.History(), []string{"foo", "bar", "qix"}) 15 | } 16 | 17 | func TestFormattedRecording(t *testing.T) { 18 | recorder := NewHistoryRecorder() 19 | recorder.Recordf("%s, %s and %s", "foo", "bar", "qix") 20 | assert.Equal(t, recorder.History()[0], "foo, bar and qix") 21 | } 22 | -------------------------------------------------------------------------------- /libmachine/log/machine_logger.go: -------------------------------------------------------------------------------- 1 | package log 2 | 3 | import "io" 4 | 5 | type MachineLogger interface { 6 | SetDebug(debug bool) 7 | 8 | SetOutWriter(io.Writer) 9 | SetErrWriter(io.Writer) 10 | 11 | Debug(args ...interface{}) 12 | Debugf(fmtString string, args ...interface{}) 13 | 14 | Error(args ...interface{}) 15 | Errorf(fmtString string, args ...interface{}) 16 | 17 | Info(args ...interface{}) 18 | Infof(fmtString string, args ...interface{}) 19 | 20 | Warn(args ...interface{}) 21 | Warnf(fmtString string, args ...interface{}) 22 | 23 | History() []string 24 | } 25 | -------------------------------------------------------------------------------- /libmachine/mcndockerclient/fake_docker_versioner.go: -------------------------------------------------------------------------------- 1 | package mcndockerclient 2 | 3 | type FakeDockerVersioner struct { 4 | Version string 5 | Err error 6 | } 7 | 8 | func (dv *FakeDockerVersioner) DockerVersion(host DockerHost) (string, error) { 9 | if dv.Err != nil { 10 | return "", dv.Err 11 | } 12 | 13 | return dv.Version, nil 14 | } 15 | -------------------------------------------------------------------------------- /libmachine/provider/provider.go: -------------------------------------------------------------------------------- 1 | package provider 2 | 3 | import "github.com/docker/machine/libmachine/host" 4 | 5 | type Provider interface { 6 | // IsValid checks whether or not the Provider can successfully create 7 | // machines. If the check does not pass, the provider is no good. 8 | IsValid() bool 9 | 10 | // Create calls out to the driver this provider is associated with, to 11 | // actually create the resource. 12 | Create() (host.Host, error) 13 | } 14 | -------------------------------------------------------------------------------- /libmachine/provision/arch_test.go: -------------------------------------------------------------------------------- 1 | package provision 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/docker/machine/drivers/fakedriver" 7 | "github.com/docker/machine/libmachine/auth" 8 | "github.com/docker/machine/libmachine/engine" 9 | "github.com/docker/machine/libmachine/provision/provisiontest" 10 | "github.com/docker/machine/libmachine/swarm" 11 | ) 12 | 13 | func TestArchDefaultStorageDriver(t *testing.T) { 14 | p := NewArchProvisioner(&fakedriver.Driver{}).(*ArchProvisioner) 15 | p.SSHCommander = provisiontest.NewFakeSSHCommander(provisiontest.FakeSSHCommanderOptions{}) 16 | p.Provision(swarm.Options{}, auth.Options{}, engine.Options{}) 17 | if p.EngineOptions.StorageDriver != "overlay2" { 18 | t.Fatal("Default storage driver should be overlay2") 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /libmachine/provision/centos.go: -------------------------------------------------------------------------------- 1 | package provision 2 | 3 | import ( 4 | "github.com/docker/machine/libmachine/drivers" 5 | ) 6 | 7 | func init() { 8 | Register("Centos", &RegisteredProvisioner{ 9 | New: NewCentosProvisioner, 10 | }) 11 | } 12 | 13 | func NewCentosProvisioner(d drivers.Driver) Provisioner { 14 | return &CentosProvisioner{ 15 | NewRedHatProvisioner("centos", d), 16 | } 17 | } 18 | 19 | type CentosProvisioner struct { 20 | *RedHatProvisioner 21 | } 22 | 23 | func (provisioner *CentosProvisioner) String() string { 24 | return "centos" 25 | } 26 | -------------------------------------------------------------------------------- /libmachine/provision/debian_test.go: -------------------------------------------------------------------------------- 1 | package provision 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/docker/machine/drivers/fakedriver" 7 | "github.com/docker/machine/libmachine/auth" 8 | "github.com/docker/machine/libmachine/engine" 9 | "github.com/docker/machine/libmachine/provision/provisiontest" 10 | "github.com/docker/machine/libmachine/swarm" 11 | ) 12 | 13 | func TestDebianDefaultStorageDriver(t *testing.T) { 14 | p := NewDebianProvisioner(&fakedriver.Driver{}).(*DebianProvisioner) 15 | p.SSHCommander = provisiontest.NewFakeSSHCommander(provisiontest.FakeSSHCommanderOptions{}) 16 | p.Provision(swarm.Options{}, auth.Options{}, engine.Options{}) 17 | if p.EngineOptions.StorageDriver != "overlay2" { 18 | t.Fatal("Default storage driver should be overlay2") 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /libmachine/provision/engine_config_context.go: -------------------------------------------------------------------------------- 1 | package provision 2 | 3 | import ( 4 | "github.com/docker/machine/libmachine/auth" 5 | "github.com/docker/machine/libmachine/engine" 6 | ) 7 | 8 | type EngineConfigContext struct { 9 | DockerPort int 10 | AuthOptions auth.Options 11 | EngineOptions engine.Options 12 | DockerOptionsDir string 13 | } 14 | -------------------------------------------------------------------------------- /libmachine/provision/errors.go: -------------------------------------------------------------------------------- 1 | package provision 2 | 3 | import ( 4 | "errors" 5 | "fmt" 6 | ) 7 | 8 | var ( 9 | ErrDetectionFailed = errors.New("OS type not recognized") 10 | ) 11 | 12 | type ErrDaemonAvailable struct { 13 | wrappedErr error 14 | } 15 | 16 | func (e ErrDaemonAvailable) Error() string { 17 | return fmt.Sprintf("Unable to verify the Docker daemon is listening: %s", e.wrappedErr) 18 | } 19 | 20 | func NewErrDaemonAvailable(err error) ErrDaemonAvailable { 21 | return ErrDaemonAvailable{ 22 | wrappedErr: err, 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /libmachine/provision/fedora.go: -------------------------------------------------------------------------------- 1 | package provision 2 | 3 | import ( 4 | "github.com/docker/machine/libmachine/drivers" 5 | ) 6 | 7 | func init() { 8 | Register("Fedora", &RegisteredProvisioner{ 9 | New: NewFedoraProvisioner, 10 | }) 11 | } 12 | 13 | func NewFedoraProvisioner(d drivers.Driver) Provisioner { 14 | return &FedoraProvisioner{ 15 | NewRedHatProvisioner("fedora", d), 16 | } 17 | } 18 | 19 | type FedoraProvisioner struct { 20 | *RedHatProvisioner 21 | } 22 | 23 | func (provisioner *FedoraProvisioner) String() string { 24 | return "fedora" 25 | } 26 | -------------------------------------------------------------------------------- /libmachine/provision/oraclelinux.go: -------------------------------------------------------------------------------- 1 | package provision 2 | 3 | import ( 4 | "github.com/docker/machine/libmachine/drivers" 5 | ) 6 | 7 | func init() { 8 | Register("OracleLinux", &RegisteredProvisioner{ 9 | New: NewOracleLinuxProvisioner, 10 | }) 11 | } 12 | 13 | func NewOracleLinuxProvisioner(d drivers.Driver) Provisioner { 14 | return &OracleLinuxProvisioner{ 15 | NewRedHatProvisioner("ol", d), 16 | } 17 | } 18 | 19 | type OracleLinuxProvisioner struct { 20 | *RedHatProvisioner 21 | } 22 | 23 | func (provisioner *OracleLinuxProvisioner) String() string { 24 | return "ol" 25 | } 26 | -------------------------------------------------------------------------------- /libmachine/provision/pkgaction/pkg_action.go: -------------------------------------------------------------------------------- 1 | package pkgaction 2 | 3 | type PackageAction int 4 | 5 | const ( 6 | Install PackageAction = iota 7 | Remove 8 | Upgrade 9 | Purge 10 | ) 11 | 12 | var packageActions = []string{ 13 | "install", 14 | "remove", 15 | "upgrade", 16 | "purge", 17 | } 18 | 19 | func (s PackageAction) String() string { 20 | if int(s) >= 0 && int(s) < len(packageActions) { 21 | return packageActions[s] 22 | } 23 | 24 | return "" 25 | } 26 | -------------------------------------------------------------------------------- /libmachine/provision/pkgaction/pkg_action_test.go: -------------------------------------------------------------------------------- 1 | package pkgaction 2 | 3 | import "testing" 4 | 5 | func TestActionValue(t *testing.T) { 6 | if Install.String() != "install" { 7 | t.Fatalf("Expected %q but got %q", "install", Install.String()) 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /libmachine/provision/redhat_test.go: -------------------------------------------------------------------------------- 1 | package provision 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/docker/machine/drivers/fakedriver" 7 | "github.com/docker/machine/libmachine/auth" 8 | "github.com/docker/machine/libmachine/engine" 9 | "github.com/docker/machine/libmachine/provision/provisiontest" 10 | "github.com/docker/machine/libmachine/swarm" 11 | ) 12 | 13 | func TestRedHatDefaultStorageDriver(t *testing.T) { 14 | p := NewRedHatProvisioner("", &fakedriver.Driver{}) 15 | p.SSHCommander = provisiontest.NewFakeSSHCommander(provisiontest.FakeSSHCommanderOptions{}) 16 | p.Provision(swarm.Options{}, auth.Options{}, engine.Options{}) 17 | if p.EngineOptions.StorageDriver != "overlay2" { 18 | t.Fatal("Default storage driver should be overlay2") 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /libmachine/provision/serviceaction/service_action.go: -------------------------------------------------------------------------------- 1 | package serviceaction 2 | 3 | type ServiceAction int 4 | 5 | const ( 6 | Restart ServiceAction = iota 7 | Start 8 | Stop 9 | Enable 10 | Disable 11 | DaemonReload 12 | ) 13 | 14 | var serviceActions = []string{ 15 | "restart", 16 | "start", 17 | "stop", 18 | "enable", 19 | "disable", 20 | "daemon-reload", 21 | } 22 | 23 | func (s ServiceAction) String() string { 24 | if int(s) >= 0 && int(s) < len(serviceActions) { 25 | return serviceActions[s] 26 | } 27 | 28 | return "" 29 | } 30 | -------------------------------------------------------------------------------- /libmachine/provision/serviceaction/service_action_test.go: -------------------------------------------------------------------------------- 1 | package serviceaction 2 | 3 | import "testing" 4 | 5 | func TestActionValue(t *testing.T) { 6 | if Restart.String() != "restart" { 7 | t.Fatalf("Expected %s but got %s", "install", Restart.String()) 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /libmachine/shell/shell.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package shell 4 | 5 | import ( 6 | "errors" 7 | "fmt" 8 | "os" 9 | "path/filepath" 10 | ) 11 | 12 | var ( 13 | ErrUnknownShell = errors.New("Error: Unknown shell") 14 | ) 15 | 16 | // Detect detects user's current shell. 17 | func Detect() (string, error) { 18 | shell := os.Getenv("SHELL") 19 | 20 | if shell == "" { 21 | fmt.Printf("The default lines below are for a sh/bash shell, you can specify the shell you're using, with the --shell flag.\n\n") 22 | return "", ErrUnknownShell 23 | } 24 | 25 | return filepath.Base(shell), nil 26 | } 27 | -------------------------------------------------------------------------------- /libmachine/shell/shell_test.go: -------------------------------------------------------------------------------- 1 | package shell 2 | 3 | import ( 4 | "os" 5 | "testing" 6 | 7 | "github.com/stretchr/testify/assert" 8 | ) 9 | 10 | func TestDetectBash(t *testing.T) { 11 | defer func(shell string) { os.Setenv("SHELL", shell) }(os.Getenv("SHELL")) 12 | os.Setenv("SHELL", "/bin/bash") 13 | 14 | shell, err := Detect() 15 | 16 | assert.Equal(t, "bash", shell) 17 | assert.NoError(t, err) 18 | } 19 | 20 | func TestDetectFish(t *testing.T) { 21 | defer func(shell string) { os.Setenv("SHELL", shell) }(os.Getenv("SHELL")) 22 | os.Setenv("SHELL", "/bin/fish") 23 | 24 | shell, err := Detect() 25 | 26 | assert.Equal(t, "fish", shell) 27 | assert.NoError(t, err) 28 | } 29 | -------------------------------------------------------------------------------- /libmachine/shell/shell_unix_test.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package shell 4 | 5 | import ( 6 | "os" 7 | "testing" 8 | 9 | "github.com/stretchr/testify/assert" 10 | ) 11 | 12 | func TestUnknownShell(t *testing.T) { 13 | defer func(shell string) { os.Setenv("SHELL", shell) }(os.Getenv("SHELL")) 14 | os.Setenv("SHELL", "") 15 | 16 | shell, err := Detect() 17 | 18 | assert.Equal(t, err, ErrUnknownShell) 19 | assert.Empty(t, shell) 20 | } 21 | -------------------------------------------------------------------------------- /libmachine/ssh/keys_test.go: -------------------------------------------------------------------------------- 1 | package ssh 2 | 3 | import ( 4 | "encoding/pem" 5 | "testing" 6 | ) 7 | 8 | func TestNewKeyPair(t *testing.T) { 9 | pair, err := NewKeyPair() 10 | if err != nil { 11 | t.Fatal(err) 12 | } 13 | 14 | if privPem := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Headers: nil, Bytes: pair.PrivateKey}); len(privPem) == 0 { 15 | t.Fatal("No PEM returned") 16 | } 17 | 18 | if fingerprint := pair.Fingerprint(); len(fingerprint) == 0 { 19 | t.Fatal("Unable to generate fingerprint") 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /libmachine/ssh/ssh_test.go: -------------------------------------------------------------------------------- 1 | package ssh 2 | 3 | import ( 4 | "io/ioutil" 5 | "os" 6 | "path/filepath" 7 | "testing" 8 | ) 9 | 10 | func TestGenerateSSHKey(t *testing.T) { 11 | tmpDir, err := ioutil.TempDir("", "machine-test-") 12 | if err != nil { 13 | t.Fatal(err) 14 | } 15 | 16 | filename := filepath.Join(tmpDir, "sshkey") 17 | 18 | if err := GenerateSSHKey(filename); err != nil { 19 | t.Fatal(err) 20 | } 21 | 22 | if _, err := os.Stat(filename); err != nil { 23 | t.Fatalf("expected ssh key at %s", filename) 24 | } 25 | 26 | // cleanup 27 | _ = os.RemoveAll(tmpDir) 28 | } 29 | -------------------------------------------------------------------------------- /libmachine/ssh/sshtest/fake_client.go: -------------------------------------------------------------------------------- 1 | package sshtest 2 | 3 | import "io" 4 | 5 | type CmdResult struct { 6 | Out string 7 | Err error 8 | } 9 | 10 | type FakeClient struct { 11 | ActivatedShell []string 12 | Outputs map[string]CmdResult 13 | } 14 | 15 | func (fsc *FakeClient) Output(command string) (string, error) { 16 | outerr := fsc.Outputs[command] 17 | return outerr.Out, outerr.Err 18 | } 19 | 20 | func (fsc *FakeClient) Shell(args ...string) error { 21 | fsc.ActivatedShell = args 22 | return nil 23 | } 24 | 25 | func (fsc *FakeClient) Start(command string) (io.ReadCloser, io.ReadCloser, error) { 26 | return nil, nil, nil 27 | } 28 | 29 | func (fsc *FakeClient) Wait() error { 30 | return nil 31 | } 32 | -------------------------------------------------------------------------------- /libmachine/state/state.go: -------------------------------------------------------------------------------- 1 | package state 2 | 3 | // State represents the state of a host 4 | type State int 5 | 6 | const ( 7 | None State = iota 8 | Running 9 | Paused 10 | Saved 11 | Stopped 12 | Stopping 13 | Starting 14 | Error 15 | Timeout 16 | ) 17 | 18 | var states = []string{ 19 | "", 20 | "Running", 21 | "Paused", 22 | "Saved", 23 | "Stopped", 24 | "Stopping", 25 | "Starting", 26 | "Error", 27 | "Timeout", 28 | } 29 | 30 | // Given a State type, returns its string representation 31 | func (s State) String() string { 32 | if int(s) >= 0 && int(s) < len(states) { 33 | return states[s] 34 | } 35 | return "" 36 | } 37 | -------------------------------------------------------------------------------- /libmachine/state/state_test.go: -------------------------------------------------------------------------------- 1 | package state 2 | 3 | import ( 4 | "testing" 5 | ) 6 | 7 | func TestDaemonCreate(t *testing.T) { 8 | if None.String() != "" { 9 | t.Fatal("None state should be empty string") 10 | } 11 | if Running.String() != "Running" { 12 | t.Fatal("Running state should be 'Running'") 13 | } 14 | if Error.String() != "Error" { 15 | t.Fatal("Error state should be 'Error'") 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /libmachine/swarm/swarm.go: -------------------------------------------------------------------------------- 1 | package swarm 2 | 3 | const ( 4 | DiscoveryServiceEndpoint = "https://discovery-stage.hub.docker.com/v1" 5 | ) 6 | 7 | type Options struct { 8 | IsSwarm bool 9 | Address string 10 | Discovery string 11 | Agent bool 12 | Master bool 13 | Host string 14 | Image string 15 | Strategy string 16 | Heartbeat int 17 | Overcommit float64 18 | ArbitraryFlags []string 19 | ArbitraryJoinFlags []string 20 | Env []string 21 | IsExperimental bool 22 | } 23 | -------------------------------------------------------------------------------- /libmachine/version/version.go: -------------------------------------------------------------------------------- 1 | package version 2 | 3 | var ( 4 | // APIVersion dictates which version of the libmachine API this is. 5 | APIVersion = 1 6 | 7 | // ConfigVersion dictates which version of the config.json format is 8 | // used. It needs to be bumped if there is a breaking change, and 9 | // therefore migration, introduced to the config file format. 10 | ConfigVersion = 3 11 | ) 12 | -------------------------------------------------------------------------------- /mk/dev.mk: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/machine-drivers/machine/ddb74f7e6e56c459d4a80ba964d5cee0df3ba35d/mk/dev.mk -------------------------------------------------------------------------------- /mk/test.mk: -------------------------------------------------------------------------------- 1 | # Quick test. You can bypass long tests using: `if testing.Short() { t.Skip("Skipping in short mode.") }` 2 | test-short: 3 | $(GO) test $(VERBOSE_GO) -test.short -tags "$(BUILDTAGS)" $(PKGS) 4 | 5 | # Runs long tests also, plus race detection 6 | test-long: 7 | $(GO) test $(VERBOSE_GO) -race -tags "$(BUILDTAGS)" $(PKGS) 8 | 9 | test-integration: build 10 | $(eval TESTSUITE=$(filter-out $@,$(MAKECMDGOALS))) 11 | test/integration/run-bats.sh $(TESTSUITE) 12 | -------------------------------------------------------------------------------- /script/build_in_container.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | set -e 4 | 5 | DOCKER_IMAGE_NAME="docker-machine-build" 6 | DOCKER_CONTAINER_NAME="docker-machine-build-container" 7 | 8 | if [[ $(docker ps -a | grep $DOCKER_CONTAINER_NAME) != "" ]]; then 9 | docker rm -f $DOCKER_CONTAINER_NAME 2>/dev/null 10 | fi 11 | 12 | docker build -t $DOCKER_IMAGE_NAME . 13 | 14 | docker run --name $DOCKER_CONTAINER_NAME \ 15 | -e DEBUG \ 16 | -e STATIC \ 17 | -e VERBOSE \ 18 | -e BUILDTAGS \ 19 | -e PARALLEL \ 20 | -e COVERAGE_DIR \ 21 | -e TARGET_OS \ 22 | -e TARGET_ARCH \ 23 | -e PREFIX \ 24 | -e TRAVIS_JOB_ID \ 25 | -e TRAVIS_PULL_REQUEST \ 26 | $DOCKER_IMAGE_NAME \ 27 | make "$@" 28 | 29 | if [[ "$@" == *"clean"* ]] && [[ -d bin ]]; then 30 | rm -Rf bin 31 | fi 32 | 33 | docker cp $DOCKER_CONTAINER_NAME:/go/src/github.com/docker/machine/bin . 34 | -------------------------------------------------------------------------------- /test/integration/.gitignore: -------------------------------------------------------------------------------- 1 | env-* 2 | -------------------------------------------------------------------------------- /test/integration/amazonec2/amazon.bats: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bats 2 | 3 | load ${BASE_TEST_DIR}/helpers.bash 4 | 5 | only_if_env DRIVER amazonec2 6 | 7 | use_disposable_machine 8 | 9 | require_env AWS_ACCESS_KEY_ID 10 | require_env AWS_SECRET_ACCESS_KEY 11 | 12 | @test "$DRIVER: Should Create a default host" { 13 | run machine create -d amazonec2 $NAME 14 | echo ${output} 15 | [ "$status" -eq 0 ] 16 | } 17 | -------------------------------------------------------------------------------- /test/integration/amazonec2/createwithkeypair.bats: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bats 2 | 3 | load ${BASE_TEST_DIR}/helpers.bash 4 | 5 | only_if_env DRIVER amazonec2 6 | 7 | use_disposable_machine 8 | 9 | require_env AWS_ACCESS_KEY_ID 10 | 11 | require_env AWS_SECRET_ACCESS_KEY 12 | 13 | export AWS_SSH_DIR="$MACHINE_STORAGE_PATH/mcnkeys" 14 | 15 | export AWS_SSH_KEYPATH=$AWS_SSH_DIR/id_rsa 16 | 17 | @test "$DRIVER: Should Create Instance with Pre existing SSH Key" { 18 | 19 | mkdir -p $AWS_SSH_DIR 20 | 21 | run ssh-keygen -f $AWS_SSH_KEYPATH -t rsa -N '' 22 | 23 | machine create -d amazonec2 $NAME 24 | 25 | run diff $AWS_SSH_KEYPATH $MACHINE_STORAGE_PATH/machines/$NAME/id_rsa 26 | [[ $output == "" ]] 27 | 28 | run diff $AWS_SSH_KEYPATH.pub $MACHINE_STORAGE_PATH/machines/$NAME/id_rsa.pub 29 | [[ $output == "" ]] 30 | 31 | 32 | } -------------------------------------------------------------------------------- /test/integration/core/crashreport.bats: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bats 2 | 3 | load ${BASE_TEST_DIR}/helpers.bash 4 | 5 | only_if_env DRIVER virtualbox 6 | 7 | use_disposable_machine 8 | 9 | @test "$DRIVER: should send bugsnag report" { 10 | # we exploit a 'bug' where vboxmanage wont allow a machine created with 1mb of RAM 11 | run machine --bugsnag-api-token nonexisting -D create -d virtualbox --virtualbox-memory 1 $NAME 12 | echo ${output} 13 | [ "$status" -eq 1 ] 14 | [[ ${output} == *"notifying bugsnag"* ]] 15 | } 16 | -------------------------------------------------------------------------------- /test/integration/core/regenerate-certs.bats: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bats 2 | 3 | load ${BASE_TEST_DIR}/helpers.bash 4 | 5 | use_shared_machine 6 | 7 | @test "$DRIVER: regenerate the certs" { 8 | run machine regenerate-certs -f $NAME 9 | [[ ${status} -eq 0 ]] 10 | } 11 | 12 | @test "$DRIVER: make sure docker still works" { 13 | run docker $(machine config $NAME) version 14 | [[ ${status} -eq 0 ]] 15 | } 16 | -------------------------------------------------------------------------------- /test/integration/virtualbox/dns.bats: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bats 2 | 3 | load ${BASE_TEST_DIR}/helpers.bash 4 | 5 | only_if_env DRIVER virtualbox 6 | 7 | use_disposable_machine 8 | 9 | @test "$DRIVER: Create a vm with a dns proxy set" { 10 | run machine create -d $DRIVER --virtualbox-dns-proxy=true $NAME 11 | [[ ${status} -eq 0 ]] 12 | } 13 | 14 | @test "$DRIVER: Check DNSProxy flag is properly set during machine creation" { 15 | run bash -c "cat ${MACHINE_STORAGE_PATH}/machines/$NAME/$NAME/Logs/VBox.log | grep DNSProxy | grep '(1)'" 16 | [[ ${status} -eq 0 ]] 17 | } -------------------------------------------------------------------------------- /test/integration/virtualbox/guards.bats: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bats 2 | 3 | load ${BASE_TEST_DIR}/helpers.bash 4 | 5 | only_if_env DRIVER virtualbox 6 | 7 | use_disposable_machine 8 | 9 | @test "$DRIVER: Should not allow machine creation with bad ISO" { 10 | run machine create -d virtualbox --virtualbox-boot2docker-url http://dev.null:9111/bad.iso $NAME 11 | [[ ${status} -eq 1 ]] 12 | } 13 | 14 | @test "$DRIVER: Should not allow machine creation with engine-install-url" { 15 | run machine create --engine-install-url https://test.docker.com -d virtualbox $NAME 16 | [[ ${output} == *"--engine-install-url cannot be used"* ]] 17 | } -------------------------------------------------------------------------------- /test/provision/rancheros.bats: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bats 2 | 3 | load ${BASE_TEST_DIR}/helpers.bash 4 | 5 | 6 | # this should move to the makefile 7 | 8 | if [[ "$DRIVER" != "virtualbox" ]]; then 9 | exit 0 10 | fi 11 | 12 | export RANCHEROS_VERSION="v0.3.1" 13 | export RANCHEROS_ISO="https://github.com/rancherio/os/releases/download/$RANCHEROS_VERSION/machine-rancheros.iso" 14 | 15 | @test "$DRIVER: create with RancherOS ISO" { 16 | VIRTUALBOX_BOOT2DOCKER_URL="$RANCHEROS_ISO" run ${BASE_TEST_DIR}/run-bats.sh ${BASE_TEST_DIR}/core 17 | echo ${output} 18 | [ ${status} -eq 0 ] 19 | } 20 | -------------------------------------------------------------------------------- /test/provision/redhat.bats: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bats 2 | 3 | load ${BASE_TEST_DIR}/helpers.bash 4 | 5 | # this should move to the makefile 6 | 7 | if [[ "$DRIVER" != "amazonec2" ]]; then 8 | exit 0 9 | fi 10 | 11 | require_env AWS_VPC_ID 12 | require_env AWS_ACCESS_KEY_ID 13 | require_env AWS_SECRET_ACCESS_KEY 14 | 15 | @test "$DRIVER: create using RedHat AMI" { 16 | # Oh snap, recursive stuff!! 17 | AWS_AMI=ami-12663b7a AWS_SSH_USER=ec2-user run ${BASE_TEST_DIR}/run-bats.sh ${BASE_TEST_DIR}/core 18 | echo ${output} 19 | [ ${status} -eq 0 ] 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/Azure/azure-sdk-for-go/storage/README.md: -------------------------------------------------------------------------------- 1 | # Azure Storage SDK for Go 2 | 3 | The `github.com/Azure/azure-sdk-for-go/storage` package is used to perform operations in Azure Storage Service. To manage your storage accounts (Azure Resource Manager / ARM), use the [github.com/Azure/azure-sdk-for-go/arm/storage](../arm/storage) package. For your classic storage accounts (Azure Service Management / ASM), use [github.com/Azure/azure-sdk-for-go/management/storageservice](../management/storageservice) package. 4 | 5 | This package includes support for [Azure Storage Emulator](https://azure.microsoft.com/documentation/articles/storage-use-emulator/) -------------------------------------------------------------------------------- /vendor/github.com/Azure/go-ansiterm/context.go: -------------------------------------------------------------------------------- 1 | package ansiterm 2 | 3 | type ansiContext struct { 4 | currentChar byte 5 | paramBuffer []byte 6 | interBuffer []byte 7 | } 8 | -------------------------------------------------------------------------------- /vendor/github.com/Azure/go-ansiterm/ground_state.go: -------------------------------------------------------------------------------- 1 | package ansiterm 2 | 3 | type groundState struct { 4 | baseState 5 | } 6 | 7 | func (gs groundState) Handle(b byte) (s state, e error) { 8 | gs.parser.context.currentChar = b 9 | 10 | nextState, err := gs.baseState.Handle(b) 11 | if nextState != nil || err != nil { 12 | return nextState, err 13 | } 14 | 15 | switch { 16 | case sliceContains(printables, b): 17 | return gs, gs.parser.print() 18 | 19 | case sliceContains(executors, b): 20 | return gs, gs.parser.execute() 21 | } 22 | 23 | return gs, nil 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/Azure/go-ansiterm/osc_string_state.go: -------------------------------------------------------------------------------- 1 | package ansiterm 2 | 3 | type oscStringState struct { 4 | baseState 5 | } 6 | 7 | func (oscState oscStringState) Handle(b byte) (s state, e error) { 8 | oscState.parser.logf("OscString::Handle %#x", b) 9 | nextState, err := oscState.baseState.Handle(b) 10 | if nextState != nil || err != nil { 11 | return nextState, err 12 | } 13 | 14 | switch { 15 | case isOscStringTerminator(b): 16 | return oscState.parser.ground, nil 17 | } 18 | 19 | return oscState, nil 20 | } 21 | 22 | // See below for OSC string terminators for linux 23 | // http://man7.org/linux/man-pages/man4/console_codes.4.html 24 | func isOscStringTerminator(b byte) bool { 25 | 26 | if b == ANSI_BEL || b == 0x5C { 27 | return true 28 | } 29 | 30 | return false 31 | } 32 | -------------------------------------------------------------------------------- /vendor/github.com/Azure/go-ansiterm/utilities.go: -------------------------------------------------------------------------------- 1 | package ansiterm 2 | 3 | import ( 4 | "strconv" 5 | ) 6 | 7 | func sliceContains(bytes []byte, b byte) bool { 8 | for _, v := range bytes { 9 | if v == b { 10 | return true 11 | } 12 | } 13 | 14 | return false 15 | } 16 | 17 | func convertBytesToInteger(bytes []byte) int { 18 | s := string(bytes) 19 | i, _ := strconv.Atoi(s) 20 | return i 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/Azure/go-ansiterm/winterm/utilities.go: -------------------------------------------------------------------------------- 1 | // +build windows 2 | 3 | package winterm 4 | 5 | // AddInRange increments a value by the passed quantity while ensuring the values 6 | // always remain within the supplied min / max range. 7 | func addInRange(n int16, increment int16, min int16, max int16) int16 { 8 | return ensureInRange(n+increment, min, max) 9 | } 10 | -------------------------------------------------------------------------------- /vendor/github.com/Azure/go-autorest/autorest/azure/config.go: -------------------------------------------------------------------------------- 1 | package azure 2 | 3 | import ( 4 | "net/url" 5 | ) 6 | 7 | // OAuthConfig represents the endpoints needed 8 | // in OAuth operations 9 | type OAuthConfig struct { 10 | AuthorizeEndpoint url.URL 11 | TokenEndpoint url.URL 12 | DeviceCodeEndpoint url.URL 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/Azure/go-autorest/autorest/date/utility.go: -------------------------------------------------------------------------------- 1 | package date 2 | 3 | import ( 4 | "strings" 5 | "time" 6 | ) 7 | 8 | // ParseTime to parse Time string to specified format. 9 | func ParseTime(format string, t string) (d time.Time, err error) { 10 | return time.Parse(format, strings.ToUpper(t)) 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/Azure/go-autorest/autorest/version.go: -------------------------------------------------------------------------------- 1 | package autorest 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | const ( 8 | major = "7" 9 | minor = "0" 10 | patch = "0" 11 | tag = "" 12 | semVerFormat = "%s.%s.%s%s" 13 | ) 14 | 15 | // Version returns the semantic version (see http://semver.org). 16 | func Version() string { 17 | return fmt.Sprintf(semVerFormat, major, minor, patch, tag) 18 | } 19 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/NOTICE.txt: -------------------------------------------------------------------------------- 1 | AWS SDK for Go 2 | Copyright 2015 Amazon.com, Inc. or its affiliates. All Rights Reserved. 3 | Copyright 2014-2015 Stripe, Inc. 4 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/client/metadata/client_info.go: -------------------------------------------------------------------------------- 1 | package metadata 2 | 3 | // ClientInfo wraps immutable data from the client.Client structure. 4 | type ClientInfo struct { 5 | ServiceName string 6 | APIVersion string 7 | Endpoint string 8 | SigningName string 9 | SigningRegion string 10 | JSONVersion string 11 | TargetPrefix string 12 | } 13 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/corehandlers/param_validator.go: -------------------------------------------------------------------------------- 1 | package corehandlers 2 | 3 | import "github.com/aws/aws-sdk-go/aws/request" 4 | 5 | // ValidateParametersHandler is a request handler to validate the input parameters. 6 | // Validating parameters only has meaning if done prior to the request being sent. 7 | var ValidateParametersHandler = request.NamedHandler{Name: "core.ValidateParametersHandler", Fn: func(r *request.Request) { 8 | if !r.ParamsFilled() { 9 | return 10 | } 11 | 12 | if v, ok := r.Params.(request.Validator); ok { 13 | if err := v.Validate(); err != nil { 14 | r.Error = err 15 | } 16 | } 17 | }} 18 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/credentials/example.ini: -------------------------------------------------------------------------------- 1 | [default] 2 | aws_access_key_id = accessKey 3 | aws_secret_access_key = secret 4 | aws_session_token = token 5 | 6 | [no_token] 7 | aws_access_key_id = accessKey 8 | aws_secret_access_key = secret 9 | 10 | [with_colon] 11 | aws_access_key_id: accessKey 12 | aws_secret_access_key: secret 13 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/errors.go: -------------------------------------------------------------------------------- 1 | package aws 2 | 3 | import "github.com/aws/aws-sdk-go/aws/awserr" 4 | 5 | var ( 6 | // ErrMissingRegion is an error that is returned if region configuration is 7 | // not found. 8 | // 9 | // @readonly 10 | ErrMissingRegion = awserr.New("MissingRegion", "could not find region configuration", nil) 11 | 12 | // ErrMissingEndpoint is an error that is returned if an endpoint cannot be 13 | // resolved for a service. 14 | // 15 | // @readonly 16 | ErrMissingEndpoint = awserr.New("MissingEndpoint", "'Endpoint' configuration is required for this service", nil) 17 | ) 18 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/request/http_request.go: -------------------------------------------------------------------------------- 1 | // +build go1.5 2 | 3 | package request 4 | 5 | import ( 6 | "io" 7 | "net/http" 8 | "net/url" 9 | ) 10 | 11 | func copyHTTPRequest(r *http.Request, body io.ReadCloser) *http.Request { 12 | req := &http.Request{ 13 | URL: &url.URL{}, 14 | Header: http.Header{}, 15 | Close: r.Close, 16 | Body: body, 17 | Host: r.Host, 18 | Method: r.Method, 19 | Proto: r.Proto, 20 | ContentLength: r.ContentLength, 21 | // Cancel will be deprecated in 1.7 and will be replaced with Context 22 | Cancel: r.Cancel, 23 | } 24 | 25 | *req.URL = *r.URL 26 | for k, v := range r.Header { 27 | for _, vv := range v { 28 | req.Header.Add(k, vv) 29 | } 30 | } 31 | 32 | return req 33 | } 34 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/request/http_request_1_4.go: -------------------------------------------------------------------------------- 1 | // +build !go1.5 2 | 3 | package request 4 | 5 | import ( 6 | "io" 7 | "net/http" 8 | "net/url" 9 | ) 10 | 11 | func copyHTTPRequest(r *http.Request, body io.ReadCloser) *http.Request { 12 | req := &http.Request{ 13 | URL: &url.URL{}, 14 | Header: http.Header{}, 15 | Close: r.Close, 16 | Body: body, 17 | Host: r.Host, 18 | Method: r.Method, 19 | Proto: r.Proto, 20 | ContentLength: r.ContentLength, 21 | } 22 | 23 | *req.URL = *r.URL 24 | for k, v := range r.Header { 25 | for _, vv := range v { 26 | req.Header.Add(k, vv) 27 | } 28 | } 29 | 30 | return req 31 | } 32 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/aws/version.go: -------------------------------------------------------------------------------- 1 | // Package aws provides core functionality for making requests to AWS services. 2 | package aws 3 | 4 | // SDKName is the name of this AWS SDK 5 | const SDKName = "aws-sdk-go" 6 | 7 | // SDKVersion is the version of this SDK 8 | const SDKVersion = "1.4.10" 9 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/private/protocol/unmarshal.go: -------------------------------------------------------------------------------- 1 | package protocol 2 | 3 | import ( 4 | "io" 5 | "io/ioutil" 6 | 7 | "github.com/aws/aws-sdk-go/aws/request" 8 | ) 9 | 10 | // UnmarshalDiscardBodyHandler is a named request handler to empty and close a response's body 11 | var UnmarshalDiscardBodyHandler = request.NamedHandler{Name: "awssdk.shared.UnmarshalDiscardBody", Fn: UnmarshalDiscardBody} 12 | 13 | // UnmarshalDiscardBody is a request handler to empty a response's body and closing it. 14 | func UnmarshalDiscardBody(r *request.Request) { 15 | if r.HTTPResponse == nil || r.HTTPResponse.Body == nil { 16 | return 17 | } 18 | 19 | io.Copy(ioutil.Discard, r.HTTPResponse.Body) 20 | r.HTTPResponse.Body.Close() 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/aws/aws-sdk-go/service/sts/customizations.go: -------------------------------------------------------------------------------- 1 | package sts 2 | 3 | import "github.com/aws/aws-sdk-go/aws/request" 4 | 5 | func init() { 6 | initRequest = func(r *request.Request) { 7 | switch r.Operation.Name { 8 | case opAssumeRoleWithSAML, opAssumeRoleWithWebIdentity: 9 | r.Handlers.Sign.Clear() // these operations are unsigned 10 | } 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /vendor/github.com/bugsnag/bugsnag-go/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | language: go 3 | 4 | go: 5 | - 1.3 6 | - 1.4 7 | - 1.5 8 | - tip 9 | 10 | script: 11 | - make ci 12 | -------------------------------------------------------------------------------- /vendor/github.com/bugsnag/bugsnag-go/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | 1.0.4 2 | ----- 3 | 4 | - Fix appengine integration broken by 1.0.3 5 | 6 | 1.0.3 7 | ----- 8 | 9 | - Allow any Logger with a Printf method. 10 | 11 | 1.0.2 12 | ----- 13 | 14 | - Use bugsnag copies of dependencies to avoid potential link rot 15 | 16 | 1.0.1 17 | ----- 18 | 19 | - gofmt/golint/govet docs improvements. 20 | 21 | 1.0.0 22 | ----- 23 | -------------------------------------------------------------------------------- /vendor/github.com/bugsnag/bugsnag-go/Makefile: -------------------------------------------------------------------------------- 1 | TEST?=./... 2 | 3 | default: alldeps test 4 | 5 | deps: 6 | go get -v -d ./... 7 | 8 | alldeps: 9 | go get -v -d -t ./... 10 | 11 | updatedeps: 12 | go get -v -d -u ./... 13 | 14 | test: alldeps 15 | go test 16 | @go vet 2>/dev/null ; if [ $$? -eq 3 ]; then \ 17 | go get golang.org/x/tools/cmd/vet; \ 18 | fi 19 | @go vet $(TEST) ; if [ $$? -eq 1 ]; then \ 20 | echo "go-vet: Issues running go vet ./..."; \ 21 | exit 1; \ 22 | fi 23 | 24 | ci: alldeps test 25 | 26 | bench: 27 | go test --bench=.* 28 | 29 | 30 | .PHONY: bin checkversion ci default deps generate releasebin test testacc testrace updatedeps 31 | -------------------------------------------------------------------------------- /vendor/github.com/bugsnag/bugsnag-go/errors/README.md: -------------------------------------------------------------------------------- 1 | Adds stacktraces to errors in golang. 2 | 3 | This was made to help build the Bugsnag notifier but can be used standalone if 4 | you like to have stacktraces on errors. 5 | 6 | See [Godoc](https://godoc.org/github.com/bugsnag/bugsnag-go/errors) for the API docs. 7 | -------------------------------------------------------------------------------- /vendor/github.com/bugsnag/bugsnag-go/panicwrap.go: -------------------------------------------------------------------------------- 1 | // +build !appengine 2 | 3 | package bugsnag 4 | 5 | import ( 6 | "github.com/bugsnag/bugsnag-go/errors" 7 | "github.com/bugsnag/panicwrap" 8 | ) 9 | 10 | // NOTE: this function does not return when you call it, instead it 11 | // re-exec()s the current process with panic monitoring. 12 | func defaultPanicHandler() { 13 | defer defaultNotifier.dontPanic() 14 | 15 | err := panicwrap.BasicMonitor(func(output string) { 16 | toNotify, err := errors.ParsePanic(output) 17 | 18 | if err != nil { 19 | defaultNotifier.Config.logf("bugsnag.handleUncaughtPanic: %v", err) 20 | } 21 | Notify(toNotify, SeverityError, Configuration{Synchronous: true}) 22 | }) 23 | 24 | if err != nil { 25 | defaultNotifier.Config.logf("bugsnag.handleUncaughtPanic: %v", err) 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /vendor/github.com/bugsnag/osext/osext_plan9.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 | package osext 6 | 7 | import "syscall" 8 | 9 | func executable() (string, error) { 10 | f, err := Open("/proc/" + itoa(Getpid()) + "/text") 11 | if err != nil { 12 | return "", err 13 | } 14 | defer f.Close() 15 | return syscall.Fd2path(int(f.Fd())) 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/bugsnag/osext/osext_procfs.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build linux netbsd openbsd 6 | 7 | package osext 8 | 9 | import ( 10 | "errors" 11 | "os" 12 | "runtime" 13 | ) 14 | 15 | func executable() (string, error) { 16 | switch runtime.GOOS { 17 | case "linux": 18 | return os.Readlink("/proc/self/exe") 19 | case "netbsd": 20 | return os.Readlink("/proc/curproc/exe") 21 | case "openbsd": 22 | return os.Readlink("/proc/curproc/file") 23 | } 24 | return "", errors.New("ExecPath not implemented for " + runtime.GOOS) 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/bugsnag/panicwrap/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 1.1.0 (2016-01-18) 2 | 3 | * Add ARM64 support 4 | [liusdu](https://github.com/liusdu) 5 | [#1](https://github.com/bugsnag/panicwrap/pull/1) 6 | 7 | ## 1.0.0 (2014-11-10) 8 | 9 | ### Enhancements 10 | 11 | * Add ability to monitor a process 12 | -------------------------------------------------------------------------------- /vendor/github.com/bugsnag/panicwrap/dup2.go: -------------------------------------------------------------------------------- 1 | // +build darwin dragonfly freebsd linux,!arm64 netbsd openbsd 2 | 3 | package panicwrap 4 | 5 | import ( 6 | "syscall" 7 | ) 8 | 9 | func dup2(oldfd, newfd int) error { 10 | return syscall.Dup2(oldfd, newfd) 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/bugsnag/panicwrap/dup3.go: -------------------------------------------------------------------------------- 1 | // +build linux,arm64 2 | 3 | package panicwrap 4 | 5 | import ( 6 | "syscall" 7 | ) 8 | 9 | func dup2(oldfd, newfd int) error { 10 | return syscall.Dup3(oldfd, newfd, 0) 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/bugsnag/panicwrap/monitor_windows.go: -------------------------------------------------------------------------------- 1 | package panicwrap 2 | 3 | import "fmt" 4 | 5 | func monitor(c *WrapConfig) (int, error) { 6 | return -1, fmt.Errorf("Monitor is not supported on windows") 7 | } 8 | -------------------------------------------------------------------------------- /vendor/github.com/cenkalti/backoff/.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/cenkalti/backoff/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | go: 1.3.3 3 | -------------------------------------------------------------------------------- /vendor/github.com/codegangsta/cli/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | sudo: false 3 | 4 | go: 5 | - 1.0.3 6 | - 1.1.2 7 | - 1.2.2 8 | - 1.3.3 9 | - 1.4.2 10 | - 1.5.1 11 | - tip 12 | 13 | matrix: 14 | allow_failures: 15 | - go: tip 16 | 17 | script: 18 | - go vet ./... 19 | - go test -v ./... 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/dgrijalva/jwt-go/.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | bin 3 | 4 | 5 | -------------------------------------------------------------------------------- /vendor/github.com/dgrijalva/jwt-go/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | go: 4 | - 1.3 5 | - 1.4 6 | - 1.5 7 | - 1.6 8 | - tip 9 | -------------------------------------------------------------------------------- /vendor/github.com/dgrijalva/jwt-go/doc.go: -------------------------------------------------------------------------------- 1 | // Package jwt is a Go implementation of JSON Web Tokens: http://self-issued.info/docs/draft-jones-json-web-token.html 2 | // 3 | // See README.md for more info. 4 | package jwt 5 | -------------------------------------------------------------------------------- /vendor/github.com/digitalocean/godo/.gitignore: -------------------------------------------------------------------------------- 1 | vendor/ 2 | -------------------------------------------------------------------------------- /vendor/github.com/digitalocean/godo/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | go: 4 | - 1.7 5 | - tip 6 | -------------------------------------------------------------------------------- /vendor/github.com/digitalocean/godo/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # Change Log 2 | 3 | ## [v1.0.0] - 2017-03-10 4 | 5 | ### Added 6 | - #130 Add Convert to ImageActionsService. - @xmudrii 7 | - #126 Add CertificatesService for managing certificates with the DigitalOcean API. - @viola 8 | - #125 Add LoadBalancersService for managing load balancers with the DigitalOcean API. - @viola 9 | - #122 Add GetVolumeByName to StorageService. - @protochron 10 | - #113 Add context.Context to all calls. - @aybabtme 11 | -------------------------------------------------------------------------------- /vendor/github.com/digitalocean/godo/CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Contributing 2 | 3 | If you submit a pull request, please keep the following guidelines in mind: 4 | 5 | 1. Code should be `go fmt` compliant. 6 | 2. Types, structs and funcs should be documented. 7 | 3. Tests pass. 8 | 9 | ## Getting set up 10 | 11 | Assuming your `$GOPATH` is set up according to your desires, run: 12 | 13 | ```sh 14 | go get github.com/digitalocean/godo 15 | ``` 16 | 17 | ## Running tests 18 | 19 | When working on code in this repository, tests can be run via: 20 | 21 | ```sh 22 | go test . 23 | ``` 24 | -------------------------------------------------------------------------------- /vendor/github.com/digitalocean/godo/doc.go: -------------------------------------------------------------------------------- 1 | // Package godo is the DigtalOcean API v2 client for Go 2 | package godo 3 | -------------------------------------------------------------------------------- /vendor/github.com/digitalocean/godo/errors.go: -------------------------------------------------------------------------------- 1 | package godo 2 | 3 | import "fmt" 4 | 5 | // ArgError is an error that represents an error with an input to godo. It 6 | // identifies the argument and the cause (if possible). 7 | type ArgError struct { 8 | arg string 9 | reason string 10 | } 11 | 12 | var _ error = &ArgError{} 13 | 14 | // NewArgError creates an InputError. 15 | func NewArgError(arg, reason string) *ArgError { 16 | return &ArgError{ 17 | arg: arg, 18 | reason: reason, 19 | } 20 | } 21 | 22 | func (e *ArgError) Error() string { 23 | return fmt.Sprintf("%s is invalid because %s", e.arg, e.reason) 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/docker/go-units/circle.yml: -------------------------------------------------------------------------------- 1 | dependencies: 2 | post: 3 | # install golint 4 | - go get github.com/golang/lint/golint 5 | 6 | test: 7 | pre: 8 | # run analysis before tests 9 | - go vet ./... 10 | - test -z "$(golint ./... | tee /dev/stderr)" 11 | - test -z "$(gofmt -s -l . | tee /dev/stderr)" 12 | -------------------------------------------------------------------------------- /vendor/github.com/exoscale/egoscale/.codeclimate.yml: -------------------------------------------------------------------------------- 1 | version: "2" 2 | 3 | checks: 4 | argument-count: 5 | enabled: false 6 | complex-logic: 7 | enabled: false 8 | file-lines: 9 | enabled: false 10 | method-complexity: 11 | enabled: false 12 | method-count: 13 | enabled: false 14 | method-lines: 15 | enabled: false 16 | nested-control-flow: 17 | enabled: false 18 | return-statements: 19 | enabled: false 20 | similar-code: 21 | enabled: false 22 | identical-code: 23 | enabled: false 24 | 25 | plugins: 26 | gofmt: 27 | enabled: true 28 | golint: 29 | enabled: true 30 | govet: 31 | enabled: true 32 | -------------------------------------------------------------------------------- /vendor/github.com/exoscale/egoscale/.gitignore: -------------------------------------------------------------------------------- 1 | build/ 2 | exo 3 | vendor 4 | .gopath 5 | -------------------------------------------------------------------------------- /vendor/github.com/exoscale/egoscale/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | dist: trusty 4 | 5 | go: 6 | - 1.8 7 | - 1.9 8 | - "1.10" 9 | - tip 10 | 11 | env: 12 | - DEP_VERSION=0.4.1 13 | 14 | cache: apt 15 | 16 | before_install: 17 | - curl -L -s https://github.com/golang/dep/releases/download/v${DEP_VERSION}/dep-linux-amd64 -o $GOPATH/bin/dep 18 | - chmod +x $GOPATH/bin/dep 19 | - npm i -g codeclimate-test-reporter 20 | 21 | script: 22 | - dep ensure 23 | - go test -race -coverprofile=coverage.out -covermode=atomic . 24 | 25 | after_success: 26 | - > 27 | if [ "${TRAVIS_GO_VERSION}" = "1.10" ]; then 28 | codeclimate-test-reporter < coverage.out; 29 | fi 30 | -------------------------------------------------------------------------------- /vendor/github.com/exoscale/egoscale/AUTHORS: -------------------------------------------------------------------------------- 1 | Pierre-Yves Ritschard 2 | Vincent Bernat 3 | Chris Baumbauer 4 | Marc-Aurèle Brothier 5 | Sebastien Goasguen 6 | Yoan Blanc 7 | Stefano Marengo 8 | Pierre-Emmanuel Jacquier 9 | -------------------------------------------------------------------------------- /vendor/github.com/exoscale/egoscale/Gopkg.toml: -------------------------------------------------------------------------------- 1 | [[constraint]] 2 | name = "github.com/jinzhu/copier" 3 | branch = "master" 4 | 5 | [prune] 6 | non-go = true 7 | go-tests = true 8 | unused-packages = true 9 | -------------------------------------------------------------------------------- /vendor/github.com/exoscale/egoscale/Makefile: -------------------------------------------------------------------------------- 1 | PKG=github.com/exoscale/egoscale 2 | 3 | GOPATH=$(CURDIR)/.gopath 4 | DEP=$(GOPATH)/bin/dep 5 | 6 | export GOPATH 7 | 8 | $(GOPATH)/src/$(PKG): 9 | mkdir -p $(GOPATH) 10 | go get -u github.com/golang/dep/cmd/dep 11 | mkdir -p $(shell dirname $(GOPATH)/src/$(PKG)) 12 | ln -sf ../../../.. $(GOPATH)/src/$(PKG) 13 | 14 | .PHONY: deps 15 | deps: $(GOPATH)/src/$(PKG) 16 | (cd $(GOPATH)/src/$(PKG) && \ 17 | $(DEP) ensure) 18 | 19 | .PHONY: deps-update 20 | deps-update: deps 21 | (cd $(GOPATH)/src/$(PKG) && \ 22 | $(DEP) ensure -update) 23 | 24 | .PHONY: clean 25 | clean: 26 | $(RM) -r $(DEST) 27 | go clean 28 | -------------------------------------------------------------------------------- /vendor/github.com/exoscale/egoscale/accounts.go: -------------------------------------------------------------------------------- 1 | package egoscale 2 | 3 | func (*ListAccounts) name() string { 4 | return "listAccounts" 5 | } 6 | 7 | func (*ListAccounts) response() interface{} { 8 | return new(ListAccountsResponse) 9 | } 10 | 11 | func (*EnableAccount) name() string { 12 | return "enableAccount" 13 | } 14 | 15 | func (*EnableAccount) response() interface{} { 16 | return new(EnableAccountResponse) 17 | } 18 | 19 | func (*DisableAccount) name() string { 20 | return "disableAccount" 21 | } 22 | 23 | func (*DisableAccount) asyncResponse() interface{} { 24 | return new(DisableAccountResponse) 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/exoscale/egoscale/accounttype_string.go: -------------------------------------------------------------------------------- 1 | // Code generated by "stringer -type AccountType"; DO NOT EDIT. 2 | 3 | package egoscale 4 | 5 | import "strconv" 6 | 7 | const _AccountType_name = "UserAccountAdminAccountDomainAdminAccount" 8 | 9 | var _AccountType_index = [...]uint8{0, 11, 23, 41} 10 | 11 | func (i AccountType) String() string { 12 | if i < 0 || i >= AccountType(len(_AccountType_index)-1) { 13 | return "AccountType(" + strconv.FormatInt(int64(i), 10) + ")" 14 | } 15 | return _AccountType_name[_AccountType_index[i]:_AccountType_index[i+1]] 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/exoscale/egoscale/apis.go: -------------------------------------------------------------------------------- 1 | package egoscale 2 | 3 | func (*ListAPIs) name() string { 4 | return "listApis" 5 | } 6 | 7 | func (*ListAPIs) response() interface{} { 8 | return new(ListAPIsResponse) 9 | } 10 | -------------------------------------------------------------------------------- /vendor/github.com/exoscale/egoscale/gopher.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/machine-drivers/machine/ddb74f7e6e56c459d4a80ba964d5cee0df3ba35d/vendor/github.com/exoscale/egoscale/gopher.png -------------------------------------------------------------------------------- /vendor/github.com/exoscale/egoscale/jobstatustype_string.go: -------------------------------------------------------------------------------- 1 | // Code generated by "stringer -type JobStatusType"; DO NOT EDIT. 2 | 3 | package egoscale 4 | 5 | import "strconv" 6 | 7 | const _JobStatusType_name = "PendingSuccessFailure" 8 | 9 | var _JobStatusType_index = [...]uint8{0, 7, 14, 21} 10 | 11 | func (i JobStatusType) String() string { 12 | if i < 0 || i >= JobStatusType(len(_JobStatusType_index)-1) { 13 | return "JobStatusType(" + strconv.FormatInt(int64(i), 10) + ")" 14 | } 15 | return _JobStatusType_name[_JobStatusType_index[i]:_JobStatusType_index[i+1]] 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/exoscale/egoscale/network_offerings.go: -------------------------------------------------------------------------------- 1 | package egoscale 2 | 3 | func (*ListNetworkOfferings) name() string { 4 | return "listNetworkOfferings" 5 | } 6 | 7 | func (*ListNetworkOfferings) response() interface{} { 8 | return new(ListNetworkOfferingsResponse) 9 | } 10 | 11 | func (*UpdateNetworkOffering) name() string { 12 | return "updateNetworkOffering" 13 | } 14 | 15 | func (*UpdateNetworkOffering) response() interface{} { 16 | return new(UpdateNetworkOfferingResponse) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/exoscale/egoscale/resource_metadata.go: -------------------------------------------------------------------------------- 1 | package egoscale 2 | 3 | func (*ListResourceDetails) name() string { 4 | return "listResourceDetails" 5 | } 6 | 7 | func (*ListResourceDetails) response() interface{} { 8 | return new(ListResourceDetailsResponse) 9 | } 10 | -------------------------------------------------------------------------------- /vendor/github.com/exoscale/egoscale/service_offerings.go: -------------------------------------------------------------------------------- 1 | package egoscale 2 | 3 | // name returns the CloudStack API command name 4 | func (*ListServiceOfferings) name() string { 5 | return "listServiceOfferings" 6 | } 7 | 8 | func (*ListServiceOfferings) response() interface{} { 9 | return new(ListServiceOfferingsResponse) 10 | } 11 | 12 | // ListServiceOfferingsResponse represents a list of service offerings 13 | type ListServiceOfferingsResponse struct { 14 | Count int `json:"count"` 15 | ServiceOffering []ServiceOffering `json:"serviceoffering"` 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/exoscale/egoscale/tags.go: -------------------------------------------------------------------------------- 1 | package egoscale 2 | 3 | // name returns the CloudStack API command name 4 | func (*CreateTags) name() string { 5 | return "createTags" 6 | } 7 | 8 | func (*CreateTags) asyncResponse() interface{} { 9 | return new(booleanResponse) 10 | } 11 | 12 | // name returns the CloudStack API command name 13 | func (*DeleteTags) name() string { 14 | return "deleteTags" 15 | } 16 | 17 | func (*DeleteTags) asyncResponse() interface{} { 18 | return new(booleanResponse) 19 | } 20 | 21 | // name returns the CloudStack API command name 22 | func (*ListTags) name() string { 23 | return "listTags" 24 | } 25 | 26 | func (*ListTags) response() interface{} { 27 | return new(ListTagsResponse) 28 | } 29 | -------------------------------------------------------------------------------- /vendor/github.com/exoscale/egoscale/users.go: -------------------------------------------------------------------------------- 1 | package egoscale 2 | 3 | func (*RegisterUserKeys) name() string { 4 | return "registerUserKeys" 5 | } 6 | 7 | func (*RegisterUserKeys) response() interface{} { 8 | return new(RegisterUserKeysResponse) 9 | } 10 | 11 | func (*CreateUser) name() string { 12 | return "createUser" 13 | } 14 | 15 | func (*CreateUser) response() interface{} { 16 | return new(CreateUserResponse) 17 | } 18 | 19 | func (*UpdateUser) name() string { 20 | return "updateUser" 21 | } 22 | 23 | func (*UpdateUser) response() interface{} { 24 | return new(UpdateUserResponse) 25 | } 26 | 27 | func (*ListUsers) name() string { 28 | return "listUsers" 29 | } 30 | 31 | func (*ListUsers) response() interface{} { 32 | return new(ListUsersResponse) 33 | } 34 | -------------------------------------------------------------------------------- /vendor/github.com/exoscale/egoscale/version.go: -------------------------------------------------------------------------------- 1 | package egoscale 2 | 3 | // Version of the library 4 | const Version = "0.9.23" 5 | -------------------------------------------------------------------------------- /vendor/github.com/go-ini/ini/.gitignore: -------------------------------------------------------------------------------- 1 | testdata/conf_out.ini 2 | ini.sublime-project 3 | ini.sublime-workspace 4 | testdata/conf_reflect.ini 5 | -------------------------------------------------------------------------------- /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/hectane/go-acl/api/api.go: -------------------------------------------------------------------------------- 1 | //+build windows 2 | 3 | // Windows API functions for manipulating ACLs. 4 | package api 5 | 6 | import ( 7 | "golang.org/x/sys/windows" 8 | ) 9 | 10 | var advapi32 = windows.MustLoadDLL("advapi32.dll") 11 | -------------------------------------------------------------------------------- /vendor/github.com/hectane/go-acl/api/posix.go: -------------------------------------------------------------------------------- 1 | //+build !windows 2 | 3 | package api 4 | -------------------------------------------------------------------------------- /vendor/github.com/hectane/go-acl/appveyor.yml: -------------------------------------------------------------------------------- 1 | version: '{build}' 2 | 3 | clone_folder: C:\gopath\src\github.com\hectane\go-acl 4 | 5 | environment: 6 | GOPATH: C:\gopath 7 | 8 | install: 9 | - go version 10 | - go env 11 | - go get -t -v ./... 12 | 13 | build: off 14 | 15 | test_script: 16 | - go test -v ./... 17 | -------------------------------------------------------------------------------- /vendor/github.com/hectane/go-acl/go.mod: -------------------------------------------------------------------------------- 1 | module github.com/hectane/go-acl 2 | 3 | go 1.12 4 | 5 | require golang.org/x/sys v0.0.0-20190529164535-6a60838ec259 6 | -------------------------------------------------------------------------------- /vendor/github.com/hectane/go-acl/go.sum: -------------------------------------------------------------------------------- 1 | golang.org/x/sys v0.0.0-20190529164535-6a60838ec259 h1:so6Hr/LodwSZ5UQDu/7PmQiDeS112WwtLvU3lpSPZTU= 2 | golang.org/x/sys v0.0.0-20190529164535-6a60838ec259/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 3 | -------------------------------------------------------------------------------- /vendor/github.com/hectane/go-acl/posix.go: -------------------------------------------------------------------------------- 1 | //+build !windows 2 | 3 | package acl 4 | 5 | import "os" 6 | 7 | // Chmod is os.Chmod. 8 | var Chmod = os.Chmod 9 | -------------------------------------------------------------------------------- /vendor/github.com/intel-go/cpuid/.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files 2 | *.slo 3 | *.lo 4 | *.o 5 | *.obj 6 | 7 | # Precompiled Headers 8 | *.gch 9 | *.pch 10 | 11 | # Compiled Dynamic libraries 12 | *.so 13 | *.dylib 14 | *.dll 15 | 16 | # Fortran module files 17 | *.mod 18 | 19 | # Compiled Static libraries 20 | *.lai 21 | *.la 22 | *.a 23 | *.lib 24 | 25 | # Executables 26 | *.exe 27 | *.out 28 | *.app 29 | -------------------------------------------------------------------------------- /vendor/github.com/intel-go/cpuid/cpuidlow_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2017 Intel Corporation. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | #include "textflag.h" 5 | 6 | // func cpuid_low(arg1, arg2 uint32) (eax, ebx, ecx, edx uint32) 7 | TEXT ·cpuid_low(SB),NOSPLIT,$0-24 8 | MOVL arg1+0(FP), AX 9 | MOVL arg2+4(FP), CX 10 | CPUID 11 | MOVL AX, eax+8(FP) 12 | MOVL BX, ebx+12(FP) 13 | MOVL CX, ecx+16(FP) 14 | MOVL DX, edx+20(FP) 15 | RET 16 | // func xgetbv_low(arg1 uint32) (eax, edx uint32) 17 | TEXT ·xgetbv_low(SB),NOSPLIT,$0-16 18 | MOVL arg1+0(FP), CX 19 | BYTE $0x0F 20 | BYTE $0x01 21 | BYTE $0xD0 22 | MOVL AX,eax+8(FP) 23 | MOVL DX,edx+12(FP) 24 | RET 25 | -------------------------------------------------------------------------------- /vendor/github.com/jinzhu/copier/Guardfile: -------------------------------------------------------------------------------- 1 | guard 'gotest' do 2 | watch(%r{\.go$}) 3 | end 4 | -------------------------------------------------------------------------------- /vendor/github.com/jinzhu/copier/wercker.yml: -------------------------------------------------------------------------------- 1 | box: golang 2 | 3 | build: 4 | steps: 5 | - setup-go-workspace 6 | 7 | # Gets the dependencies 8 | - script: 9 | name: go get 10 | code: | 11 | go get 12 | 13 | # Build the project 14 | - script: 15 | name: go build 16 | code: | 17 | go build ./... 18 | 19 | # Test the project 20 | - script: 21 | name: go test 22 | code: | 23 | go test ./... 24 | -------------------------------------------------------------------------------- /vendor/github.com/jmespath/go-jmespath/.gitignore: -------------------------------------------------------------------------------- 1 | jpgo 2 | jmespath-fuzz.zip 3 | cpu.out 4 | go-jmespath.test 5 | -------------------------------------------------------------------------------- /vendor/github.com/jmespath/go-jmespath/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | sudo: false 4 | 5 | go: 6 | - 1.4 7 | 8 | install: go get -v -t ./... 9 | script: make test 10 | -------------------------------------------------------------------------------- /vendor/github.com/jmespath/go-jmespath/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright 2015 James Saryerwinnie 2 | 3 | Licensed under the Apache License, Version 2.0 (the "License"); 4 | you may not use this file except in compliance with the License. 5 | You may obtain a copy of the License at 6 | 7 | http://www.apache.org/licenses/LICENSE-2.0 8 | 9 | Unless required by applicable law or agreed to in writing, software 10 | distributed under the License is distributed on an "AS IS" BASIS, 11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | See the License for the specific language governing permissions and 13 | limitations under the License. 14 | -------------------------------------------------------------------------------- /vendor/github.com/jmespath/go-jmespath/README.md: -------------------------------------------------------------------------------- 1 | # go-jmespath - A JMESPath implementation in Go 2 | 3 | [![Build Status](https://img.shields.io/travis/jmespath/go-jmespath.svg)](https://travis-ci.org/jmespath/go-jmespath) 4 | 5 | 6 | 7 | See http://jmespath.org for more info. 8 | -------------------------------------------------------------------------------- /vendor/github.com/jmespath/go-jmespath/api.go: -------------------------------------------------------------------------------- 1 | package jmespath 2 | 3 | // Search evaluates a JMESPath expression against input data and returns the result. 4 | func Search(expression string, data interface{}) (interface{}, error) { 5 | intr := newInterpreter() 6 | parser := NewParser() 7 | ast, err := parser.Parse(expression) 8 | if err != nil { 9 | return nil, err 10 | } 11 | return intr.Execute(ast, data) 12 | } 13 | -------------------------------------------------------------------------------- /vendor/github.com/jmespath/go-jmespath/toktype_string.go: -------------------------------------------------------------------------------- 1 | // generated by stringer -type=tokType; DO NOT EDIT 2 | 3 | package jmespath 4 | 5 | import "fmt" 6 | 7 | const _tokType_name = "tUnknowntStartDottFiltertFlattentLparentRparentLbrackettRbrackettLbracetRbracetOrtPipetNumbertUnquotedIdentifiertQuotedIdentifiertCommatColontLTtLTEtGTtGTEtEQtNEtJSONLiteraltStringLiteraltCurrenttExpreftAndtNottEOF" 8 | 9 | var _tokType_index = [...]uint8{0, 8, 13, 17, 24, 32, 39, 46, 55, 64, 71, 78, 81, 86, 93, 112, 129, 135, 141, 144, 148, 151, 155, 158, 161, 173, 187, 195, 202, 206, 210, 214} 10 | 11 | func (i tokType) String() string { 12 | if i < 0 || i >= tokType(len(_tokType_index)-1) { 13 | return fmt.Sprintf("tokType(%d)", i) 14 | } 15 | return _tokType_name[_tokType_index[i]:_tokType_index[i+1]] 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/konsorten/go-windows-terminal-sequences/go.mod: -------------------------------------------------------------------------------- 1 | module github.com/konsorten/go-windows-terminal-sequences 2 | -------------------------------------------------------------------------------- /vendor/github.com/mitchellh/mapstructure/error.go: -------------------------------------------------------------------------------- 1 | package mapstructure 2 | 3 | import ( 4 | "fmt" 5 | "strings" 6 | ) 7 | 8 | // Error implements the error interface and can represents multiple 9 | // errors that occur in the course of a single decode. 10 | type Error struct { 11 | Errors []string 12 | } 13 | 14 | func (e *Error) Error() string { 15 | points := make([]string, len(e.Errors)) 16 | for i, err := range e.Errors { 17 | points[i] = fmt.Sprintf("* %s", err) 18 | } 19 | 20 | return fmt.Sprintf( 21 | "%d error(s) decoding:\n\n%s", 22 | len(e.Errors), strings.Join(points, "\n")) 23 | } 24 | 25 | func appendErrors(errors []string, err error) []string { 26 | switch e := err.(type) { 27 | case *Error: 28 | return append(errors, e.Errors...) 29 | default: 30 | return append(errors, e.Error()) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /vendor/github.com/moby/term/.gitignore: -------------------------------------------------------------------------------- 1 | # Docker project generated files to ignore 2 | # if you want to ignore files created by your editor/tools, 3 | # please consider a global .gitignore https://help.github.com/articles/ignoring-files 4 | *.exe 5 | *.exe~ 6 | *.gz 7 | *.orig 8 | test.main 9 | .*.swp 10 | .DS_Store 11 | # a .bashrc may be added to customize the build environment 12 | .bashrc 13 | .editorconfig 14 | .gopath/ 15 | .go-pkg-cache/ 16 | .idea/ 17 | autogen/ 18 | bundles/ 19 | cmd/dockerd/dockerd 20 | contrib/builder/rpm/*/changelog 21 | vendor/pkg/ 22 | go-test-report.json 23 | profile.out 24 | junit-report.xml 25 | -------------------------------------------------------------------------------- /vendor/github.com/moby/term/go.mod: -------------------------------------------------------------------------------- 1 | module github.com/moby/term 2 | 3 | go 1.13 4 | 5 | require ( 6 | github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78 7 | github.com/google/go-cmp v0.3.1 8 | github.com/pkg/errors v0.9.1 // indirect 9 | github.com/sirupsen/logrus v1.4.2 10 | golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527 11 | gotest.tools v2.2.0+incompatible 12 | gotest.tools/v3 v3.0.2 // indirect 13 | ) 14 | -------------------------------------------------------------------------------- /vendor/github.com/moby/term/tc.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package term 4 | 5 | import ( 6 | "syscall" 7 | "unsafe" 8 | 9 | "golang.org/x/sys/unix" 10 | ) 11 | 12 | func tcget(fd uintptr, p *Termios) syscall.Errno { 13 | _, _, err := unix.Syscall(unix.SYS_IOCTL, fd, uintptr(getTermios), uintptr(unsafe.Pointer(p))) 14 | return err 15 | } 16 | 17 | func tcset(fd uintptr, p *Termios) syscall.Errno { 18 | _, _, err := unix.Syscall(unix.SYS_IOCTL, fd, setTermios, uintptr(unsafe.Pointer(p))) 19 | return err 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/moby/term/winsize.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package term 4 | 5 | import ( 6 | "golang.org/x/sys/unix" 7 | ) 8 | 9 | // GetWinsize returns the window size based on the specified file descriptor. 10 | func GetWinsize(fd uintptr) (*Winsize, error) { 11 | uws, err := unix.IoctlGetWinsize(int(fd), unix.TIOCGWINSZ) 12 | ws := &Winsize{Height: uws.Row, Width: uws.Col, x: uws.Xpixel, y: uws.Ypixel} 13 | return ws, err 14 | } 15 | 16 | // SetWinsize tries to set the specified window size for the specified file descriptor. 17 | func SetWinsize(fd uintptr, ws *Winsize) error { 18 | uws := &unix.Winsize{Row: ws.Height, Col: ws.Width, Xpixel: ws.x, Ypixel: ws.y} 19 | return unix.IoctlSetWinsize(int(fd), unix.TIOCSWINSZ, uws) 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | install: 3 | - go get -v -tags 'fixtures acceptance' ./... 4 | go: 5 | - 1.1 6 | - 1.2 7 | - 1.3 8 | - 1.4 9 | - tip 10 | script: script/cibuild 11 | after_success: 12 | - go get code.google.com/p/go.tools/cmd/cover 13 | - go get github.com/axw/gocov/gocov 14 | - go get github.com/mattn/goveralls 15 | - export PATH=$PATH:$HOME/gopath/bin/ 16 | - goveralls 2k7PTU3xa474Hymwgdj6XjqenNfGTNkO8 17 | sudo: false 18 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/CONTRIBUTORS.md: -------------------------------------------------------------------------------- 1 | Contributors 2 | ============ 3 | 4 | | Name | Email | 5 | | ---- | ----- | 6 | | Samuel A. Falvo II | 7 | | Glen Campbell | 8 | | Jesse Noller | 9 | | Jon Perritt | 10 | | Ash Wilson | 11 | | Jamie Hannaford | 12 | | Don Schenck | don.schenck@rackspace.com> 13 | | Joe Topjian | 14 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/auth_results.go: -------------------------------------------------------------------------------- 1 | package gophercloud 2 | 3 | import "time" 4 | 5 | // AuthResults [deprecated] is a leftover type from the v0.x days. It was 6 | // intended to describe common functionality among identity service results, but 7 | // is not actually used anywhere. 8 | type AuthResults interface { 9 | // TokenID returns the token's ID value from the authentication response. 10 | TokenID() (string, error) 11 | 12 | // ExpiresAt retrieves the token's expiration time. 13 | ExpiresAt() (time.Time, error) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/openstack/compute/v2/extensions/floatingip/doc.go: -------------------------------------------------------------------------------- 1 | // Package floatingip provides the ability to manage floating ips through 2 | // nova-network 3 | package floatingip 4 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/openstack/compute/v2/extensions/keypairs/doc.go: -------------------------------------------------------------------------------- 1 | // Package keypairs provides information and interaction with the Keypairs 2 | // extension for the OpenStack Compute service. 3 | package keypairs 4 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/openstack/compute/v2/extensions/keypairs/urls.go: -------------------------------------------------------------------------------- 1 | package keypairs 2 | 3 | import "github.com/rackspace/gophercloud" 4 | 5 | const resourcePath = "os-keypairs" 6 | 7 | func resourceURL(c *gophercloud.ServiceClient) string { 8 | return c.ServiceURL(resourcePath) 9 | } 10 | 11 | func listURL(c *gophercloud.ServiceClient) string { 12 | return resourceURL(c) 13 | } 14 | 15 | func createURL(c *gophercloud.ServiceClient) string { 16 | return resourceURL(c) 17 | } 18 | 19 | func getURL(c *gophercloud.ServiceClient, name string) string { 20 | return c.ServiceURL(resourcePath, name) 21 | } 22 | 23 | func deleteURL(c *gophercloud.ServiceClient, name string) string { 24 | return getURL(c, name) 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/openstack/compute/v2/extensions/startstop/doc.go: -------------------------------------------------------------------------------- 1 | /* 2 | Package startstop provides functionality to start and stop servers that have 3 | been provisioned by the OpenStack Compute service. 4 | */ 5 | package startstop 6 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/openstack/compute/v2/flavors/doc.go: -------------------------------------------------------------------------------- 1 | // Package flavors provides information and interaction with the flavor API 2 | // resource in the OpenStack Compute service. 3 | // 4 | // A flavor is an available hardware configuration for a server. Each flavor 5 | // has a unique combination of disk space, memory capacity and priority for CPU 6 | // time. 7 | package flavors 8 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/openstack/compute/v2/flavors/urls.go: -------------------------------------------------------------------------------- 1 | package flavors 2 | 3 | import ( 4 | "github.com/rackspace/gophercloud" 5 | ) 6 | 7 | func getURL(client *gophercloud.ServiceClient, id string) string { 8 | return client.ServiceURL("flavors", id) 9 | } 10 | 11 | func listURL(client *gophercloud.ServiceClient) string { 12 | return client.ServiceURL("flavors", "detail") 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/openstack/compute/v2/images/doc.go: -------------------------------------------------------------------------------- 1 | // Package images provides information and interaction with the image API 2 | // resource in the OpenStack Compute service. 3 | // 4 | // An image is a collection of files used to create or rebuild a server. 5 | // Operators provide a number of pre-built OS images by default. You may also 6 | // create custom images from cloud servers you have launched. 7 | package images 8 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/openstack/compute/v2/images/urls.go: -------------------------------------------------------------------------------- 1 | package images 2 | 3 | import "github.com/rackspace/gophercloud" 4 | 5 | func listDetailURL(client *gophercloud.ServiceClient) string { 6 | return client.ServiceURL("images", "detail") 7 | } 8 | 9 | func getURL(client *gophercloud.ServiceClient, id string) string { 10 | return client.ServiceURL("images", id) 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/openstack/compute/v2/servers/doc.go: -------------------------------------------------------------------------------- 1 | // Package servers provides information and interaction with the server API 2 | // resource in the OpenStack Compute service. 3 | // 4 | // A server is a virtual machine instance in the compute system. In order for 5 | // one to be provisioned, a valid flavor and image are required. 6 | package servers 7 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/openstack/compute/v2/servers/util.go: -------------------------------------------------------------------------------- 1 | package servers 2 | 3 | import "github.com/rackspace/gophercloud" 4 | 5 | // WaitForStatus will continually poll a server until it successfully transitions to a specified 6 | // status. It will do this for at most the number of seconds specified. 7 | func WaitForStatus(c *gophercloud.ServiceClient, id, status string, secs int) error { 8 | return gophercloud.WaitFor(secs, func() (bool, error) { 9 | current, err := Get(c, id).Extract() 10 | if err != nil { 11 | return false, err 12 | } 13 | 14 | if current.Status == status { 15 | return true, nil 16 | } 17 | 18 | return false, nil 19 | }) 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/openstack/identity/v2/tenants/doc.go: -------------------------------------------------------------------------------- 1 | // Package tenants provides information and interaction with the 2 | // tenants API resource for the OpenStack Identity service. 3 | // 4 | // See http://developer.openstack.org/api-ref-identity-v2.html#identity-auth-v2 5 | // and http://developer.openstack.org/api-ref-identity-v2.html#admin-tenants 6 | // for more information. 7 | package tenants 8 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/openstack/identity/v2/tenants/urls.go: -------------------------------------------------------------------------------- 1 | package tenants 2 | 3 | import "github.com/rackspace/gophercloud" 4 | 5 | func listURL(client *gophercloud.ServiceClient) string { 6 | return client.ServiceURL("tenants") 7 | } 8 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/openstack/identity/v2/tokens/doc.go: -------------------------------------------------------------------------------- 1 | // Package tokens provides information and interaction with the token API 2 | // resource for the OpenStack Identity service. 3 | // For more information, see: 4 | // http://developer.openstack.org/api-ref-identity-v2.html#identity-auth-v2 5 | package tokens 6 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/openstack/identity/v2/tokens/urls.go: -------------------------------------------------------------------------------- 1 | package tokens 2 | 3 | import "github.com/rackspace/gophercloud" 4 | 5 | // CreateURL generates the URL used to create new Tokens. 6 | func CreateURL(client *gophercloud.ServiceClient) string { 7 | return client.ServiceURL("tokens") 8 | } 9 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/openstack/identity/v3/tokens/doc.go: -------------------------------------------------------------------------------- 1 | // Package tokens provides information and interaction with the token API 2 | // resource for the OpenStack Identity service. 3 | // 4 | // For more information, see: 5 | // http://developer.openstack.org/api-ref-identity-v3.html#tokens-v3 6 | package tokens 7 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/openstack/identity/v3/tokens/urls.go: -------------------------------------------------------------------------------- 1 | package tokens 2 | 3 | import "github.com/rackspace/gophercloud" 4 | 5 | func tokenURL(c *gophercloud.ServiceClient) string { 6 | return c.ServiceURL("auth", "tokens") 7 | } 8 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/openstack/networking/v2/extensions/layer3/floatingips/urls.go: -------------------------------------------------------------------------------- 1 | package floatingips 2 | 3 | import "github.com/rackspace/gophercloud" 4 | 5 | const resourcePath = "floatingips" 6 | 7 | func rootURL(c *gophercloud.ServiceClient) string { 8 | return c.ServiceURL(resourcePath) 9 | } 10 | 11 | func resourceURL(c *gophercloud.ServiceClient, id string) string { 12 | return c.ServiceURL(resourcePath, id) 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/openstack/networking/v2/networks/doc.go: -------------------------------------------------------------------------------- 1 | // Package networks contains functionality for working with Neutron network 2 | // resources. A network is an isolated virtual layer-2 broadcast domain that is 3 | // typically reserved for the tenant who created it (unless you configure the 4 | // network to be shared). Tenants can create multiple networks until the 5 | // thresholds per-tenant quota is reached. 6 | // 7 | // In the v2.0 Networking API, the network is the main entity. Ports and subnets 8 | // are always associated with a network. 9 | package networks 10 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/openstack/networking/v2/networks/errors.go: -------------------------------------------------------------------------------- 1 | package networks 2 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/openstack/networking/v2/ports/doc.go: -------------------------------------------------------------------------------- 1 | // Package ports contains functionality for working with Neutron port resources. 2 | // A port represents a virtual switch port on a logical network switch. Virtual 3 | // instances attach their interfaces into ports. The logical port also defines 4 | // the MAC address and the IP address(es) to be assigned to the interfaces 5 | // plugged into them. When IP addresses are associated to a port, this also 6 | // implies the port is associated with a subnet, as the IP address was taken 7 | // from the allocation pool for a specific subnet. 8 | package ports 9 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/openstack/networking/v2/ports/errors.go: -------------------------------------------------------------------------------- 1 | package ports 2 | 3 | import "fmt" 4 | 5 | func err(str string) error { 6 | return fmt.Errorf("%s", str) 7 | } 8 | 9 | var ( 10 | errNetworkIDRequired = err("A Network ID is required") 11 | ) 12 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/pagination/null.go: -------------------------------------------------------------------------------- 1 | package pagination 2 | 3 | // nullPage is an always-empty page that trivially satisfies all Page interfacts. 4 | // It's useful to be returned along with an error. 5 | type nullPage struct{} 6 | 7 | // NextPageURL always returns "" to indicate that there are no more pages to return. 8 | func (p nullPage) NextPageURL() (string, error) { 9 | return "", nil 10 | } 11 | 12 | // IsEmpty always returns true to prevent iteration over nullPages. 13 | func (p nullPage) IsEmpty() (bool, error) { 14 | return true, nil 15 | } 16 | 17 | // LastMark always returns "" because the nullPage contains no items to have a mark. 18 | func (p nullPage) LastMark() (string, error) { 19 | return "", nil 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/pagination/pkg.go: -------------------------------------------------------------------------------- 1 | /* 2 | Package pagination contains utilities and convenience structs that implement common pagination idioms within OpenStack APIs. 3 | */ 4 | package pagination 5 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/pagination/single.go: -------------------------------------------------------------------------------- 1 | package pagination 2 | 3 | // SinglePageBase may be embedded in a Page that contains all of the results from an operation at once. 4 | type SinglePageBase PageResult 5 | 6 | // NextPageURL always returns "" to indicate that there are no more pages to return. 7 | func (current SinglePageBase) NextPageURL() (string, error) { 8 | return "", nil 9 | } 10 | 11 | // GetBody returns the single page's body. This method is needed to satisfy the 12 | // Page interface. 13 | func (current SinglePageBase) GetBody() interface{} { 14 | return current.Body 15 | } 16 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/rackspace/identity/v2/tokens/doc.go: -------------------------------------------------------------------------------- 1 | // Package tokens provides information and interaction with the token 2 | // API resource for the Rackspace Identity service. 3 | package tokens 4 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/testhelper/client/fake.go: -------------------------------------------------------------------------------- 1 | package client 2 | 3 | import ( 4 | "github.com/rackspace/gophercloud" 5 | "github.com/rackspace/gophercloud/testhelper" 6 | ) 7 | 8 | // Fake token to use. 9 | const TokenID = "cbc36478b0bd8e67e89469c7749d4127" 10 | 11 | // ServiceClient returns a generic service client for use in tests. 12 | func ServiceClient() *gophercloud.ServiceClient { 13 | return &gophercloud.ServiceClient{ 14 | ProviderClient: &gophercloud.ProviderClient{TokenID: TokenID}, 15 | Endpoint: testhelper.Endpoint(), 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/rackspace/gophercloud/testhelper/doc.go: -------------------------------------------------------------------------------- 1 | /* 2 | Package testhelper container methods that are useful for writing unit tests. 3 | */ 4 | package testhelper 5 | -------------------------------------------------------------------------------- /vendor/github.com/samalba/dockerclient/.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/sirupsen/logrus/.gitignore: -------------------------------------------------------------------------------- 1 | logrus 2 | vendor 3 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/appveyor.yml: -------------------------------------------------------------------------------- 1 | version: "{build}" 2 | platform: x64 3 | clone_folder: c:\gopath\src\github.com\sirupsen\logrus 4 | environment: 5 | GOPATH: c:\gopath 6 | branches: 7 | only: 8 | - master 9 | install: 10 | - set PATH=%GOPATH%\bin;c:\go\bin;%PATH% 11 | - go version 12 | build_script: 13 | - go get -t 14 | - go test 15 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/doc.go: -------------------------------------------------------------------------------- 1 | /* 2 | Package logrus is a structured logger for Go, completely API compatible with the standard library logger. 3 | 4 | 5 | The simplest way to use Logrus is simply the package-level exported logger: 6 | 7 | package main 8 | 9 | import ( 10 | log "github.com/sirupsen/logrus" 11 | ) 12 | 13 | func main() { 14 | log.WithFields(log.Fields{ 15 | "animal": "walrus", 16 | "number": 1, 17 | "size": 10, 18 | }).Info("A walrus appears") 19 | } 20 | 21 | Output: 22 | time="2015-09-07T08:48:33Z" level=info msg="A walrus appears" animal=walrus number=1 size=10 23 | 24 | For a full guide visit https://github.com/sirupsen/logrus 25 | */ 26 | package logrus 27 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/go.mod: -------------------------------------------------------------------------------- 1 | module github.com/sirupsen/logrus 2 | 3 | require ( 4 | github.com/davecgh/go-spew v1.1.1 // indirect 5 | github.com/konsorten/go-windows-terminal-sequences v1.0.1 6 | github.com/pmezard/go-difflib v1.0.0 // indirect 7 | github.com/stretchr/objx v0.1.1 // indirect 8 | github.com/stretchr/testify v1.2.2 9 | golang.org/x/sys v0.0.0-20190422165155-953cdadca894 10 | ) 11 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/terminal_check_appengine.go: -------------------------------------------------------------------------------- 1 | // +build appengine 2 | 3 | package logrus 4 | 5 | import ( 6 | "io" 7 | ) 8 | 9 | func checkIfTerminal(w io.Writer) bool { 10 | return true 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/terminal_check_bsd.go: -------------------------------------------------------------------------------- 1 | // +build darwin dragonfly freebsd netbsd openbsd 2 | 3 | package logrus 4 | 5 | import "golang.org/x/sys/unix" 6 | 7 | const ioctlReadTermios = unix.TIOCGETA 8 | 9 | func isTerminal(fd int) bool { 10 | _, err := unix.IoctlGetTermios(fd, ioctlReadTermios) 11 | return err == nil 12 | } 13 | 14 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/terminal_check_no_terminal.go: -------------------------------------------------------------------------------- 1 | // +build js nacl plan9 2 | 3 | package logrus 4 | 5 | import ( 6 | "io" 7 | ) 8 | 9 | func checkIfTerminal(w io.Writer) bool { 10 | return false 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/terminal_check_notappengine.go: -------------------------------------------------------------------------------- 1 | // +build !appengine,!js,!windows,!nacl,!plan9 2 | 3 | package logrus 4 | 5 | import ( 6 | "io" 7 | "os" 8 | ) 9 | 10 | func checkIfTerminal(w io.Writer) bool { 11 | switch v := w.(type) { 12 | case *os.File: 13 | return isTerminal(int(v.Fd())) 14 | default: 15 | return false 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/terminal_check_solaris.go: -------------------------------------------------------------------------------- 1 | package logrus 2 | 3 | import ( 4 | "golang.org/x/sys/unix" 5 | ) 6 | 7 | // IsTerminal returns true if the given file descriptor is a terminal. 8 | func isTerminal(fd int) bool { 9 | _, err := unix.IoctlGetTermio(fd, unix.TCGETA) 10 | return err == nil 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/terminal_check_unix.go: -------------------------------------------------------------------------------- 1 | // +build linux aix 2 | 3 | package logrus 4 | 5 | import "golang.org/x/sys/unix" 6 | 7 | const ioctlReadTermios = unix.TCGETS 8 | 9 | func isTerminal(fd int) bool { 10 | _, err := unix.IoctlGetTermios(fd, ioctlReadTermios) 11 | return err == nil 12 | } 13 | 14 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/terminal_check_windows.go: -------------------------------------------------------------------------------- 1 | // +build !appengine,!js,windows 2 | 3 | package logrus 4 | 5 | import ( 6 | "io" 7 | "os" 8 | "syscall" 9 | 10 | sequences "github.com/konsorten/go-windows-terminal-sequences" 11 | ) 12 | 13 | func initTerminal(w io.Writer) { 14 | switch v := w.(type) { 15 | case *os.File: 16 | sequences.EnableVirtualTerminalProcessing(syscall.Handle(v.Fd()), true) 17 | } 18 | } 19 | 20 | func checkIfTerminal(w io.Writer) bool { 21 | var ret bool 22 | switch v := w.(type) { 23 | case *os.File: 24 | var mode uint32 25 | err := syscall.GetConsoleMode(syscall.Handle(v.Fd()), &mode) 26 | ret = (err == nil) 27 | default: 28 | ret = false 29 | } 30 | if ret { 31 | initTerminal(w) 32 | } 33 | return ret 34 | } 35 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/objx/.codeclimate.yml: -------------------------------------------------------------------------------- 1 | engines: 2 | gofmt: 3 | enabled: true 4 | golint: 5 | enabled: true 6 | govet: 7 | enabled: true 8 | 9 | exclude_patterns: 10 | - ".github/" 11 | - "vendor/" 12 | - "codegen/" 13 | - "doc.go" 14 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/objx/.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 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/objx/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | go: 3 | - 1.8 4 | - 1.9 5 | - tip 6 | 7 | env: 8 | global: 9 | - CC_TEST_REPORTER_ID=68feaa3410049ce73e145287acbcdacc525087a30627f96f04e579e75bd71c00 10 | 11 | before_script: 12 | - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter 13 | - chmod +x ./cc-test-reporter 14 | - ./cc-test-reporter before-build 15 | 16 | install: 17 | - go get github.com/go-task/task/cmd/task 18 | 19 | script: 20 | - task dl-deps 21 | - task lint 22 | - task test-coverage 23 | 24 | after_script: 25 | - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT 26 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/objx/Gopkg.toml: -------------------------------------------------------------------------------- 1 | [prune] 2 | unused-packages = true 3 | non-go = true 4 | go-tests = true 5 | 6 | [[constraint]] 7 | name = "github.com/stretchr/testify" 8 | version = "~1.2.0" 9 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/objx/Taskfile.yml: -------------------------------------------------------------------------------- 1 | default: 2 | deps: [test] 3 | 4 | dl-deps: 5 | desc: Downloads cli dependencies 6 | cmds: 7 | - go get -u github.com/golang/lint/golint 8 | - go get -u github.com/golang/dep/cmd/dep 9 | 10 | update-deps: 11 | desc: Updates dependencies 12 | cmds: 13 | - dep ensure 14 | - dep ensure -update 15 | 16 | lint: 17 | desc: Runs golint 18 | cmds: 19 | - go fmt $(go list ./... | grep -v /vendor/) 20 | - go vet $(go list ./... | grep -v /vendor/) 21 | - golint $(ls *.go | grep -v "doc.go") 22 | silent: true 23 | 24 | test: 25 | desc: Runs go tests 26 | cmds: 27 | - go test -race . 28 | 29 | test-coverage: 30 | desc: Runs go tests and calucates test coverage 31 | cmds: 32 | - go test -coverprofile=c.out . 33 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/objx/constants.go: -------------------------------------------------------------------------------- 1 | package objx 2 | 3 | const ( 4 | // PathSeparator is the character used to separate the elements 5 | // of the keypath. 6 | // 7 | // For example, `location.address.city` 8 | PathSeparator string = "." 9 | 10 | // SignatureSeparator is the character that is used to 11 | // separate the Base64 string from the security signature. 12 | SignatureSeparator = "_" 13 | ) 14 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/objx/security.go: -------------------------------------------------------------------------------- 1 | package objx 2 | 3 | import ( 4 | "crypto/sha1" 5 | "encoding/hex" 6 | ) 7 | 8 | // HashWithKey hashes the specified string using the security key 9 | func HashWithKey(data, key string) string { 10 | d := sha1.Sum([]byte(data + ":" + key)) 11 | return hex.EncodeToString(d[:]) 12 | } 13 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/objx/tests.go: -------------------------------------------------------------------------------- 1 | package objx 2 | 3 | // Has gets whether there is something at the specified selector 4 | // or not. 5 | // 6 | // If m is nil, Has will always return false. 7 | func (m Map) Has(selector string) bool { 8 | if m == nil { 9 | return false 10 | } 11 | return !m.Get(selector).IsNil() 12 | } 13 | 14 | // IsNil gets whether the data is nil or not. 15 | func (v *Value) IsNil() bool { 16 | return v == nil || v.data == nil 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/testify/assert/assertion_format.go.tmpl: -------------------------------------------------------------------------------- 1 | {{.CommentFormat}} 2 | func {{.DocInfo.Name}}f(t TestingT, {{.ParamsFormat}}) bool { 3 | if h, ok := t.(tHelper); ok { h.Helper() } 4 | return {{.DocInfo.Name}}(t, {{.ForwardedParamsFormat}}) 5 | } 6 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/testify/assert/assertion_forward.go.tmpl: -------------------------------------------------------------------------------- 1 | {{.CommentWithoutT "a"}} 2 | func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) bool { 3 | if h, ok := a.t.(tHelper); ok { h.Helper() } 4 | return {{.DocInfo.Name}}(a.t, {{.ForwardedParams}}) 5 | } 6 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/testify/assert/errors.go: -------------------------------------------------------------------------------- 1 | package assert 2 | 3 | import ( 4 | "errors" 5 | ) 6 | 7 | // AnError is an error instance useful for testing. If the code does not care 8 | // about error specifics, and only needs to return the error for example, this 9 | // error should be used to make the test code more readable. 10 | var AnError = errors.New("assert.AnError general error for testing") 11 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/testify/assert/forward_assertions.go: -------------------------------------------------------------------------------- 1 | package assert 2 | 3 | // Assertions provides assertion methods around the 4 | // TestingT interface. 5 | type Assertions struct { 6 | t TestingT 7 | } 8 | 9 | // New makes a new Assertions object for the specified TestingT. 10 | func New(t TestingT) *Assertions { 11 | return &Assertions{ 12 | t: t, 13 | } 14 | } 15 | 16 | //go:generate go run ../_codegen/main.go -output-package=assert -template=assertion_forward.go.tmpl -include-format-funcs 17 | -------------------------------------------------------------------------------- /vendor/github.com/tent/http-link-go/.gitignore: -------------------------------------------------------------------------------- 1 | *.test 2 | -------------------------------------------------------------------------------- /vendor/github.com/tent/http-link-go/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | go: 3 | - 1.1 4 | - tip 5 | before_install: 6 | - go get launchpad.net/gocheck 7 | -------------------------------------------------------------------------------- /vendor/github.com/tent/http-link-go/README.md: -------------------------------------------------------------------------------- 1 | # http-link-go [![Build Status](https://travis-ci.org/tent/http-link-go.png?branch=master)](https://travis-ci.org/tent/http-link-go) 2 | 3 | http-link-go implements parsing and serialization of Link header values as 4 | defined in [RFC 5988](https://tools.ietf.org/html/rfc5988). 5 | 6 | [**Documentation**](http://godoc.org/github.com/tent/http-link-go) 7 | 8 | ## Installation 9 | 10 | ```text 11 | go get github.com/tent/http-link-go 12 | ``` 13 | -------------------------------------------------------------------------------- /vendor/github.com/vmware/govcloudair/.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 | .cover 10 | 11 | # Architecture specific extensions/prefixes 12 | *.[568vq] 13 | [568vq].out 14 | 15 | *.cgo1.go 16 | *.cgo2.c 17 | _cgo_defun.c 18 | _cgo_gotypes.go 19 | _cgo_export.* 20 | 21 | _testmain.go 22 | 23 | *.exe 24 | *.test 25 | *.prof -------------------------------------------------------------------------------- /vendor/github.com/vmware/govcloudair/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | install: 4 | - go get -t ./... 5 | - go get golang.org/x/tools/cmd/cover 6 | - go get github.com/mattn/goveralls 7 | 8 | script: 9 | - PATH="$HOME/gopath/bin:$PATH" 10 | - script/coverage --coveralls -------------------------------------------------------------------------------- /vendor/github.com/vmware/govcloudair/Readme.md: -------------------------------------------------------------------------------- 1 | ## govcloudair [![Build Status](https://travis-ci.org/vmware/govcloudair.svg?branch=master)](https://travis-ci.org/frapposelli/govcloudair) [![Coverage Status](https://img.shields.io/coveralls/vmware/govcloudair.svg)](https://coveralls.io/r/vmware/govcloudair) [![GoDoc](https://godoc.org/github.com/vmware/govcloudair?status.svg)](http://godoc.org/github.com/vmware/govcloudair) 2 | 3 | This package provides the `govcloudair` package which offers an interface to the vCloud Air 5.6 API. 4 | 5 | It serves as a foundation for a project currently in development, there are plans to make it a general purpose API in the future. 6 | 7 | The API is currently under heavy development, its coverage is extremely limited at the moment. -------------------------------------------------------------------------------- /vendor/github.com/vmware/govcloudair/orgvdcnetwork.go: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 VMware, Inc. All rights reserved. Licensed under the Apache v2 License. 3 | */ 4 | 5 | package govcloudair 6 | 7 | import ( 8 | types "github.com/vmware/govcloudair/types/v56" 9 | ) 10 | 11 | type OrgVDCNetwork struct { 12 | OrgVDCNetwork *types.OrgVDCNetwork 13 | c *Client 14 | } 15 | 16 | func NewOrgVDCNetwork(c *Client) *OrgVDCNetwork { 17 | return &OrgVDCNetwork{ 18 | OrgVDCNetwork: new(types.OrgVDCNetwork), 19 | c: c, 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/vmware/govcloudair/vapptemplate.go: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2014 VMware, Inc. All rights reserved. Licensed under the Apache v2 License. 3 | */ 4 | 5 | package govcloudair 6 | 7 | import ( 8 | types "github.com/vmware/govcloudair/types/v56" 9 | ) 10 | 11 | type VAppTemplate struct { 12 | VAppTemplate *types.VAppTemplate 13 | c *Client 14 | } 15 | 16 | func NewVAppTemplate(c *Client) *VAppTemplate { 17 | return &VAppTemplate{ 18 | VAppTemplate: new(types.VAppTemplate), 19 | c: c, 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/vmware/govmomi/.drone.sec: -------------------------------------------------------------------------------- 1 | eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkExMjhHQ00ifQ.kK6pryC8R-O1R0Gj9ydLvQuIZlcYLGze23WdW7xbpiEEKdz6nweJrMm7ysy8lgu1tM47JVo19p2_b26bNKSQshCUOETvd7Hb2UMZOjnyUnqdyAAyoi6UkIquXfUUbHTNS0iMxwSxxW9KMp2GXNq8-o6T8xQZTDirBJFKKd8ZNUasTaoa5j8U9IfdR1aCavTBuOhvk8IVs-jSbY5TVJMJiE0IOPXois7aRJ6uAiANQBk9VKLegEcZD_qAewecXHDsHi-u0jbmg3o3PPaJaK_Qv5dsPlR2M-E2kE3AGUn0-zn5zYRngoAZ8WZr2O4GvLdltJKq9i2z7jOrdOzzRcDRow.96qvwl_E1Hj15u7Q.hWs-jQ8FsqQFD7pE9N-UEP1BWQ9rsJIcCaPvQRIp8Fukm_vvlw9YEaEq0ERLrsUWsJWpd1ca8_h8x7xD6f_d5YppwRqRHIeGIsdBOTMhNs0lG8ikkQXLat-UroCpy8EC17nuUtDE2E2Kdxrk4Cdd6Bk-dKk0Ta4w3Ud0YBKa.P8zrO7xizgv0i98eVWWzEg -------------------------------------------------------------------------------- /vendor/github.com/vmware/govmomi/.drone.yml: -------------------------------------------------------------------------------- 1 | clone: 2 | tags: true 3 | path: github.com/vmware/govmomi 4 | build: 5 | image: golang:1.6 6 | pull: true 7 | environment: 8 | - GOVC_TEST_URL=$$GOVC_TEST_URL 9 | - GOVC_INSECURE=1 10 | - VCA=1 11 | commands: 12 | - make all install 13 | - git clone https://github.com/sstephenson/bats.git /tmp/bats 14 | - /tmp/bats/install.sh /usr/local 15 | - apt-get -qq update && apt-get install -yqq uuid-runtime bsdmainutils jq 16 | - govc/test/images/update.sh 17 | - bats govc/test 18 | -------------------------------------------------------------------------------- /vendor/github.com/vmware/govmomi/.gitignore: -------------------------------------------------------------------------------- 1 | secrets.yml 2 | -------------------------------------------------------------------------------- /vendor/github.com/vmware/govmomi/.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | 3 | language: go 4 | 5 | go: 6 | - 1.6 7 | 8 | before_install: 9 | - make vendor 10 | 11 | script: 12 | - make check test 13 | -------------------------------------------------------------------------------- /vendor/github.com/vmware/govmomi/Makefile: -------------------------------------------------------------------------------- 1 | .PHONY: test 2 | 3 | all: check test 4 | 5 | check: goimports govet 6 | 7 | vendor: 8 | go get golang.org/x/tools/cmd/goimports 9 | go get github.com/davecgh/go-spew/spew 10 | go get golang.org/x/net/context 11 | 12 | goimports: vendor 13 | @echo checking go imports... 14 | @! goimports -d . 2>&1 | egrep -v '^$$' 15 | 16 | govet: 17 | @echo checking go vet... 18 | @go tool vet -structtags=false -methods=false . 19 | 20 | test: vendor 21 | go test -v $(TEST_OPTS) ./... 22 | 23 | install: vendor 24 | go install github.com/vmware/govmomi/govc 25 | -------------------------------------------------------------------------------- /vendor/github.com/vmware/govmomi/object/vmware_distributed_virtual_switch.go: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2015 VMware, Inc. All Rights Reserved. 3 | 4 | Licensed under the Apache License, Version 2.0 (the "License"); 5 | you may not use this file except in compliance with the License. 6 | You may obtain a copy of the License at 7 | 8 | http://www.apache.org/licenses/LICENSE-2.0 9 | 10 | Unless required by applicable law or agreed to in writing, software 11 | distributed under the License is distributed on an "AS IS" BASIS, 12 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | See the License for the specific language governing permissions and 14 | limitations under the License. 15 | */ 16 | 17 | package object 18 | 19 | type VmwareDistributedVirtualSwitch struct { 20 | DistributedVirtualSwitch 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/vmware/govmomi/vim25/mo/registry.go: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2014 VMware, Inc. All Rights Reserved. 3 | 4 | Licensed under the Apache License, Version 2.0 (the "License"); 5 | you may not use this file except in compliance with the License. 6 | You may obtain a copy of the License at 7 | 8 | http://www.apache.org/licenses/LICENSE-2.0 9 | 10 | Unless required by applicable law or agreed to in writing, software 11 | distributed under the License is distributed on an "AS IS" BASIS, 12 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | See the License for the specific language governing permissions and 14 | limitations under the License. 15 | */ 16 | 17 | package mo 18 | 19 | import "reflect" 20 | 21 | var t = map[string]reflect.Type{} 22 | -------------------------------------------------------------------------------- /vendor/github.com/vmware/govmomi/vim25/types/base.go: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2014 VMware, Inc. All Rights Reserved. 3 | 4 | Licensed under the Apache License, Version 2.0 (the "License"); 5 | you may not use this file except in compliance with the License. 6 | You may obtain a copy of the License at 7 | 8 | http://www.apache.org/licenses/LICENSE-2.0 9 | 10 | Unless required by applicable law or agreed to in writing, software 11 | distributed under the License is distributed on an "AS IS" BASIS, 12 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | See the License for the specific language governing permissions and 14 | limitations under the License. 15 | */ 16 | 17 | package types 18 | 19 | type AnyType interface{} 20 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/AUTHORS: -------------------------------------------------------------------------------- 1 | # This source code refers to The Go Authors for copyright purposes. 2 | # The master list of authors is in the main Go distribution, 3 | # visible at https://tip.golang.org/AUTHORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # This source code was written by the Go contributors. 2 | # The master list of contributors is in the main Go distribution, 3 | # visible at https://tip.golang.org/CONTRIBUTORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/const_amd64.h: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // This code was translated into a form compatible with 6a from the public 6 | // domain sources in SUPERCOP: https://bench.cr.yp.to/supercop.html 7 | 8 | #define REDMASK51 0x0007FFFFFFFFFFFF 9 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/const_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // This code was translated into a form compatible with 6a from the public 6 | // domain sources in SUPERCOP: https://bench.cr.yp.to/supercop.html 7 | 8 | // +build amd64,!gccgo,!appengine 9 | 10 | // These constants cannot be encoded in non-MOVQ immediates. 11 | // We access them directly from memory instead. 12 | 13 | DATA ·_121666_213(SB)/8, $996687872 14 | GLOBL ·_121666_213(SB), 8, $8 15 | 16 | DATA ·_2P0(SB)/8, $0xFFFFFFFFFFFDA 17 | GLOBL ·_2P0(SB), 8, $8 18 | 19 | DATA ·_2P1234(SB)/8, $0xFFFFFFFFFFFFE 20 | GLOBL ·_2P1234(SB), 8, $8 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/internal/chacha20/chacha_noasm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !arm64,!s390x arm64,!go1.11 gccgo appengine 6 | 7 | package chacha20 8 | 9 | const ( 10 | bufSize = 64 11 | haveAsm = false 12 | ) 13 | 14 | func (*Cipher) xorKeyStreamAsm(dst, src []byte) { 15 | panic("not implemented") 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/poly1305/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 | // +build !amd64 gccgo appengine 6 | 7 | package poly1305 8 | 9 | type mac struct{ macGeneric } 10 | 11 | func newMAC(key *[32]byte) mac { return mac{newMACGeneric(key)} } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/poly1305/sum_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build arm,!gccgo,!appengine,!nacl 6 | 7 | package poly1305 8 | 9 | // This function is implemented in sum_arm.s 10 | //go:noescape 11 | func poly1305_auth_armv6(out *[16]byte, m *byte, mlen uint32, key *[32]byte) 12 | 13 | // Sum generates an authenticator for m using a one-time key and puts the 14 | // 16-byte result into out. Authenticating two different messages with the same 15 | // key allows an attacker to forge messages at will. 16 | func Sum(out *[16]byte, m []byte, key *[32]byte) { 17 | var mPtr *byte 18 | if len(m) > 0 { 19 | mPtr = &m[0] 20 | } 21 | poly1305_auth_armv6(out, mPtr, uint32(len(m)), key) 22 | } 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/poly1305/sum_noasm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build s390x,!go1.11 !arm,!amd64,!s390x gccgo appengine nacl 6 | 7 | package poly1305 8 | 9 | // Sum generates an authenticator for msg using a one-time key and puts the 10 | // 16-byte result into out. Authenticating two different messages with the same 11 | // key allows an attacker to forge messages at will. 12 | func Sum(out *[TagSize]byte, msg []byte, key *[32]byte) { 13 | h := newMAC(key) 14 | h.Write(msg) 15 | h.Sum(out) 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/ssh/terminal/util_aix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build aix 6 | 7 | package terminal 8 | 9 | import "golang.org/x/sys/unix" 10 | 11 | const ioctlReadTermios = unix.TCGETS 12 | const ioctlWriteTermios = unix.TCSETS 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/ssh/terminal/util_bsd.go: -------------------------------------------------------------------------------- 1 | // Copyright 2013 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build darwin dragonfly freebsd netbsd openbsd 6 | 7 | package terminal 8 | 9 | import "golang.org/x/sys/unix" 10 | 11 | const ioctlReadTermios = unix.TIOCGETA 12 | const ioctlWriteTermios = unix.TIOCSETA 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/ssh/terminal/util_linux.go: -------------------------------------------------------------------------------- 1 | // Copyright 2013 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package terminal 6 | 7 | import "golang.org/x/sys/unix" 8 | 9 | const ioctlReadTermios = unix.TCGETS 10 | const ioctlWriteTermios = unix.TCSETS 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 | // +build go1.9 6 | 7 | package context 8 | 9 | import "context" // standard library's context, as of Go 1.7 10 | 11 | // A Context carries a deadline, a cancelation signal, and other values across 12 | // API boundaries. 13 | // 14 | // Context's methods may be called by multiple goroutines simultaneously. 15 | type Context = context.Context 16 | 17 | // A CancelFunc tells an operation to abandon its work. 18 | // A CancelFunc does not wait for the work to stop. 19 | // After the first call, subsequent calls to a CancelFunc do nothing. 20 | type CancelFunc = context.CancelFunc 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/oauth2/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | go: 4 | - 1.3 5 | - 1.4 6 | 7 | install: 8 | - export GOPATH="$HOME/gopath" 9 | - mkdir -p "$GOPATH/src/golang.org/x" 10 | - mv "$TRAVIS_BUILD_DIR" "$GOPATH/src/golang.org/x/oauth2" 11 | - go get -v -t -d golang.org/x/oauth2/... 12 | 13 | script: 14 | - go test -v golang.org/x/oauth2/... 15 | -------------------------------------------------------------------------------- /vendor/golang.org/x/oauth2/AUTHORS: -------------------------------------------------------------------------------- 1 | # This source code refers to The Go Authors for copyright purposes. 2 | # The master list of authors is in the main Go distribution, 3 | # visible at http://tip.golang.org/AUTHORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/oauth2/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # This source code was written by the Go contributors. 2 | # The master list of contributors is in the main Go distribution, 3 | # visible at http://tip.golang.org/CONTRIBUTORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/oauth2/client_appengine.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build appengine 6 | 7 | // App Engine hooks. 8 | 9 | package oauth2 10 | 11 | import ( 12 | "net/http" 13 | 14 | "golang.org/x/net/context" 15 | "golang.org/x/oauth2/internal" 16 | "google.golang.org/appengine/urlfetch" 17 | ) 18 | 19 | func init() { 20 | internal.RegisterContextClientFunc(contextClientAppEngine) 21 | } 22 | 23 | func contextClientAppEngine(ctx context.Context) (*http.Client, error) { 24 | return urlfetch.Client(ctx), nil 25 | } 26 | -------------------------------------------------------------------------------- /vendor/golang.org/x/oauth2/google/appengine_hook.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build appengine 6 | 7 | package google 8 | 9 | import "google.golang.org/appengine" 10 | 11 | func init() { 12 | appengineTokenFunc = appengine.AccessToken 13 | } 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/oauth2/google/appenginevm_hook.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The oauth2 Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build appenginevm 6 | 7 | package google 8 | 9 | import "google.golang.org/appengine" 10 | 11 | func init() { 12 | appengineVM = true 13 | appengineTokenFunc = appengine.AccessToken 14 | } 15 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/AUTHORS: -------------------------------------------------------------------------------- 1 | # This source code refers to The Go Authors for copyright purposes. 2 | # The master list of authors is in the main Go distribution, 3 | # visible at http://tip.golang.org/AUTHORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # This source code was written by the Go contributors. 2 | # The master list of contributors is in the main Go distribution, 3 | # visible at http://tip.golang.org/CONTRIBUTORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/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 | // +build !gccgo 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_ppc64.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 | // +build aix,ppc64 6 | 7 | package cpu 8 | 9 | const cacheLineSize = 128 10 | 11 | const ( 12 | // getsystemcfg constants 13 | _SC_IMPL = 2 14 | _IMPL_POWER8 = 0x10000 15 | _IMPL_POWER9 = 0x20000 16 | ) 17 | 18 | func init() { 19 | impl := getsystemcfg(_SC_IMPL) 20 | if impl&_IMPL_POWER8 != 0 { 21 | PPC64.IsPOWER8 = true 22 | } 23 | if impl&_IMPL_POWER9 != 0 { 24 | PPC64.IsPOWER9 = true 25 | } 26 | 27 | Initialized = true 28 | } 29 | 30 | func getsystemcfg(label int) (n uint64) { 31 | r0, _ := callgetsystemcfg(label) 32 | n = uint64(r0) 33 | return 34 | } 35 | -------------------------------------------------------------------------------- /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 | // +build !gccgo 6 | 7 | package cpu 8 | 9 | func getisar0() uint64 10 | func getisar1() uint64 11 | func getpfr0() uint64 12 | -------------------------------------------------------------------------------- /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 | // +build !gccgo 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 | // +build 386 amd64 amd64p32 6 | // +build !gccgo 7 | 8 | package cpu 9 | 10 | // cpuid is implemented in cpu_x86.s for gc compiler 11 | // and in cpu_gccgo.c for gccgo. 12 | func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32) 13 | 14 | // xgetbv with ecx = 0 is implemented in cpu_x86.s for gc compiler 15 | // and in cpu_gccgo.c for gccgo. 16 | func xgetbv() (eax, edx uint32) 17 | -------------------------------------------------------------------------------- /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 | // +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 | // +build 386 amd64 amd64p32 6 | // +build gccgo 7 | 8 | package cpu 9 | 10 | //extern gccgoGetCpuidCount 11 | func gccgoGetCpuidCount(eaxArg, ecxArg uint32, eax, ebx, ecx, edx *uint32) 12 | 13 | func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32) { 14 | var a, b, c, d uint32 15 | gccgoGetCpuidCount(eaxArg, ecxArg, &a, &b, &c, &d) 16 | return a, b, c, d 17 | } 18 | 19 | //extern gccgoXgetbv 20 | func gccgoXgetbv(eax, edx *uint32) 21 | 22 | func xgetbv() (eax, edx uint32) { 23 | var a, d uint32 24 | gccgoXgetbv(&a, &d) 25 | return a, d 26 | } 27 | -------------------------------------------------------------------------------- /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 | // +build !386,!amd64,!amd64p32,!arm64 6 | 7 | package cpu 8 | 9 | func init() { 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 | // +build 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 | // +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_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 | // +build mips64 mips64le 6 | 7 | package cpu 8 | 9 | const cacheLineSize = 32 10 | -------------------------------------------------------------------------------- /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 | // +build mips mipsle 6 | 7 | package cpu 8 | 9 | const cacheLineSize = 32 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 | // +build !linux,arm64 6 | 7 | package cpu 8 | 9 | func doinit() {} 10 | -------------------------------------------------------------------------------- /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 | // +build riscv64 6 | 7 | package cpu 8 | 9 | const cacheLineSize = 32 10 | -------------------------------------------------------------------------------- /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 | // +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 | -------------------------------------------------------------------------------- /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 | // +build 386 amd64 amd64p32 6 | // +build !gccgo 7 | 8 | #include "textflag.h" 9 | 10 | // func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32) 11 | TEXT ·cpuid(SB), NOSPLIT, $0-24 12 | MOVL eaxArg+0(FP), AX 13 | MOVL ecxArg+4(FP), CX 14 | CPUID 15 | MOVL AX, eax+8(FP) 16 | MOVL BX, ebx+12(FP) 17 | MOVL CX, ecx+16(FP) 18 | MOVL DX, edx+20(FP) 19 | RET 20 | 21 | // func xgetbv() (eax, edx uint32) 22 | TEXT ·xgetbv(SB),NOSPLIT,$0-8 23 | MOVL $0, CX 24 | XGETBV 25 | MOVL AX, eax+0(FP) 26 | MOVL DX, edx+4(FP) 27 | RET 28 | -------------------------------------------------------------------------------- /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 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris 6 | // +build go1.9 7 | 8 | package unix 9 | 10 | import "syscall" 11 | 12 | type Signal = syscall.Signal 13 | type Errno = syscall.Errno 14 | type SysProcAttr = syscall.SysProcAttr 15 | -------------------------------------------------------------------------------- /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 | // +build !gccgo 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_darwin_386.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for 386, Darwin 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-28 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_darwin_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for AMD64, Darwin 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_darwin_arm.s: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | // +build arm,darwin 7 | 8 | #include "textflag.h" 9 | 10 | // 11 | // System call support for ARM, Darwin 12 | // 13 | 14 | // Just jump to package syscall's implementation for all these functions. 15 | // The runtime may know about them. 16 | 17 | TEXT ·Syscall(SB),NOSPLIT,$0-28 18 | B syscall·Syscall(SB) 19 | 20 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 21 | B syscall·Syscall6(SB) 22 | 23 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 24 | B syscall·Syscall9(SB) 25 | 26 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 27 | B syscall·RawSyscall(SB) 28 | 29 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 30 | B syscall·RawSyscall6(SB) 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_darwin_arm64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | // +build arm64,darwin 7 | 8 | #include "textflag.h" 9 | 10 | // 11 | // System call support for AMD64, Darwin 12 | // 13 | 14 | // Just jump to package syscall's implementation for all these functions. 15 | // The runtime may know about them. 16 | 17 | TEXT ·Syscall(SB),NOSPLIT,$0-56 18 | B syscall·Syscall(SB) 19 | 20 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 21 | B syscall·Syscall6(SB) 22 | 23 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 24 | B syscall·Syscall9(SB) 25 | 26 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 27 | B syscall·RawSyscall(SB) 28 | 29 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 30 | B syscall·RawSyscall6(SB) 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_dragonfly_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for AMD64, DragonFly 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_freebsd_386.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for 386, FreeBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-28 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_freebsd_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for AMD64, FreeBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_freebsd_arm.s: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for ARM, FreeBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-28 17 | B syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | B syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | B syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | B syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | B syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_freebsd_arm64.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 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for ARM64, FreeBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_netbsd_386.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for 386, NetBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-28 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_netbsd_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for AMD64, NetBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_netbsd_arm.s: -------------------------------------------------------------------------------- 1 | // Copyright 2013 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for ARM, NetBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-28 17 | B syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | B syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | B syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | B syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | B syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_netbsd_arm64.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 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for ARM64, NetBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | B syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | B syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | B syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | B syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | B syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_openbsd_386.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for 386, OpenBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-28 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_openbsd_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for AMD64, OpenBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_openbsd_arm.s: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for ARM, OpenBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-28 17 | B syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | B syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | B syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | B syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | B syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_openbsd_arm64.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 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for arm64, 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 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for amd64, Solaris are implemented in runtime/syscall_solaris.go 11 | // 12 | 13 | TEXT ·sysvicall6(SB),NOSPLIT,$0-88 14 | JMP syscall·sysvicall6(SB) 15 | 16 | TEXT ·rawSysvicall6(SB),NOSPLIT,$0-88 17 | JMP syscall·rawSysvicall6(SB) 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/constants.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris 6 | 7 | package unix 8 | 9 | const ( 10 | R_OK = 0x4 11 | W_OK = 0x2 12 | X_OK = 0x1 13 | ) 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/endian_big.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | // 5 | // +build ppc64 s390x mips mips64 6 | 7 | package unix 8 | 9 | const isBigEndian = true 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/endian_little.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | // 5 | // +build 386 amd64 amd64p32 arm arm64 ppc64le mipsle mips64le riscv64 6 | 7 | package unix 8 | 9 | const isBigEndian = false 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/env_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2010 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris 6 | 7 | // Unix environment variables. 8 | 9 | package unix 10 | 11 | import "syscall" 12 | 13 | func Getenv(key string) (value string, found bool) { 14 | return syscall.Getenv(key) 15 | } 16 | 17 | func Setenv(key, value string) error { 18 | return syscall.Setenv(key, value) 19 | } 20 | 21 | func Clearenv() { 22 | syscall.Clearenv() 23 | } 24 | 25 | func Environ() []string { 26 | return syscall.Environ() 27 | } 28 | 29 | func Unsetenv(key string) error { 30 | return syscall.Unsetenv(key) 31 | } 32 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/fcntl_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 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/fcntl_linux_32bit.go: -------------------------------------------------------------------------------- 1 | // +build linux,386 linux,arm linux,mips linux,mipsle 2 | 3 | // Copyright 2014 The Go Authors. All rights reserved. 4 | // Use of this source code is governed by a BSD-style 5 | // license that can be found in the LICENSE file. 6 | 7 | package unix 8 | 9 | func init() { 10 | // On 32-bit Linux systems, the fcntl syscall that matches Go's 11 | // Flock_t type is SYS_FCNTL64, not SYS_FCNTL. 12 | fcntl64Syscall = SYS_FCNTL64 13 | } 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/gccgo_linux_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build gccgo,linux,amd64 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | //extern gettimeofday 12 | func realGettimeofday(*Timeval, *byte) int32 13 | 14 | func gettimeofday(tv *Timeval) (err syscall.Errno) { 15 | r := realGettimeofday(tv, nil) 16 | if r < 0 { 17 | return syscall.GetErrno() 18 | } 19 | return 0 20 | } 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/pagesize_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris 6 | 7 | // For Unix, get the pagesize from the runtime. 8 | 9 | package unix 10 | 11 | import "syscall" 12 | 13 | func Getpagesize() int { 14 | return syscall.Getpagesize() 15 | } 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/race.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build darwin,race linux,race freebsd,race 6 | 7 | package unix 8 | 9 | import ( 10 | "runtime" 11 | "unsafe" 12 | ) 13 | 14 | const raceenabled = true 15 | 16 | func raceAcquire(addr unsafe.Pointer) { 17 | runtime.RaceAcquire(addr) 18 | } 19 | 20 | func raceReleaseMerge(addr unsafe.Pointer) { 21 | runtime.RaceReleaseMerge(addr) 22 | } 23 | 24 | func raceReadRange(addr unsafe.Pointer, len int) { 25 | runtime.RaceReadRange(addr, len) 26 | } 27 | 28 | func raceWriteRange(addr unsafe.Pointer, len int) { 29 | runtime.RaceWriteRange(addr, len) 30 | } 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/race0.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build aix darwin,!race linux,!race freebsd,!race netbsd openbsd solaris dragonfly 6 | 7 | package unix 8 | 9 | import ( 10 | "unsafe" 11 | ) 12 | 13 | const raceenabled = false 14 | 15 | func raceAcquire(addr unsafe.Pointer) { 16 | } 17 | 18 | func raceReleaseMerge(addr unsafe.Pointer) { 19 | } 20 | 21 | func raceReadRange(addr unsafe.Pointer, len int) { 22 | } 23 | 24 | func raceWriteRange(addr unsafe.Pointer, len int) { 25 | } 26 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/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 | // +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 | // +build darwin 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/str.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris 6 | 7 | package unix 8 | 9 | func itoa(val int) string { // do it here rather than with fmt to avoid dependency 10 | if val < 0 { 11 | return "-" + uitoa(uint(-val)) 12 | } 13 | return uitoa(uint(val)) 14 | } 15 | 16 | func uitoa(val uint) string { 17 | var buf [32]byte // big enough for int64 18 | i := len(buf) - 1 19 | for val >= 10 { 20 | buf[i] = byte(val%10 + '0') 21 | i-- 22 | val /= 10 23 | } 24 | buf[i] = byte(val + '0') 25 | return string(buf[i:]) 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_darwin_386.1_11.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 | // +build darwin,386,!go1.12 6 | 7 | package unix 8 | 9 | //sys Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) = SYS_GETDIRENTRIES64 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_darwin_amd64.1_11.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 | // +build darwin,amd64,!go1.12 6 | 7 | package unix 8 | 9 | //sys Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) = SYS_GETDIRENTRIES64 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_darwin_arm.1_11.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 | // +build darwin,arm,!go1.12 6 | 7 | package unix 8 | 9 | func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) { 10 | return 0, ENOSYS 11 | } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_darwin_arm64.1_11.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 | // +build darwin,arm64,!go1.12 6 | 7 | package unix 8 | 9 | func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) { 10 | return 0, ENOSYS 11 | } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_amd64_gc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build amd64,linux 6 | // +build !gccgo 7 | 8 | package unix 9 | 10 | import "syscall" 11 | 12 | //go:noescape 13 | func gettimeofday(tv *Timeval) (err syscall.Errno) 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_gc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build linux,!gccgo 6 | 7 | package unix 8 | 9 | // SyscallNoError may be used instead of Syscall for syscalls that don't fail. 10 | func SyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) 11 | 12 | // RawSyscallNoError may be used instead of RawSyscall for syscalls that don't 13 | // fail. 14 | func RawSyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) 15 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_gc_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build linux,!gccgo,386 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | // Underlying system call writes to newoffset via pointer. 12 | // Implemented in assembly to avoid allocation. 13 | func seek(fd int, offset int64, whence int) (newoffset int64, err syscall.Errno) 14 | 15 | func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno) 16 | func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno) 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_gccgo_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build linux,gccgo,arm 6 | 7 | package unix 8 | 9 | import ( 10 | "syscall" 11 | "unsafe" 12 | ) 13 | 14 | func seek(fd int, offset int64, whence int) (int64, syscall.Errno) { 15 | var newoffset int64 16 | offsetLow := uint32(offset & 0xffffffff) 17 | offsetHigh := uint32((offset >> 32) & 0xffffffff) 18 | _, _, err := Syscall6(SYS__LLSEEK, uintptr(fd), uintptr(offsetHigh), uintptr(offsetLow), uintptr(unsafe.Pointer(&newoffset)), uintptr(whence), 0) 19 | return newoffset, err 20 | } 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_solaris_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build amd64,solaris 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: nsec} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: usec} 15 | } 16 | 17 | func (iov *Iovec) SetLen(length int) { 18 | iov.Len = uint64(length) 19 | } 20 | 21 | func (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 | // +build darwin dragonfly freebsd linux netbsd openbsd solaris 6 | // +build !gccgo,!ppc64le,!ppc64 7 | 8 | package unix 9 | 10 | import "syscall" 11 | 12 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) 13 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) 14 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) 15 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/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 ptrace(PTRACE_GETREGSET, pid, uintptr(addr), uintptr(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 ptrace(PTRACE_SETREGSET, pid, uintptr(addr), uintptr(unsafe.Pointer(&iovec))) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/zsyscall_darwin_386.1_13.s: -------------------------------------------------------------------------------- 1 | // go run mkasm_darwin.go 386 2 | // Code generated by the command above; DO NOT EDIT. 3 | 4 | // +build go1.13 5 | 6 | #include "textflag.h" 7 | TEXT ·libc_fdopendir_trampoline(SB),NOSPLIT,$0-0 8 | JMP libc_fdopendir(SB) 9 | TEXT ·libc_closedir_trampoline(SB),NOSPLIT,$0-0 10 | JMP libc_closedir(SB) 11 | TEXT ·libc_readdir_r_trampoline(SB),NOSPLIT,$0-0 12 | JMP libc_readdir_r(SB) 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.1_13.s: -------------------------------------------------------------------------------- 1 | // go run mkasm_darwin.go amd64 2 | // Code generated by the command above; DO NOT EDIT. 3 | 4 | // +build go1.13 5 | 6 | #include "textflag.h" 7 | TEXT ·libc_fdopendir_trampoline(SB),NOSPLIT,$0-0 8 | JMP libc_fdopendir(SB) 9 | TEXT ·libc_closedir_trampoline(SB),NOSPLIT,$0-0 10 | JMP libc_closedir(SB) 11 | TEXT ·libc_readdir_r_trampoline(SB),NOSPLIT,$0-0 12 | JMP libc_readdir_r(SB) 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.1_13.s: -------------------------------------------------------------------------------- 1 | // go run mkasm_darwin.go arm 2 | // Code generated by the command above; DO NOT EDIT. 3 | 4 | // +build go1.13 5 | 6 | #include "textflag.h" 7 | TEXT ·libc_fdopendir_trampoline(SB),NOSPLIT,$0-0 8 | JMP libc_fdopendir(SB) 9 | TEXT ·libc_closedir_trampoline(SB),NOSPLIT,$0-0 10 | JMP libc_closedir(SB) 11 | TEXT ·libc_readdir_r_trampoline(SB),NOSPLIT,$0-0 12 | JMP libc_readdir_r(SB) 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.1_13.s: -------------------------------------------------------------------------------- 1 | // go run mkasm_darwin.go arm64 2 | // Code generated by the command above; DO NOT EDIT. 3 | 4 | // +build go1.13 5 | 6 | #include "textflag.h" 7 | TEXT ·libc_fdopendir_trampoline(SB),NOSPLIT,$0-0 8 | JMP libc_fdopendir(SB) 9 | TEXT ·libc_closedir_trampoline(SB),NOSPLIT,$0-0 10 | JMP libc_closedir(SB) 11 | TEXT ·libc_readdir_r_trampoline(SB),NOSPLIT,$0-0 12 | JMP libc_readdir_r(SB) 13 | -------------------------------------------------------------------------------- /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 | // +build windows 6 | // +build go1.9 7 | 8 | package windows 9 | 10 | import "syscall" 11 | 12 | type Errno = syscall.Errno 13 | type SysProcAttr = syscall.SysProcAttr 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/empty.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 | // +build !go1.12 6 | 7 | // This file is here to allow bodyless functions with go:linkname for Go 1.11 8 | // and earlier (see https://golang.org/issue/23311). 9 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/memory_windows.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package windows 6 | 7 | const ( 8 | MEM_COMMIT = 0x00001000 9 | MEM_RESERVE = 0x00002000 10 | MEM_DECOMMIT = 0x00004000 11 | MEM_RELEASE = 0x00008000 12 | MEM_RESET = 0x00080000 13 | MEM_TOP_DOWN = 0x00100000 14 | MEM_WRITE_WATCH = 0x00200000 15 | MEM_PHYSICAL = 0x00400000 16 | MEM_RESET_UNDO = 0x01000000 17 | MEM_LARGE_PAGES = 0x20000000 18 | 19 | PAGE_NOACCESS = 0x01 20 | PAGE_READONLY = 0x02 21 | PAGE_READWRITE = 0x04 22 | PAGE_WRITECOPY = 0x08 23 | PAGE_EXECUTE_READ = 0x20 24 | PAGE_EXECUTE_READWRITE = 0x40 25 | PAGE_EXECUTE_WRITECOPY = 0x80 26 | ) 27 | -------------------------------------------------------------------------------- /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 | // +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 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 | // +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 | // +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/registry/mksyscall.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build generate 6 | 7 | package registry 8 | 9 | //go:generate go run golang.org/x/sys/windows/mkwinsyscall -output zsyscall_windows.go syscall.go 10 | -------------------------------------------------------------------------------- /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 | // +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/sys/windows/types_windows_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 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 windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | Description [WSADESCRIPTION_LEN + 1]byte 11 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 12 | MaxSockets uint16 13 | MaxUdpDg uint16 14 | VendorInfo *byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Port uint16 21 | Proto *byte 22 | } 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/types_windows_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 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 windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | MaxSockets uint16 11 | MaxUdpDg uint16 12 | VendorInfo *byte 13 | Description [WSADESCRIPTION_LEN + 1]byte 14 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Proto *byte 21 | Port uint16 22 | } 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/types_windows_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 | package windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | Description [WSADESCRIPTION_LEN + 1]byte 11 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 12 | MaxSockets uint16 13 | MaxUdpDg uint16 14 | VendorInfo *byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Port uint16 21 | Proto *byte 22 | } 23 | -------------------------------------------------------------------------------- /vendor/google.golang.org/api/AUTHORS: -------------------------------------------------------------------------------- 1 | # This is the official list of authors for copyright purposes. 2 | # This file is distinct from the CONTRIBUTORS files. 3 | # See the latter for an explanation. 4 | 5 | # Names should be added to this file as 6 | # Name or Organization 7 | # The email address is not required for organizations. 8 | 9 | # Please keep the list sorted. 10 | Google Inc. 11 | -------------------------------------------------------------------------------- /vendor/google.golang.org/api/gensupport/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package gensupport is an internal implementation detail used by code 6 | // generated by the google-api-go-generator tool. 7 | // 8 | // This package may be modified at any time without regard for backwards 9 | // compatibility. It should not be used directly by API users. 10 | package gensupport 11 | -------------------------------------------------------------------------------- /vendor/google.golang.org/api/gensupport/go18.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build go1.8 6 | 7 | package gensupport 8 | 9 | import ( 10 | "io" 11 | "net/http" 12 | ) 13 | 14 | // SetGetBody sets the GetBody field of req to f. 15 | func SetGetBody(req *http.Request, f func() (io.ReadCloser, error)) { 16 | req.GetBody = f 17 | } 18 | -------------------------------------------------------------------------------- /vendor/google.golang.org/api/gensupport/header.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package gensupport 6 | 7 | import ( 8 | "fmt" 9 | "runtime" 10 | "strings" 11 | ) 12 | 13 | // GoogleClientHeader returns the value to use for the x-goog-api-client 14 | // header, which is used internally by Google. 15 | func GoogleClientHeader(generatorVersion, clientElement string) string { 16 | elts := []string{"gl-go/" + strings.Replace(runtime.Version(), " ", "_", -1)} 17 | if clientElement != "" { 18 | elts = append(elts, clientElement) 19 | } 20 | elts = append(elts, fmt.Sprintf("gdcl/%s", generatorVersion)) 21 | return strings.Join(elts, " ") 22 | } 23 | -------------------------------------------------------------------------------- /vendor/google.golang.org/api/gensupport/not_go18.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !go1.8 6 | 7 | package gensupport 8 | 9 | import ( 10 | "io" 11 | "net/http" 12 | ) 13 | 14 | func SetGetBody(req *http.Request, f func() (io.ReadCloser, error)) {} 15 | -------------------------------------------------------------------------------- /vendor/google.golang.org/api/googleapi/internal/uritemplates/utils.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package uritemplates 6 | 7 | // Expand parses then expands a URI template with a set of values to produce 8 | // the resultant URI. Two forms of the result are returned: one with all the 9 | // elements escaped, and one with the elements unescaped. 10 | func Expand(path string, values map[string]string) (escaped, unescaped string, err error) { 11 | template, err := parse(path) 12 | if err != nil { 13 | return "", "", err 14 | } 15 | escaped, unescaped = template.Expand(values) 16 | return escaped, unescaped, nil 17 | } 18 | -------------------------------------------------------------------------------- /vendor/google.golang.org/appengine/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | sudo: false 3 | 4 | go: 5 | - 1.4 6 | 7 | install: 8 | - go get -v -t -d google.golang.org/appengine/... 9 | - mkdir sdk 10 | - curl -o sdk.zip "https://storage.googleapis.com/appengine-sdks/featured/go_appengine_sdk_linux_amd64-1.9.24.zip" 11 | - unzip sdk.zip -d sdk 12 | - export APPENGINE_DEV_APPSERVER=$(pwd)/sdk/go_appengine/dev_appserver.py 13 | 14 | script: 15 | - go version 16 | - go test -v google.golang.org/appengine/... 17 | - go test -v -race google.golang.org/appengine/... 18 | - sdk/go_appengine/goapp test -v google.golang.org/appengine/... 19 | -------------------------------------------------------------------------------- /vendor/google.golang.org/appengine/internal/app_id.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 Google Inc. All rights reserved. 2 | // Use of this source code is governed by the Apache 2.0 3 | // license that can be found in the LICENSE file. 4 | 5 | package internal 6 | 7 | import ( 8 | "strings" 9 | ) 10 | 11 | func parseFullAppID(appid string) (partition, domain, displayID string) { 12 | if i := strings.Index(appid, "~"); i != -1 { 13 | partition, appid = appid[:i], appid[i+1:] 14 | } 15 | if i := strings.Index(appid, ":"); i != -1 { 16 | domain, appid = appid[:i], appid[i+1:] 17 | } 18 | return partition, domain, appid 19 | } 20 | 21 | // appID returns "appid" or "domain.com:appid". 22 | func appID(fullAppID string) string { 23 | _, dom, dis := parseFullAppID(fullAppID) 24 | if dom != "" { 25 | return dom + ":" + dis 26 | } 27 | return dis 28 | } 29 | -------------------------------------------------------------------------------- /vendor/google.golang.org/appengine/internal/base/api_base.proto: -------------------------------------------------------------------------------- 1 | // Built-in base types for API calls. Primarily useful as return types. 2 | 3 | syntax = "proto2"; 4 | option go_package = "base"; 5 | 6 | package appengine.base; 7 | 8 | message StringProto { 9 | required string value = 1; 10 | } 11 | 12 | message Integer32Proto { 13 | required int32 value = 1; 14 | } 15 | 16 | message Integer64Proto { 17 | required int64 value = 1; 18 | } 19 | 20 | message BoolProto { 21 | required bool value = 1; 22 | } 23 | 24 | message DoubleProto { 25 | required double value = 1; 26 | } 27 | 28 | message BytesProto { 29 | required bytes value = 1 [ctype=CORD]; 30 | } 31 | 32 | message VoidProto { 33 | } 34 | -------------------------------------------------------------------------------- /vendor/google.golang.org/appengine/internal/identity.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 Google Inc. All rights reserved. 2 | // Use of this source code is governed by the Apache 2.0 3 | // license that can be found in the LICENSE file. 4 | 5 | package internal 6 | 7 | import netcontext "golang.org/x/net/context" 8 | 9 | // These functions are implementations of the wrapper functions 10 | // in ../appengine/identity.go. See that file for commentary. 11 | 12 | func AppID(c netcontext.Context) string { 13 | return appID(FullyQualifiedAppID(c)) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/google.golang.org/appengine/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/cloud/AUTHORS: -------------------------------------------------------------------------------- 1 | # This is the official list of cloud authors for copyright purposes. 2 | # This file is distinct from the CONTRIBUTORS files. 3 | # See the latter for an explanation. 4 | 5 | # Names should be added to this file as: 6 | # Name or Organization 7 | # The email address is not required for organizations. 8 | 9 | Google Inc. 10 | Palm Stone Games, Inc. 11 | Péter Szilágyi 12 | Tyler Treat 13 | -------------------------------------------------------------------------------- /version/version.go: -------------------------------------------------------------------------------- 1 | package version 2 | 3 | import ( 4 | "fmt" 5 | "strings" 6 | ) 7 | 8 | var ( 9 | Version = "dev" 10 | 11 | // GitCommit will be overwritten automatically by the build system 12 | GitCommit = "HEAD" 13 | ) 14 | 15 | // FullVersion formats the version to be printed 16 | func FullVersion() string { 17 | return fmt.Sprintf("%s, build %s", Version, GitCommit) 18 | } 19 | 20 | // RC checks if the Machine version is a release candidate or not 21 | func RC() bool { 22 | return strings.Contains(Version, "rc") 23 | } 24 | --------------------------------------------------------------------------------