├── .env.sample ├── .gitignore ├── Dockerfile ├── Gemfile ├── Gemfile.lock ├── Godeps ├── Godeps.json ├── Readme └── _workspace │ └── .gitignore ├── LICENSE ├── Makefile ├── README.md ├── Vagrantfile ├── artifacts.go ├── bin ├── ansible └── install_ansible ├── bindata.go ├── builder ├── README.md ├── builder.go ├── builder_test.go ├── datadog │ ├── datadog.go │ ├── datadog_test.go │ └── tests │ │ └── datadog_test.go ├── docker │ ├── .gitignore │ ├── README.md │ ├── docker.go │ ├── docker_test.go │ └── tests │ │ └── docker_test.go ├── github.go └── github_test.go ├── builds.go ├── circle.yml ├── client └── conveyor │ ├── build.go │ ├── conveyor.go │ ├── errors.go │ ├── logs.go │ └── transport.go ├── cloudformation.json ├── cmd └── conveyor │ ├── factories.go │ ├── main.go │ ├── server.go │ └── worker.go ├── conveyor.go ├── conveyor_test.go ├── db └── migrations │ └── 1_initial_schema.sql ├── docker-compose.yml ├── github.go ├── internal └── ghinstallation │ ├── LICENSE │ ├── README.md │ ├── appsTransport.go │ ├── appsTransport_test.go │ ├── transport.go │ └── transport_test.go ├── logs ├── cloudwatch │ ├── cloudwatch.go │ └── cloudwatch_test.go ├── fs.go ├── logs.go └── s3 │ └── s3.go ├── meta.json ├── packer.json ├── queue.go ├── queue_test.go ├── roles ├── cf-tools │ └── tasks │ │ └── main.yml ├── common │ ├── defaults │ │ └── main.yml │ ├── tasks │ │ └── main.yml │ └── templates │ │ └── etc │ │ └── hosts ├── conveyor │ ├── defaults │ │ └── main.yml │ ├── tasks │ │ └── main.yml │ └── templates │ │ ├── etc │ │ └── init │ │ │ └── conveyor.conf │ │ └── usr │ │ └── bin │ │ └── conveyor ├── datadog │ └── tasks │ │ └── main.yml └── docker │ ├── defaults │ └── main.yml │ ├── handlers │ └── main.yml │ ├── tasks │ └── main.yml │ └── templates │ └── root │ └── .dockercfg ├── schema.go ├── schema.json ├── schema.md ├── schemata ├── artifact.json ├── build.json └── error.json ├── server ├── api │ ├── api.go │ └── api_test.go ├── github │ ├── github.go │ └── github_test.go └── server.go ├── site.yml ├── tests └── api │ └── api_test.go ├── vendor ├── code.google.com │ └── p │ │ └── go-uuid │ │ └── uuid │ │ ├── LICENSE │ │ ├── dce.go │ │ ├── doc.go │ │ ├── hash.go │ │ ├── node.go │ │ ├── time.go │ │ ├── util.go │ │ ├── uuid.go │ │ ├── uuid_test.go │ │ ├── version1.go │ │ └── version4.go ├── github.com │ ├── Azure │ │ └── 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 │ ├── DataDog │ │ └── datadog-go │ │ │ └── statsd │ │ │ ├── README.md │ │ │ ├── statsd.go │ │ │ └── statsd_test.go │ ├── Microsoft │ │ └── go-winio │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── backup.go │ │ │ ├── ea.go │ │ │ ├── file.go │ │ │ ├── fileinfo.go │ │ │ ├── pipe.go │ │ │ ├── privilege.go │ │ │ ├── reparse.go │ │ │ ├── sd.go │ │ │ ├── syscall.go │ │ │ └── zsyscall_windows.go │ ├── Nvveen │ │ └── Gotty │ │ │ ├── LICENSE │ │ │ ├── README │ │ │ ├── attributes.go │ │ │ ├── gotty.go │ │ │ ├── parser.go │ │ │ └── types.go │ ├── aws │ │ └── aws-sdk-go │ │ │ ├── aws │ │ │ ├── awserr │ │ │ │ ├── error.go │ │ │ │ └── types.go │ │ │ ├── awsutil │ │ │ │ ├── copy.go │ │ │ │ ├── copy_test.go │ │ │ │ ├── path_value.go │ │ │ │ ├── path_value_test.go │ │ │ │ └── prettify.go │ │ │ ├── config.go │ │ │ ├── config_test.go │ │ │ ├── convert_types.go │ │ │ ├── convert_types_test.go │ │ │ ├── corehandlers │ │ │ │ ├── handlers.go │ │ │ │ ├── handlers_test.go │ │ │ │ ├── param_validator.go │ │ │ │ └── param_validator_test.go │ │ │ ├── credentials │ │ │ │ ├── chain_provider.go │ │ │ │ ├── chain_provider_test.go │ │ │ │ ├── credentials.go │ │ │ │ ├── credentials_test.go │ │ │ │ ├── ec2rolecreds │ │ │ │ │ ├── ec2_role_provider.go │ │ │ │ │ └── ec2_role_provider_test.go │ │ │ │ ├── env_provider.go │ │ │ │ ├── env_provider_test.go │ │ │ │ ├── example.ini │ │ │ │ ├── shared_credentials_provider.go │ │ │ │ ├── shared_credentials_provider_test.go │ │ │ │ ├── static_provider.go │ │ │ │ ├── static_provider_test.go │ │ │ │ └── stscreds │ │ │ │ │ ├── assume_role_provider.go │ │ │ │ │ └── assume_role_provider_test.go │ │ │ ├── defaults │ │ │ │ └── defaults.go │ │ │ ├── ec2metadata │ │ │ │ ├── api.go │ │ │ │ ├── api_test.go │ │ │ │ └── service.go │ │ │ ├── errors.go │ │ │ ├── logger.go │ │ │ ├── request │ │ │ │ ├── handlers.go │ │ │ │ ├── handlers_test.go │ │ │ │ ├── request.go │ │ │ │ ├── request_pagination_test.go │ │ │ │ ├── request_test.go │ │ │ │ └── retryer.go │ │ │ ├── service │ │ │ │ ├── default_retryer.go │ │ │ │ ├── service.go │ │ │ │ └── serviceinfo │ │ │ │ │ └── service_info.go │ │ │ ├── types.go │ │ │ ├── types_test.go │ │ │ └── version.go │ │ │ ├── internal │ │ │ ├── endpoints │ │ │ │ ├── endpoints.go │ │ │ │ ├── endpoints.json │ │ │ │ ├── endpoints_map.go │ │ │ │ └── endpoints_test.go │ │ │ ├── protocol │ │ │ │ ├── json │ │ │ │ │ └── jsonutil │ │ │ │ │ │ ├── build.go │ │ │ │ │ │ ├── build_test.go │ │ │ │ │ │ └── unmarshal.go │ │ │ │ ├── jsonrpc │ │ │ │ │ ├── build_test.go │ │ │ │ │ ├── jsonrpc.go │ │ │ │ │ └── unmarshal_test.go │ │ │ │ ├── query │ │ │ │ │ ├── build.go │ │ │ │ │ ├── build_test.go │ │ │ │ │ ├── queryutil │ │ │ │ │ │ └── queryutil.go │ │ │ │ │ ├── unmarshal.go │ │ │ │ │ ├── unmarshal_error.go │ │ │ │ │ └── unmarshal_test.go │ │ │ │ ├── rest │ │ │ │ │ ├── build.go │ │ │ │ │ ├── payload.go │ │ │ │ │ └── unmarshal.go │ │ │ │ ├── restxml │ │ │ │ │ ├── build_test.go │ │ │ │ │ ├── restxml.go │ │ │ │ │ └── unmarshal_test.go │ │ │ │ └── xml │ │ │ │ │ └── xmlutil │ │ │ │ │ ├── build.go │ │ │ │ │ ├── unmarshal.go │ │ │ │ │ └── xml_to_struct.go │ │ │ └── signer │ │ │ │ └── v4 │ │ │ │ ├── functional_test.go │ │ │ │ ├── v4.go │ │ │ │ └── v4_test.go │ │ │ └── service │ │ │ ├── cloudwatchlogs │ │ │ ├── api.go │ │ │ ├── cloudwatchlogsiface │ │ │ │ ├── interface.go │ │ │ │ └── interface_test.go │ │ │ ├── examples_test.go │ │ │ └── service.go │ │ │ ├── s3 │ │ │ ├── api.go │ │ │ ├── bucket_location.go │ │ │ ├── bucket_location_test.go │ │ │ ├── content_md5.go │ │ │ ├── customizations.go │ │ │ ├── customizations_test.go │ │ │ ├── examples_test.go │ │ │ ├── host_style_bucket.go │ │ │ ├── host_style_bucket_test.go │ │ │ ├── s3iface │ │ │ │ ├── interface.go │ │ │ │ └── interface_test.go │ │ │ ├── s3manager │ │ │ │ ├── download.go │ │ │ │ ├── download_test.go │ │ │ │ ├── upload.go │ │ │ │ └── upload_test.go │ │ │ ├── service.go │ │ │ ├── sse.go │ │ │ ├── sse_test.go │ │ │ ├── statusok_error.go │ │ │ ├── statusok_error_test.go │ │ │ ├── unmarshal_error.go │ │ │ └── unmarshal_error_test.go │ │ │ └── sqs │ │ │ ├── api.go │ │ │ ├── api_test.go │ │ │ ├── checksums.go │ │ │ ├── checksums_test.go │ │ │ ├── customizations.go │ │ │ ├── examples_test.go │ │ │ ├── service.go │ │ │ └── sqsiface │ │ │ ├── interface.go │ │ │ └── interface_test.go │ ├── codegangsta │ │ ├── cli │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── app.go │ │ │ ├── app_test.go │ │ │ ├── autocomplete │ │ │ │ ├── bash_autocomplete │ │ │ │ └── zsh_autocomplete │ │ │ ├── cli.go │ │ │ ├── cli_test.go │ │ │ ├── command.go │ │ │ ├── command_test.go │ │ │ ├── context.go │ │ │ ├── context_test.go │ │ │ ├── flag.go │ │ │ ├── flag_test.go │ │ │ ├── help.go │ │ │ └── helpers_test.go │ │ └── negroni │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── doc.go │ │ │ ├── logger.go │ │ │ ├── logger_test.go │ │ │ ├── negroni.go │ │ │ ├── negroni_test.go │ │ │ ├── recovery.go │ │ │ ├── recovery_test.go │ │ │ ├── response_writer.go │ │ │ ├── response_writer_test.go │ │ │ ├── static.go │ │ │ └── static_test.go │ ├── containerd │ │ └── continuity │ │ │ ├── LICENSE │ │ │ └── pathdriver │ │ │ └── path_driver.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 │ │ │ ├── LICENSE │ │ │ ├── MIGRATION_GUIDE.md │ │ │ ├── README.md │ │ │ ├── VERSION_HISTORY.md │ │ │ ├── claims.go │ │ │ ├── doc.go │ │ │ ├── ecdsa.go │ │ │ ├── ecdsa_test.go │ │ │ ├── ecdsa_utils.go │ │ │ ├── errors.go │ │ │ ├── example_test.go │ │ │ ├── hmac.go │ │ │ ├── hmac_example_test.go │ │ │ ├── hmac_test.go │ │ │ ├── http_example_test.go │ │ │ ├── map_claims.go │ │ │ ├── none.go │ │ │ ├── none_test.go │ │ │ ├── parser.go │ │ │ ├── parser_test.go │ │ │ ├── rsa.go │ │ │ ├── rsa_pss.go │ │ │ ├── rsa_pss_test.go │ │ │ ├── rsa_test.go │ │ │ ├── rsa_utils.go │ │ │ ├── signing_method.go │ │ │ └── token.go │ ├── docker │ │ ├── docker │ │ │ ├── LICENSE │ │ │ ├── NOTICE │ │ │ ├── api │ │ │ │ └── types │ │ │ │ │ ├── auth.go │ │ │ │ │ ├── blkiodev │ │ │ │ │ └── blkio.go │ │ │ │ │ ├── client.go │ │ │ │ │ ├── configs.go │ │ │ │ │ ├── container │ │ │ │ │ ├── config.go │ │ │ │ │ ├── container_changes.go │ │ │ │ │ ├── container_create.go │ │ │ │ │ ├── container_top.go │ │ │ │ │ ├── container_update.go │ │ │ │ │ ├── container_wait.go │ │ │ │ │ ├── host_config.go │ │ │ │ │ ├── hostconfig_unix.go │ │ │ │ │ ├── hostconfig_windows.go │ │ │ │ │ └── waitcondition.go │ │ │ │ │ ├── error_response.go │ │ │ │ │ ├── filters │ │ │ │ │ ├── example_test.go │ │ │ │ │ ├── parse.go │ │ │ │ │ └── parse_test.go │ │ │ │ │ ├── graph_driver_data.go │ │ │ │ │ ├── id_response.go │ │ │ │ │ ├── image_delete_response_item.go │ │ │ │ │ ├── image_summary.go │ │ │ │ │ ├── mount │ │ │ │ │ └── mount.go │ │ │ │ │ ├── network │ │ │ │ │ └── network.go │ │ │ │ │ ├── plugin.go │ │ │ │ │ ├── plugin_device.go │ │ │ │ │ ├── plugin_env.go │ │ │ │ │ ├── plugin_interface_type.go │ │ │ │ │ ├── plugin_mount.go │ │ │ │ │ ├── plugin_responses.go │ │ │ │ │ ├── port.go │ │ │ │ │ ├── registry │ │ │ │ │ ├── authenticate.go │ │ │ │ │ └── registry.go │ │ │ │ │ ├── seccomp.go │ │ │ │ │ ├── service_update_response.go │ │ │ │ │ ├── stats.go │ │ │ │ │ ├── strslice │ │ │ │ │ ├── strslice.go │ │ │ │ │ └── strslice_test.go │ │ │ │ │ ├── swarm │ │ │ │ │ ├── common.go │ │ │ │ │ ├── config.go │ │ │ │ │ ├── container.go │ │ │ │ │ ├── network.go │ │ │ │ │ ├── node.go │ │ │ │ │ ├── runtime.go │ │ │ │ │ ├── runtime │ │ │ │ │ │ ├── gen.go │ │ │ │ │ │ ├── plugin.pb.go │ │ │ │ │ │ └── plugin.proto │ │ │ │ │ ├── secret.go │ │ │ │ │ ├── service.go │ │ │ │ │ ├── swarm.go │ │ │ │ │ └── task.go │ │ │ │ │ ├── types.go │ │ │ │ │ ├── versions │ │ │ │ │ ├── README.md │ │ │ │ │ ├── compare.go │ │ │ │ │ └── compare_test.go │ │ │ │ │ └── volume.go │ │ │ ├── opts │ │ │ │ ├── env.go │ │ │ │ ├── env_test.go │ │ │ │ ├── hosts.go │ │ │ │ ├── hosts_test.go │ │ │ │ ├── hosts_unix.go │ │ │ │ ├── hosts_windows.go │ │ │ │ ├── ip.go │ │ │ │ ├── ip_test.go │ │ │ │ ├── opts.go │ │ │ │ ├── opts_test.go │ │ │ │ ├── opts_unix.go │ │ │ │ ├── opts_windows.go │ │ │ │ ├── quotedstring.go │ │ │ │ ├── quotedstring_test.go │ │ │ │ ├── runtime.go │ │ │ │ ├── ulimit.go │ │ │ │ └── ulimit_test.go │ │ │ └── pkg │ │ │ │ ├── archive │ │ │ │ ├── README.md │ │ │ │ ├── archive.go │ │ │ │ ├── archive_linux.go │ │ │ │ ├── archive_linux_test.go │ │ │ │ ├── archive_other.go │ │ │ │ ├── archive_test.go │ │ │ │ ├── archive_unix.go │ │ │ │ ├── archive_unix_test.go │ │ │ │ ├── archive_windows.go │ │ │ │ ├── archive_windows_test.go │ │ │ │ ├── changes.go │ │ │ │ ├── changes_linux.go │ │ │ │ ├── changes_other.go │ │ │ │ ├── changes_posix_test.go │ │ │ │ ├── changes_test.go │ │ │ │ ├── changes_unix.go │ │ │ │ ├── changes_windows.go │ │ │ │ ├── copy.go │ │ │ │ ├── copy_unix.go │ │ │ │ ├── copy_unix_test.go │ │ │ │ ├── copy_windows.go │ │ │ │ ├── diff.go │ │ │ │ ├── diff_test.go │ │ │ │ ├── example_changes.go │ │ │ │ ├── testdata │ │ │ │ │ └── broken.tar │ │ │ │ ├── time_linux.go │ │ │ │ ├── time_unsupported.go │ │ │ │ ├── utils_test.go │ │ │ │ ├── whiteouts.go │ │ │ │ ├── wrap.go │ │ │ │ └── wrap_test.go │ │ │ │ ├── fileutils │ │ │ │ ├── fileutils.go │ │ │ │ ├── fileutils_darwin.go │ │ │ │ ├── fileutils_test.go │ │ │ │ ├── fileutils_unix.go │ │ │ │ └── fileutils_windows.go │ │ │ │ ├── homedir │ │ │ │ ├── homedir_linux.go │ │ │ │ ├── homedir_others.go │ │ │ │ ├── homedir_test.go │ │ │ │ ├── homedir_unix.go │ │ │ │ └── homedir_windows.go │ │ │ │ ├── idtools │ │ │ │ ├── idtools.go │ │ │ │ ├── idtools_unix.go │ │ │ │ ├── idtools_unix_test.go │ │ │ │ ├── idtools_windows.go │ │ │ │ ├── usergroupadd_linux.go │ │ │ │ ├── usergroupadd_unsupported.go │ │ │ │ └── utils_unix.go │ │ │ │ ├── ioutils │ │ │ │ ├── buffer.go │ │ │ │ ├── buffer_test.go │ │ │ │ ├── bytespipe.go │ │ │ │ ├── bytespipe_test.go │ │ │ │ ├── fswriters.go │ │ │ │ ├── fswriters_test.go │ │ │ │ ├── readers.go │ │ │ │ ├── readers_test.go │ │ │ │ ├── temp_unix.go │ │ │ │ ├── temp_windows.go │ │ │ │ ├── writeflusher.go │ │ │ │ ├── writers.go │ │ │ │ └── writers_test.go │ │ │ │ ├── jsonmessage │ │ │ │ ├── jsonmessage.go │ │ │ │ └── jsonmessage_test.go │ │ │ │ ├── longpath │ │ │ │ ├── longpath.go │ │ │ │ └── longpath_test.go │ │ │ │ ├── mount │ │ │ │ ├── flags.go │ │ │ │ ├── flags_freebsd.go │ │ │ │ ├── flags_linux.go │ │ │ │ ├── flags_unsupported.go │ │ │ │ ├── mount.go │ │ │ │ ├── mount_unix_test.go │ │ │ │ ├── mounter_freebsd.go │ │ │ │ ├── mounter_linux.go │ │ │ │ ├── mounter_linux_test.go │ │ │ │ ├── mounter_unsupported.go │ │ │ │ ├── mountinfo.go │ │ │ │ ├── mountinfo_freebsd.go │ │ │ │ ├── mountinfo_linux.go │ │ │ │ ├── mountinfo_linux_test.go │ │ │ │ ├── mountinfo_unsupported.go │ │ │ │ ├── mountinfo_windows.go │ │ │ │ ├── sharedsubtree_linux.go │ │ │ │ └── sharedsubtree_linux_test.go │ │ │ │ ├── pools │ │ │ │ ├── pools.go │ │ │ │ └── pools_test.go │ │ │ │ ├── stdcopy │ │ │ │ ├── stdcopy.go │ │ │ │ └── stdcopy_test.go │ │ │ │ ├── system │ │ │ │ ├── chtimes.go │ │ │ │ ├── chtimes_test.go │ │ │ │ ├── chtimes_unix.go │ │ │ │ ├── chtimes_unix_test.go │ │ │ │ ├── chtimes_windows.go │ │ │ │ ├── chtimes_windows_test.go │ │ │ │ ├── errors.go │ │ │ │ ├── exitcode.go │ │ │ │ ├── filesys.go │ │ │ │ ├── filesys_windows.go │ │ │ │ ├── init.go │ │ │ │ ├── init_unix.go │ │ │ │ ├── init_windows.go │ │ │ │ ├── lcow.go │ │ │ │ ├── lcow_unix.go │ │ │ │ ├── lcow_windows.go │ │ │ │ ├── lstat_unix.go │ │ │ │ ├── lstat_unix_test.go │ │ │ │ ├── lstat_windows.go │ │ │ │ ├── meminfo.go │ │ │ │ ├── meminfo_linux.go │ │ │ │ ├── meminfo_unix_test.go │ │ │ │ ├── meminfo_unsupported.go │ │ │ │ ├── meminfo_windows.go │ │ │ │ ├── mknod.go │ │ │ │ ├── mknod_windows.go │ │ │ │ ├── path.go │ │ │ │ ├── path_windows_test.go │ │ │ │ ├── process_unix.go │ │ │ │ ├── process_windows.go │ │ │ │ ├── rm.go │ │ │ │ ├── rm_test.go │ │ │ │ ├── stat_darwin.go │ │ │ │ ├── stat_freebsd.go │ │ │ │ ├── stat_linux.go │ │ │ │ ├── stat_openbsd.go │ │ │ │ ├── stat_solaris.go │ │ │ │ ├── stat_unix.go │ │ │ │ ├── stat_unix_test.go │ │ │ │ ├── stat_windows.go │ │ │ │ ├── syscall_unix.go │ │ │ │ ├── syscall_windows.go │ │ │ │ ├── syscall_windows_test.go │ │ │ │ ├── umask.go │ │ │ │ ├── umask_windows.go │ │ │ │ ├── utimes_freebsd.go │ │ │ │ ├── utimes_linux.go │ │ │ │ ├── utimes_unix_test.go │ │ │ │ ├── utimes_unsupported.go │ │ │ │ ├── xattrs_linux.go │ │ │ │ └── xattrs_unsupported.go │ │ │ │ └── term │ │ │ │ ├── ascii.go │ │ │ │ ├── ascii_test.go │ │ │ │ ├── proxy.go │ │ │ │ ├── proxy_test.go │ │ │ │ ├── tc.go │ │ │ │ ├── term.go │ │ │ │ ├── term_linux_test.go │ │ │ │ ├── term_windows.go │ │ │ │ ├── termios_bsd.go │ │ │ │ ├── termios_linux.go │ │ │ │ ├── windows │ │ │ │ ├── ansi_reader.go │ │ │ │ ├── ansi_writer.go │ │ │ │ ├── console.go │ │ │ │ ├── windows.go │ │ │ │ └── windows_test.go │ │ │ │ └── winsize.go │ │ ├── go-connections │ │ │ ├── LICENSE │ │ │ └── nat │ │ │ │ ├── nat.go │ │ │ │ ├── parse.go │ │ │ │ └── sort.go │ │ └── go-units │ │ │ ├── CONTRIBUTING.md │ │ │ ├── LICENSE │ │ │ ├── MAINTAINERS │ │ │ ├── README.md │ │ │ ├── circle.yml │ │ │ ├── duration.go │ │ │ ├── duration_test.go │ │ │ ├── size.go │ │ │ ├── size_test.go │ │ │ ├── ulimit.go │ │ │ └── ulimit_test.go │ ├── ejholmes │ │ ├── cloudwatch │ │ │ ├── README.md │ │ │ ├── cloudwatch.go │ │ │ ├── example │ │ │ │ └── main.go │ │ │ ├── reader.go │ │ │ └── writer.go │ │ └── hookshot │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── events │ │ │ ├── commit_comment.go │ │ │ ├── create.go │ │ │ ├── delete.go │ │ │ ├── deployment.go │ │ │ ├── deployment_status.go │ │ │ ├── events.go │ │ │ ├── fork.go │ │ │ ├── generate │ │ │ ├── gollum.go │ │ │ ├── issue_comment.go │ │ │ ├── issues.go │ │ │ ├── member.go │ │ │ ├── membership.go │ │ │ ├── page_build.go │ │ │ ├── ping.go │ │ │ ├── public.go │ │ │ ├── pull_request.go │ │ │ ├── pull_request_review_comment.go │ │ │ ├── push.go │ │ │ ├── release.go │ │ │ ├── repository.go │ │ │ ├── status.go │ │ │ ├── team_add.go │ │ │ ├── timestamp.go │ │ │ └── watch.go │ │ │ ├── example_test.go │ │ │ ├── hooker │ │ │ ├── hooker.go │ │ │ └── hooker_test.go │ │ │ ├── hookshot.go │ │ │ └── hookshot_test.go │ ├── ernesto-jimenez │ │ └── go-querystring │ │ │ ├── LICENSE │ │ │ └── query │ │ │ └── encode.go │ ├── fsouza │ │ └── go-dockerclient │ │ │ ├── AUTHORS │ │ │ ├── DOCKER-LICENSE │ │ │ ├── LICENSE │ │ │ ├── Makefile │ │ │ ├── README.markdown │ │ │ ├── appveyor.yml │ │ │ ├── auth.go │ │ │ ├── auth_test.go │ │ │ ├── build_test.go │ │ │ ├── change.go │ │ │ ├── change_test.go │ │ │ ├── client.go │ │ │ ├── client_stress_test.go │ │ │ ├── client_test.go │ │ │ ├── client_unix.go │ │ │ ├── client_unix_test.go │ │ │ ├── client_windows.go │ │ │ ├── client_windows_test.go │ │ │ ├── container.go │ │ │ ├── container_test.go │ │ │ ├── container_unix_test.go │ │ │ ├── env.go │ │ │ ├── env_test.go │ │ │ ├── event.go │ │ │ ├── event_test.go │ │ │ ├── example_test.go │ │ │ ├── exec.go │ │ │ ├── exec_test.go │ │ │ ├── image.go │ │ │ ├── image_test.go │ │ │ ├── integration_test.go │ │ │ ├── misc.go │ │ │ ├── misc_test.go │ │ │ ├── network.go │ │ │ ├── network_test.go │ │ │ ├── node.go │ │ │ ├── node_test.go │ │ │ ├── service.go │ │ │ ├── service_test.go │ │ │ ├── signal.go │ │ │ ├── swarm.go │ │ │ ├── swarm_test.go │ │ │ ├── tar.go │ │ │ ├── task.go │ │ │ ├── task_test.go │ │ │ ├── tls.go │ │ │ ├── volume.go │ │ │ └── volume_test.go │ ├── go-ini │ │ └── ini │ │ │ ├── LICENSE │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── README_ZH.md │ │ │ ├── error.go │ │ │ ├── ini.go │ │ │ ├── ini_test.go │ │ │ ├── key.go │ │ │ ├── key_test.go │ │ │ ├── parser.go │ │ │ ├── parser_test.go │ │ │ ├── section.go │ │ │ ├── section_test.go │ │ │ ├── struct.go │ │ │ ├── struct_test.go │ │ │ └── testdata │ │ │ ├── UTF-16-BE-BOM.ini │ │ │ ├── UTF-16-LE-BOM.ini │ │ │ ├── UTF-8-BOM.ini │ │ │ ├── aicc.ini │ │ │ └── conf.ini │ ├── gogo │ │ └── protobuf │ │ │ ├── LICENSE │ │ │ └── proto │ │ │ ├── clone.go │ │ │ ├── decode.go │ │ │ ├── decode_gogo.go │ │ │ ├── duration.go │ │ │ ├── duration_gogo.go │ │ │ ├── encode.go │ │ │ ├── encode_gogo.go │ │ │ ├── equal.go │ │ │ ├── extensions.go │ │ │ ├── extensions_gogo.go │ │ │ ├── lib.go │ │ │ ├── lib_gogo.go │ │ │ ├── message_set.go │ │ │ ├── pointer_reflect.go │ │ │ ├── pointer_reflect_gogo.go │ │ │ ├── pointer_unsafe.go │ │ │ ├── pointer_unsafe_gogo.go │ │ │ ├── properties.go │ │ │ ├── properties_gogo.go │ │ │ ├── skip_gogo.go │ │ │ ├── text.go │ │ │ ├── text_gogo.go │ │ │ ├── text_parser.go │ │ │ ├── timestamp.go │ │ │ └── timestamp_gogo.go │ ├── goji │ │ └── httpauth │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ └── basic_auth.go │ ├── google │ │ ├── go-github │ │ │ ├── LICENSE │ │ │ └── github │ │ │ │ ├── activity.go │ │ │ │ ├── activity_events.go │ │ │ │ ├── activity_events_test.go │ │ │ │ ├── activity_notifications.go │ │ │ │ ├── activity_notifications_test.go │ │ │ │ ├── activity_star.go │ │ │ │ ├── activity_star_test.go │ │ │ │ ├── activity_test.go │ │ │ │ ├── activity_watching.go │ │ │ │ ├── activity_watching_test.go │ │ │ │ ├── admin.go │ │ │ │ ├── admin_stats.go │ │ │ │ ├── admin_stats_test.go │ │ │ │ ├── admin_test.go │ │ │ │ ├── apps.go │ │ │ │ ├── apps_installation.go │ │ │ │ ├── apps_installation_test.go │ │ │ │ ├── apps_marketplace.go │ │ │ │ ├── apps_marketplace_test.go │ │ │ │ ├── apps_test.go │ │ │ │ ├── authorizations.go │ │ │ │ ├── authorizations_test.go │ │ │ │ ├── doc.go │ │ │ │ ├── event_types.go │ │ │ │ ├── examples_test.go │ │ │ │ ├── gen-accessors.go │ │ │ │ ├── gists.go │ │ │ │ ├── gists_comments.go │ │ │ │ ├── gists_comments_test.go │ │ │ │ ├── gists_test.go │ │ │ │ ├── git.go │ │ │ │ ├── git_blobs.go │ │ │ │ ├── git_blobs_test.go │ │ │ │ ├── git_commits.go │ │ │ │ ├── git_commits_test.go │ │ │ │ ├── git_refs.go │ │ │ │ ├── git_refs_test.go │ │ │ │ ├── git_tags.go │ │ │ │ ├── git_tags_test.go │ │ │ │ ├── git_trees.go │ │ │ │ ├── git_trees_test.go │ │ │ │ ├── github-accessors.go │ │ │ │ ├── github.go │ │ │ │ ├── github_test.go │ │ │ │ ├── gitignore.go │ │ │ │ ├── gitignore_test.go │ │ │ │ ├── issues.go │ │ │ │ ├── issues_assignees.go │ │ │ │ ├── issues_assignees_test.go │ │ │ │ ├── issues_comments.go │ │ │ │ ├── issues_comments_test.go │ │ │ │ ├── issues_events.go │ │ │ │ ├── issues_events_test.go │ │ │ │ ├── issues_labels.go │ │ │ │ ├── issues_labels_test.go │ │ │ │ ├── issues_milestones.go │ │ │ │ ├── issues_milestones_test.go │ │ │ │ ├── issues_test.go │ │ │ │ ├── issues_timeline.go │ │ │ │ ├── issues_timeline_test.go │ │ │ │ ├── licenses.go │ │ │ │ ├── licenses_test.go │ │ │ │ ├── messages.go │ │ │ │ ├── messages_test.go │ │ │ │ ├── migrations.go │ │ │ │ ├── migrations_source_import.go │ │ │ │ ├── migrations_source_import_test.go │ │ │ │ ├── migrations_test.go │ │ │ │ ├── misc.go │ │ │ │ ├── misc_test.go │ │ │ │ ├── orgs.go │ │ │ │ ├── orgs_hooks.go │ │ │ │ ├── orgs_hooks_test.go │ │ │ │ ├── orgs_members.go │ │ │ │ ├── orgs_members_test.go │ │ │ │ ├── orgs_outside_collaborators.go │ │ │ │ ├── orgs_outside_collaborators_test.go │ │ │ │ ├── orgs_projects.go │ │ │ │ ├── orgs_projects_test.go │ │ │ │ ├── orgs_teams.go │ │ │ │ ├── orgs_teams_test.go │ │ │ │ ├── orgs_test.go │ │ │ │ ├── orgs_users_blocking.go │ │ │ │ ├── orgs_users_blocking_test.go │ │ │ │ ├── projects.go │ │ │ │ ├── projects_test.go │ │ │ │ ├── pulls.go │ │ │ │ ├── pulls_comments.go │ │ │ │ ├── pulls_comments_test.go │ │ │ │ ├── pulls_reviewers.go │ │ │ │ ├── pulls_reviewers_test.go │ │ │ │ ├── pulls_reviews.go │ │ │ │ ├── pulls_reviews_test.go │ │ │ │ ├── pulls_test.go │ │ │ │ ├── reactions.go │ │ │ │ ├── reactions_test.go │ │ │ │ ├── repos.go │ │ │ │ ├── repos_collaborators.go │ │ │ │ ├── repos_collaborators_test.go │ │ │ │ ├── repos_comments.go │ │ │ │ ├── repos_comments_test.go │ │ │ │ ├── repos_commits.go │ │ │ │ ├── repos_commits_test.go │ │ │ │ ├── repos_community_health.go │ │ │ │ ├── repos_community_health_test.go │ │ │ │ ├── repos_contents.go │ │ │ │ ├── repos_contents_test.go │ │ │ │ ├── repos_deployments.go │ │ │ │ ├── repos_deployments_test.go │ │ │ │ ├── repos_forks.go │ │ │ │ ├── repos_forks_test.go │ │ │ │ ├── repos_hooks.go │ │ │ │ ├── repos_hooks_test.go │ │ │ │ ├── repos_invitations.go │ │ │ │ ├── repos_invitations_test.go │ │ │ │ ├── repos_keys.go │ │ │ │ ├── repos_keys_test.go │ │ │ │ ├── repos_merging.go │ │ │ │ ├── repos_merging_test.go │ │ │ │ ├── repos_pages.go │ │ │ │ ├── repos_pages_test.go │ │ │ │ ├── repos_projects.go │ │ │ │ ├── repos_projects_test.go │ │ │ │ ├── repos_releases.go │ │ │ │ ├── repos_releases_test.go │ │ │ │ ├── repos_stats.go │ │ │ │ ├── repos_stats_test.go │ │ │ │ ├── repos_statuses.go │ │ │ │ ├── repos_statuses_test.go │ │ │ │ ├── repos_test.go │ │ │ │ ├── repos_traffic.go │ │ │ │ ├── repos_traffic_test.go │ │ │ │ ├── search.go │ │ │ │ ├── search_test.go │ │ │ │ ├── strings.go │ │ │ │ ├── strings_test.go │ │ │ │ ├── teams.go │ │ │ │ ├── teams_discussion_comments.go │ │ │ │ ├── teams_discussion_comments_test.go │ │ │ │ ├── teams_discussions.go │ │ │ │ ├── teams_discussions_test.go │ │ │ │ ├── timestamp.go │ │ │ │ ├── timestamp_test.go │ │ │ │ ├── users.go │ │ │ │ ├── users_administration.go │ │ │ │ ├── users_administration_test.go │ │ │ │ ├── users_blocking.go │ │ │ │ ├── users_blocking_test.go │ │ │ │ ├── users_emails.go │ │ │ │ ├── users_emails_test.go │ │ │ │ ├── users_followers.go │ │ │ │ ├── users_followers_test.go │ │ │ │ ├── users_gpg_keys.go │ │ │ │ ├── users_gpg_keys_test.go │ │ │ │ ├── users_keys.go │ │ │ │ ├── users_keys_test.go │ │ │ │ ├── users_test.go │ │ │ │ ├── with_appengine.go │ │ │ │ └── without_appengine.go │ │ └── go-querystring │ │ │ └── query │ │ │ ├── encode.go │ │ │ └── encode_test.go │ ├── gorilla │ │ ├── context │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── context.go │ │ │ ├── context_test.go │ │ │ └── doc.go │ │ └── mux │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── bench_test.go │ │ │ ├── doc.go │ │ │ ├── mux.go │ │ │ ├── mux_test.go │ │ │ ├── old_test.go │ │ │ ├── regexp.go │ │ │ └── route.go │ ├── gotestyourself │ │ └── gotestyourself │ │ │ ├── LICENSE │ │ │ ├── internal │ │ │ ├── format │ │ │ │ └── format.go │ │ │ └── source │ │ │ │ └── source.go │ │ │ └── skip │ │ │ └── skip.go │ ├── honeybadger-io │ │ └── honeybadger-go │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── buffered_worker.go │ │ │ ├── client.go │ │ │ ├── client_test.go │ │ │ ├── configuration.go │ │ │ ├── configuration_test.go │ │ │ ├── context.go │ │ │ ├── context_test.go │ │ │ ├── error.go │ │ │ ├── honeybadger.go │ │ │ ├── honeybadger_test.go │ │ │ ├── notice.go │ │ │ ├── notice_test.go │ │ │ ├── server.go │ │ │ └── worker.go │ ├── jmespath │ │ └── go-jmespath │ │ │ ├── LICENSE │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── api.go │ │ │ ├── api_test.go │ │ │ ├── astnodetype_string.go │ │ │ ├── compliance_test.go │ │ │ ├── functions.go │ │ │ ├── interpreter.go │ │ │ ├── interpreter_test.go │ │ │ ├── lexer.go │ │ │ ├── lexer_test.go │ │ │ ├── parser.go │ │ │ ├── parser_test.go │ │ │ ├── toktype_string.go │ │ │ ├── util.go │ │ │ └── util_test.go │ ├── jmoiron │ │ └── sqlx │ │ │ ├── .gitignore │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── bind.go │ │ │ ├── doc.go │ │ │ ├── named.go │ │ │ ├── reflectx │ │ │ ├── README.md │ │ │ └── reflect.go │ │ │ ├── sqlx.go │ │ │ └── types │ │ │ ├── README.md │ │ │ └── types.go │ ├── lib │ │ └── pq │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── CONTRIBUTING.md │ │ │ ├── LICENSE.md │ │ │ ├── README.md │ │ │ ├── buf.go │ │ │ ├── certs │ │ │ ├── README │ │ │ ├── postgresql.crt │ │ │ ├── postgresql.key │ │ │ ├── root.crt │ │ │ ├── server.crt │ │ │ └── server.key │ │ │ ├── conn.go │ │ │ ├── copy.go │ │ │ ├── doc.go │ │ │ ├── encode.go │ │ │ ├── error.go │ │ │ ├── hstore │ │ │ └── hstore.go │ │ │ ├── listen_example │ │ │ └── doc.go │ │ │ ├── notify.go │ │ │ ├── oid │ │ │ ├── doc.go │ │ │ ├── gen.go │ │ │ └── types.go │ │ │ ├── url.go │ │ │ ├── user_posix.go │ │ │ └── user_windows.go │ ├── mattn │ │ ├── go-runewidth │ │ │ ├── LICENSE │ │ │ ├── README.mkd │ │ │ ├── runewidth.go │ │ │ ├── runewidth_js.go │ │ │ ├── runewidth_posix.go │ │ │ ├── runewidth_test.go │ │ │ └── runewidth_windows.go │ │ └── go-sqlite3 │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── backup.go │ │ │ ├── backup_test.go │ │ │ ├── callback.go │ │ │ ├── callback_test.go │ │ │ ├── doc.go │ │ │ ├── error.go │ │ │ ├── error_test.go │ │ │ ├── sqlite3-binding.c │ │ │ ├── sqlite3-binding.h │ │ │ ├── sqlite3.go │ │ │ ├── sqlite3_context.go │ │ │ ├── sqlite3_fts3_test.go │ │ │ ├── sqlite3_fts5.go │ │ │ ├── sqlite3_go18.go │ │ │ ├── sqlite3_go18_test.go │ │ │ ├── sqlite3_icu.go │ │ │ ├── sqlite3_json1.go │ │ │ ├── sqlite3_libsqlite3.go │ │ │ ├── sqlite3_load_extension.go │ │ │ ├── sqlite3_omit_load_extension.go │ │ │ ├── sqlite3_other.go │ │ │ ├── sqlite3_test.go │ │ │ ├── sqlite3_test │ │ │ └── sqltest.go │ │ │ ├── sqlite3_trace.go │ │ │ ├── sqlite3_trace_test.go │ │ │ ├── sqlite3_type.go │ │ │ ├── sqlite3_vtable.go │ │ │ ├── sqlite3_vtable_test.go │ │ │ ├── sqlite3_windows.go │ │ │ └── sqlite3ext.h │ ├── olekukonko │ │ └── tablewriter │ │ │ ├── LICENCE.md │ │ │ ├── README.md │ │ │ ├── csv.go │ │ │ ├── table.go │ │ │ ├── table_test.go │ │ │ ├── test.csv │ │ │ ├── test_info.csv │ │ │ ├── util.go │ │ │ ├── wrap.go │ │ │ └── wrap_test.go │ ├── opencontainers │ │ ├── go-digest │ │ │ ├── LICENSE.code │ │ │ ├── LICENSE.docs │ │ │ ├── README.md │ │ │ ├── algorithm.go │ │ │ ├── digest.go │ │ │ ├── digester.go │ │ │ ├── doc.go │ │ │ └── verifiers.go │ │ ├── image-spec │ │ │ ├── LICENSE │ │ │ └── specs-go │ │ │ │ ├── v1 │ │ │ │ ├── annotations.go │ │ │ │ ├── config.go │ │ │ │ ├── descriptor.go │ │ │ │ ├── index.go │ │ │ │ ├── layout.go │ │ │ │ ├── manifest.go │ │ │ │ └── mediatype.go │ │ │ │ ├── version.go │ │ │ │ └── versioned.go │ │ ├── runc │ │ │ ├── LICENSE │ │ │ ├── NOTICE │ │ │ └── libcontainer │ │ │ │ ├── system │ │ │ │ ├── linux.go │ │ │ │ ├── proc.go │ │ │ │ ├── syscall_linux_32.go │ │ │ │ ├── syscall_linux_64.go │ │ │ │ ├── sysconfig.go │ │ │ │ ├── sysconfig_notcgo.go │ │ │ │ ├── unsupported.go │ │ │ │ └── xattrs_linux.go │ │ │ │ └── user │ │ │ │ ├── lookup.go │ │ │ │ ├── lookup_unix.go │ │ │ │ ├── lookup_unsupported.go │ │ │ │ └── user.go │ │ └── selinux │ │ │ ├── LICENSE │ │ │ └── go-selinux │ │ │ ├── selinux.go │ │ │ └── xattrs.go │ ├── pkg │ │ └── errors │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── errors.go │ │ │ └── stack.go │ ├── pmezard │ │ └── go-difflib │ │ │ ├── LICENSE │ │ │ └── difflib │ │ │ └── difflib.go │ ├── remind101 │ │ ├── newrelic │ │ │ ├── Dockerfile │ │ │ ├── LICENSE │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── circle.yml │ │ │ ├── newrelic.go │ │ │ ├── newrelic_test.go │ │ │ ├── recorder_newrelic_disabled.go │ │ │ ├── recorder_newrelic_enabled.go │ │ │ ├── reporter_newrelic_disabled.go │ │ │ ├── reporter_newrelic_enabled.go │ │ │ ├── sdk │ │ │ │ └── sdk.go │ │ │ ├── stack.go │ │ │ ├── stack_test.go │ │ │ ├── tracer_newrelic_disabled.go │ │ │ ├── tracer_newrelic_enabled.go │ │ │ └── tx.go │ │ └── pkg │ │ │ ├── logger │ │ │ ├── example_test.go │ │ │ ├── logger.go │ │ │ └── logger_test.go │ │ │ ├── reporter │ │ │ ├── fallback.go │ │ │ ├── fallback_test.go │ │ │ ├── hb2 │ │ │ │ ├── hb2.go │ │ │ │ └── hb2_test.go │ │ │ ├── logger.go │ │ │ ├── logger_test.go │ │ │ ├── multi.go │ │ │ ├── multi_test.go │ │ │ ├── nr │ │ │ │ ├── nr.go │ │ │ │ └── nr_test.go │ │ │ ├── reporter.go │ │ │ ├── reporter_test.go │ │ │ └── util │ │ │ │ └── util.go │ │ │ └── stream │ │ │ ├── http │ │ │ └── http.go │ │ │ ├── stream.go │ │ │ └── stream_test.go │ ├── rubenv │ │ └── sql-migrate │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── README.md │ │ │ ├── doc.go │ │ │ ├── migrate.go │ │ │ ├── sql-migrate │ │ │ ├── command_common.go │ │ │ ├── command_down.go │ │ │ ├── command_redo.go │ │ │ ├── command_status.go │ │ │ ├── command_up.go │ │ │ ├── config.go │ │ │ ├── main.go │ │ │ └── mssql.go │ │ │ ├── sqlparse │ │ │ ├── README.md │ │ │ └── sqlparse.go │ │ │ ├── test-integration │ │ │ ├── dbconfig.yml │ │ │ ├── mysql-flag.sh │ │ │ ├── mysql.sh │ │ │ ├── postgres.sh │ │ │ └── sqlite.sh │ │ │ └── test-migrations │ │ │ ├── 1_initial.sql │ │ │ └── 2_record.sql │ ├── shirou │ │ └── gopsutil │ │ │ ├── common │ │ │ ├── common.go │ │ │ ├── common_darwin.go │ │ │ ├── common_freebsd.go │ │ │ ├── common_test.go │ │ │ └── common_windows.go │ │ │ ├── load │ │ │ ├── load.go │ │ │ ├── load_darwin.go │ │ │ ├── load_freebsd.go │ │ │ ├── load_linux.go │ │ │ ├── load_test.go │ │ │ └── load_windows.go │ │ │ └── mem │ │ │ ├── mem.go │ │ │ ├── mem_darwin.go │ │ │ ├── mem_freebsd.go │ │ │ ├── mem_linux.go │ │ │ ├── mem_test.go │ │ │ └── mem_windows.go │ ├── sirupsen │ │ └── logrus │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── alt_exit.go │ │ │ ├── doc.go │ │ │ ├── entry.go │ │ │ ├── exported.go │ │ │ ├── formatter.go │ │ │ ├── hooks.go │ │ │ ├── json_formatter.go │ │ │ ├── logger.go │ │ │ ├── logrus.go │ │ │ ├── terminal_bsd.go │ │ │ ├── terminal_linux.go │ │ │ ├── text_formatter.go │ │ │ └── writer.go │ ├── stretchr │ │ ├── objx │ │ │ ├── .gitignore │ │ │ ├── LICENSE.md │ │ │ ├── README.md │ │ │ ├── accessors.go │ │ │ ├── accessors_test.go │ │ │ ├── codegen │ │ │ │ ├── array-access.txt │ │ │ │ ├── index.html │ │ │ │ ├── template.txt │ │ │ │ └── types_list.txt │ │ │ ├── constants.go │ │ │ ├── conversions.go │ │ │ ├── conversions_test.go │ │ │ ├── doc.go │ │ │ ├── fixture_test.go │ │ │ ├── map.go │ │ │ ├── map_for_test.go │ │ │ ├── map_test.go │ │ │ ├── mutations.go │ │ │ ├── mutations_test.go │ │ │ ├── security.go │ │ │ ├── security_test.go │ │ │ ├── simple_example_test.go │ │ │ ├── tests.go │ │ │ ├── tests_test.go │ │ │ ├── type_specific_codegen.go │ │ │ ├── type_specific_codegen_test.go │ │ │ ├── value.go │ │ │ └── value_test.go │ │ └── testify │ │ │ ├── LICENSE │ │ │ ├── assert │ │ │ ├── assertions.go │ │ │ ├── assertions_test.go │ │ │ ├── doc.go │ │ │ ├── errors.go │ │ │ ├── forward_assertions.go │ │ │ ├── forward_assertions_test.go │ │ │ ├── http_assertions.go │ │ │ └── http_assertions_test.go │ │ │ ├── mock │ │ │ ├── doc.go │ │ │ ├── mock.go │ │ │ └── mock_test.go │ │ │ └── require │ │ │ ├── doc.go │ │ │ ├── forward_requirements.go │ │ │ ├── forward_requirements_test.go │ │ │ ├── require.go │ │ │ ├── require.go.tmpl │ │ │ ├── require_forward.go │ │ │ ├── require_forward.go.tmpl │ │ │ ├── requirements.go │ │ │ └── requirements_test.go │ └── vaughan0 │ │ └── go-ini │ │ ├── LICENSE │ │ ├── README.md │ │ ├── ini.go │ │ ├── ini_linux_test.go │ │ ├── ini_test.go │ │ └── test.ini ├── golang.org │ └── x │ │ ├── crypto │ │ ├── LICENSE │ │ ├── PATENTS │ │ └── ssh │ │ │ └── terminal │ │ │ ├── terminal.go │ │ │ ├── util.go │ │ │ ├── util_bsd.go │ │ │ ├── util_linux.go │ │ │ ├── util_plan9.go │ │ │ ├── util_solaris.go │ │ │ └── util_windows.go │ │ ├── net │ │ ├── LICENSE │ │ ├── PATENTS │ │ ├── context │ │ │ ├── context.go │ │ │ ├── context_test.go │ │ │ ├── ctxhttp │ │ │ │ ├── ctxhttp.go │ │ │ │ ├── ctxhttp_17_test.go │ │ │ │ ├── ctxhttp_pre17.go │ │ │ │ ├── ctxhttp_pre17_test.go │ │ │ │ └── ctxhttp_test.go │ │ │ └── withtimeout_test.go │ │ ├── http2 │ │ │ ├── Dockerfile │ │ │ ├── Makefile │ │ │ ├── README │ │ │ ├── ciphers.go │ │ │ ├── ciphers_test.go │ │ │ ├── client_conn_pool.go │ │ │ ├── configure_transport.go │ │ │ ├── databuffer.go │ │ │ ├── databuffer_test.go │ │ │ ├── errors.go │ │ │ ├── errors_test.go │ │ │ ├── flow.go │ │ │ ├── flow_test.go │ │ │ ├── frame.go │ │ │ ├── frame_test.go │ │ │ ├── go16.go │ │ │ ├── go17.go │ │ │ ├── go17_not18.go │ │ │ ├── go18.go │ │ │ ├── go18_test.go │ │ │ ├── go19.go │ │ │ ├── go19_test.go │ │ │ ├── gotrack.go │ │ │ ├── gotrack_test.go │ │ │ ├── headermap.go │ │ │ ├── hpack │ │ │ │ ├── encode.go │ │ │ │ ├── encode_test.go │ │ │ │ ├── hpack.go │ │ │ │ ├── hpack_test.go │ │ │ │ ├── huffman.go │ │ │ │ ├── tables.go │ │ │ │ └── tables_test.go │ │ │ ├── http2.go │ │ │ ├── http2_test.go │ │ │ ├── not_go16.go │ │ │ ├── not_go17.go │ │ │ ├── not_go18.go │ │ │ ├── not_go19.go │ │ │ ├── pipe.go │ │ │ ├── pipe_test.go │ │ │ ├── server.go │ │ │ ├── server_push_test.go │ │ │ ├── server_test.go │ │ │ ├── testdata │ │ │ │ └── draft-ietf-httpbis-http2.xml │ │ │ ├── transport.go │ │ │ ├── transport_test.go │ │ │ ├── write.go │ │ │ ├── writesched.go │ │ │ ├── writesched_priority.go │ │ │ ├── writesched_priority_test.go │ │ │ ├── writesched_random.go │ │ │ ├── writesched_random_test.go │ │ │ ├── writesched_test.go │ │ │ └── z_spec_test.go │ │ ├── idna │ │ │ ├── example_test.go │ │ │ ├── idna.go │ │ │ ├── idna_test.go │ │ │ ├── punycode.go │ │ │ ├── punycode_test.go │ │ │ ├── tables.go │ │ │ ├── trie.go │ │ │ └── trieval.go │ │ └── lex │ │ │ └── httplex │ │ │ ├── httplex.go │ │ │ └── httplex_test.go │ │ ├── oauth2 │ │ ├── .travis.yml │ │ ├── AUTHORS │ │ ├── CONTRIBUTING.md │ │ ├── CONTRIBUTORS │ │ ├── LICENSE │ │ ├── README.md │ │ ├── client_appengine.go │ │ ├── clientcredentials │ │ │ ├── clientcredentials.go │ │ │ └── clientcredentials_test.go │ │ ├── example_test.go │ │ ├── facebook │ │ │ └── facebook.go │ │ ├── github │ │ │ └── github.go │ │ ├── google │ │ │ ├── appengine.go │ │ │ ├── appengine_hook.go │ │ │ ├── default.go │ │ │ ├── example_test.go │ │ │ ├── google.go │ │ │ ├── google_test.go │ │ │ ├── sdk.go │ │ │ ├── sdk_test.go │ │ │ └── testdata │ │ │ │ └── gcloud │ │ │ │ ├── credentials │ │ │ │ └── properties │ │ ├── internal │ │ │ ├── oauth2.go │ │ │ ├── oauth2_test.go │ │ │ ├── token.go │ │ │ ├── token_test.go │ │ │ └── transport.go │ │ ├── jws │ │ │ └── jws.go │ │ ├── jwt │ │ │ ├── example_test.go │ │ │ ├── jwt.go │ │ │ └── jwt_test.go │ │ ├── linkedin │ │ │ └── linkedin.go │ │ ├── oauth2.go │ │ ├── oauth2_test.go │ │ ├── odnoklassniki │ │ │ └── odnoklassniki.go │ │ ├── paypal │ │ │ └── paypal.go │ │ ├── token.go │ │ ├── token_test.go │ │ ├── transport.go │ │ ├── transport_test.go │ │ └── vk │ │ │ └── vk.go │ │ ├── sys │ │ ├── LICENSE │ │ ├── PATENTS │ │ ├── unix │ │ │ ├── README.md │ │ │ ├── asm_darwin_386.s │ │ │ ├── asm_darwin_amd64.s │ │ │ ├── asm_darwin_arm.s │ │ │ ├── asm_darwin_arm64.s │ │ │ ├── asm_dragonfly_amd64.s │ │ │ ├── asm_freebsd_386.s │ │ │ ├── asm_freebsd_amd64.s │ │ │ ├── asm_freebsd_arm.s │ │ │ ├── asm_linux_386.s │ │ │ ├── asm_linux_amd64.s │ │ │ ├── asm_linux_arm.s │ │ │ ├── asm_linux_arm64.s │ │ │ ├── asm_linux_mips64x.s │ │ │ ├── asm_linux_mipsx.s │ │ │ ├── asm_linux_ppc64x.s │ │ │ ├── asm_linux_s390x.s │ │ │ ├── asm_netbsd_386.s │ │ │ ├── asm_netbsd_amd64.s │ │ │ ├── asm_netbsd_arm.s │ │ │ ├── asm_openbsd_386.s │ │ │ ├── asm_openbsd_amd64.s │ │ │ ├── asm_openbsd_arm.s │ │ │ ├── asm_solaris_amd64.s │ │ │ ├── bluetooth_linux.go │ │ │ ├── cap_freebsd.go │ │ │ ├── constants.go │ │ │ ├── dev_darwin.go │ │ │ ├── dev_dragonfly.go │ │ │ ├── dev_freebsd.go │ │ │ ├── dev_linux.go │ │ │ ├── dev_netbsd.go │ │ │ ├── dev_openbsd.go │ │ │ ├── dirent.go │ │ │ ├── endian_big.go │ │ │ ├── endian_little.go │ │ │ ├── env_unix.go │ │ │ ├── env_unset.go │ │ │ ├── errors_freebsd_386.go │ │ │ ├── errors_freebsd_amd64.go │ │ │ ├── errors_freebsd_arm.go │ │ │ ├── file_unix.go │ │ │ ├── flock.go │ │ │ ├── flock_linux_32bit.go │ │ │ ├── gccgo.go │ │ │ ├── gccgo_c.c │ │ │ ├── gccgo_linux_amd64.go │ │ │ ├── openbsd_pledge.go │ │ │ ├── pagesize_unix.go │ │ │ ├── race.go │ │ │ ├── race0.go │ │ │ ├── sockcmsg_linux.go │ │ │ ├── sockcmsg_unix.go │ │ │ ├── str.go │ │ │ ├── syscall.go │ │ │ ├── syscall_bsd.go │ │ │ ├── syscall_darwin.go │ │ │ ├── syscall_darwin_386.go │ │ │ ├── syscall_darwin_amd64.go │ │ │ ├── syscall_darwin_arm.go │ │ │ ├── syscall_darwin_arm64.go │ │ │ ├── syscall_dragonfly.go │ │ │ ├── syscall_dragonfly_amd64.go │ │ │ ├── syscall_freebsd.go │ │ │ ├── syscall_freebsd_386.go │ │ │ ├── syscall_freebsd_amd64.go │ │ │ ├── syscall_freebsd_arm.go │ │ │ ├── syscall_linux.go │ │ │ ├── syscall_linux_386.go │ │ │ ├── syscall_linux_amd64.go │ │ │ ├── syscall_linux_amd64_gc.go │ │ │ ├── syscall_linux_arm.go │ │ │ ├── syscall_linux_arm64.go │ │ │ ├── syscall_linux_mips64x.go │ │ │ ├── syscall_linux_mipsx.go │ │ │ ├── syscall_linux_ppc64x.go │ │ │ ├── syscall_linux_s390x.go │ │ │ ├── syscall_linux_sparc64.go │ │ │ ├── syscall_netbsd.go │ │ │ ├── syscall_netbsd_386.go │ │ │ ├── syscall_netbsd_amd64.go │ │ │ ├── syscall_netbsd_arm.go │ │ │ ├── syscall_no_getwd.go │ │ │ ├── syscall_openbsd.go │ │ │ ├── syscall_openbsd_386.go │ │ │ ├── syscall_openbsd_amd64.go │ │ │ ├── syscall_openbsd_arm.go │ │ │ ├── syscall_solaris.go │ │ │ ├── syscall_solaris_amd64.go │ │ │ ├── syscall_unix.go │ │ │ ├── syscall_unix_gc.go │ │ │ ├── timestruct.go │ │ │ ├── zerrors_darwin_386.go │ │ │ ├── zerrors_darwin_amd64.go │ │ │ ├── zerrors_darwin_arm.go │ │ │ ├── zerrors_darwin_arm64.go │ │ │ ├── zerrors_dragonfly_amd64.go │ │ │ ├── zerrors_freebsd_386.go │ │ │ ├── zerrors_freebsd_amd64.go │ │ │ ├── zerrors_freebsd_arm.go │ │ │ ├── zerrors_linux_386.go │ │ │ ├── zerrors_linux_amd64.go │ │ │ ├── zerrors_linux_arm.go │ │ │ ├── zerrors_linux_arm64.go │ │ │ ├── zerrors_linux_mips.go │ │ │ ├── zerrors_linux_mips64.go │ │ │ ├── zerrors_linux_mips64le.go │ │ │ ├── zerrors_linux_mipsle.go │ │ │ ├── zerrors_linux_ppc64.go │ │ │ ├── zerrors_linux_ppc64le.go │ │ │ ├── zerrors_linux_s390x.go │ │ │ ├── zerrors_linux_sparc64.go │ │ │ ├── zerrors_netbsd_386.go │ │ │ ├── zerrors_netbsd_amd64.go │ │ │ ├── zerrors_netbsd_arm.go │ │ │ ├── zerrors_openbsd_386.go │ │ │ ├── zerrors_openbsd_amd64.go │ │ │ ├── zerrors_openbsd_arm.go │ │ │ ├── zerrors_solaris_amd64.go │ │ │ ├── zptrace386_linux.go │ │ │ ├── zptracearm_linux.go │ │ │ ├── zptracemips_linux.go │ │ │ ├── zptracemipsle_linux.go │ │ │ ├── zsyscall_darwin_386.go │ │ │ ├── zsyscall_darwin_amd64.go │ │ │ ├── zsyscall_darwin_arm.go │ │ │ ├── zsyscall_darwin_arm64.go │ │ │ ├── zsyscall_dragonfly_amd64.go │ │ │ ├── zsyscall_freebsd_386.go │ │ │ ├── zsyscall_freebsd_amd64.go │ │ │ ├── zsyscall_freebsd_arm.go │ │ │ ├── zsyscall_linux_386.go │ │ │ ├── zsyscall_linux_amd64.go │ │ │ ├── zsyscall_linux_arm.go │ │ │ ├── zsyscall_linux_arm64.go │ │ │ ├── zsyscall_linux_mips.go │ │ │ ├── zsyscall_linux_mips64.go │ │ │ ├── zsyscall_linux_mips64le.go │ │ │ ├── zsyscall_linux_mipsle.go │ │ │ ├── zsyscall_linux_ppc64.go │ │ │ ├── zsyscall_linux_ppc64le.go │ │ │ ├── zsyscall_linux_s390x.go │ │ │ ├── zsyscall_linux_sparc64.go │ │ │ ├── zsyscall_netbsd_386.go │ │ │ ├── zsyscall_netbsd_amd64.go │ │ │ ├── zsyscall_netbsd_arm.go │ │ │ ├── zsyscall_openbsd_386.go │ │ │ ├── zsyscall_openbsd_amd64.go │ │ │ ├── zsyscall_openbsd_arm.go │ │ │ ├── zsyscall_solaris_amd64.go │ │ │ ├── zsysctl_openbsd_386.go │ │ │ ├── zsysctl_openbsd_amd64.go │ │ │ ├── zsysctl_openbsd_arm.go │ │ │ ├── zsysnum_darwin_386.go │ │ │ ├── zsysnum_darwin_amd64.go │ │ │ ├── zsysnum_darwin_arm.go │ │ │ ├── zsysnum_darwin_arm64.go │ │ │ ├── zsysnum_dragonfly_amd64.go │ │ │ ├── zsysnum_freebsd_386.go │ │ │ ├── zsysnum_freebsd_amd64.go │ │ │ ├── zsysnum_freebsd_arm.go │ │ │ ├── zsysnum_linux_386.go │ │ │ ├── zsysnum_linux_amd64.go │ │ │ ├── zsysnum_linux_arm.go │ │ │ ├── zsysnum_linux_arm64.go │ │ │ ├── zsysnum_linux_mips.go │ │ │ ├── zsysnum_linux_mips64.go │ │ │ ├── zsysnum_linux_mips64le.go │ │ │ ├── zsysnum_linux_mipsle.go │ │ │ ├── zsysnum_linux_ppc64.go │ │ │ ├── zsysnum_linux_ppc64le.go │ │ │ ├── zsysnum_linux_s390x.go │ │ │ ├── zsysnum_linux_sparc64.go │ │ │ ├── zsysnum_netbsd_386.go │ │ │ ├── zsysnum_netbsd_amd64.go │ │ │ ├── zsysnum_netbsd_arm.go │ │ │ ├── zsysnum_openbsd_386.go │ │ │ ├── zsysnum_openbsd_amd64.go │ │ │ ├── zsysnum_openbsd_arm.go │ │ │ ├── zsysnum_solaris_amd64.go │ │ │ ├── ztypes_darwin_386.go │ │ │ ├── ztypes_darwin_amd64.go │ │ │ ├── ztypes_darwin_arm.go │ │ │ ├── ztypes_darwin_arm64.go │ │ │ ├── ztypes_dragonfly_amd64.go │ │ │ ├── ztypes_freebsd_386.go │ │ │ ├── ztypes_freebsd_amd64.go │ │ │ ├── ztypes_freebsd_arm.go │ │ │ ├── ztypes_linux_386.go │ │ │ ├── ztypes_linux_amd64.go │ │ │ ├── ztypes_linux_arm.go │ │ │ ├── ztypes_linux_arm64.go │ │ │ ├── ztypes_linux_mips.go │ │ │ ├── ztypes_linux_mips64.go │ │ │ ├── ztypes_linux_mips64le.go │ │ │ ├── ztypes_linux_mipsle.go │ │ │ ├── ztypes_linux_ppc64.go │ │ │ ├── ztypes_linux_ppc64le.go │ │ │ ├── ztypes_linux_s390x.go │ │ │ ├── ztypes_linux_sparc64.go │ │ │ ├── ztypes_netbsd_386.go │ │ │ ├── ztypes_netbsd_amd64.go │ │ │ ├── ztypes_netbsd_arm.go │ │ │ ├── ztypes_openbsd_386.go │ │ │ ├── ztypes_openbsd_amd64.go │ │ │ ├── ztypes_openbsd_arm.go │ │ │ └── ztypes_solaris_amd64.go │ │ └── windows │ │ │ ├── asm_windows_386.s │ │ │ ├── asm_windows_amd64.s │ │ │ ├── dll_windows.go │ │ │ ├── env_unset.go │ │ │ ├── env_windows.go │ │ │ ├── eventlog.go │ │ │ ├── exec_windows.go │ │ │ ├── memory_windows.go │ │ │ ├── mksyscall.go │ │ │ ├── race.go │ │ │ ├── race0.go │ │ │ ├── security_windows.go │ │ │ ├── service.go │ │ │ ├── str.go │ │ │ ├── syscall.go │ │ │ ├── syscall_windows.go │ │ │ ├── types_windows.go │ │ │ ├── types_windows_386.go │ │ │ ├── types_windows_amd64.go │ │ │ └── zsyscall_windows.go │ │ └── text │ │ ├── LICENSE │ │ ├── PATENTS │ │ ├── internal │ │ ├── gen │ │ │ ├── code.go │ │ │ └── gen.go │ │ ├── testtext │ │ │ ├── codesize.go │ │ │ ├── flag.go │ │ │ ├── gc.go │ │ │ ├── gccgo.go │ │ │ ├── go1_6.go │ │ │ ├── go1_7.go │ │ │ └── text.go │ │ └── ucd │ │ │ ├── example_test.go │ │ │ ├── ucd.go │ │ │ └── ucd_test.go │ │ ├── secure │ │ └── bidirule │ │ │ ├── bench_test.go │ │ │ ├── bidirule.go │ │ │ └── bidirule_test.go │ │ ├── transform │ │ ├── examples_test.go │ │ ├── transform.go │ │ └── transform_test.go │ │ └── unicode │ │ ├── bidi │ │ ├── bidi.go │ │ ├── bracket.go │ │ ├── core.go │ │ ├── core_test.go │ │ ├── gen.go │ │ ├── gen_ranges.go │ │ ├── gen_trieval.go │ │ ├── prop.go │ │ ├── ranges_test.go │ │ ├── tables.go │ │ ├── tables_test.go │ │ └── trieval.go │ │ ├── cldr │ │ ├── base.go │ │ ├── cldr.go │ │ ├── cldr_test.go │ │ ├── collate.go │ │ ├── collate_test.go │ │ ├── data_test.go │ │ ├── decode.go │ │ ├── examples_test.go │ │ ├── makexml.go │ │ ├── resolve.go │ │ ├── resolve_test.go │ │ ├── slice.go │ │ ├── slice_test.go │ │ └── xml.go │ │ ├── norm │ │ ├── composition.go │ │ ├── composition_test.go │ │ ├── example_iter_test.go │ │ ├── example_test.go │ │ ├── forminfo.go │ │ ├── forminfo_test.go │ │ ├── input.go │ │ ├── iter.go │ │ ├── iter_test.go │ │ ├── maketables.go │ │ ├── norm_test.go │ │ ├── normalize.go │ │ ├── normalize_test.go │ │ ├── readwriter.go │ │ ├── readwriter_test.go │ │ ├── tables.go │ │ ├── transform.go │ │ ├── transform_test.go │ │ ├── trie.go │ │ ├── triegen.go │ │ └── ucd_test.go │ │ └── rangetable │ │ ├── gen.go │ │ ├── merge.go │ │ ├── merge_test.go │ │ ├── rangetable.go │ │ ├── rangetable_test.go │ │ └── tables.go ├── gopkg.in │ └── gorp.v1 │ │ ├── .gitignore │ │ ├── .travis.yml │ │ ├── LICENSE │ │ ├── Makefile │ │ ├── README.md │ │ ├── dialect.go │ │ ├── errors.go │ │ ├── gorp.go │ │ └── test_all.sh └── vendor.json └── worker ├── builder.go ├── builder_test.go ├── worker.go └── worker_test.go /.env.sample: -------------------------------------------------------------------------------- 1 | GITHUB_TOKEN= 2 | GITHUB_SECRET= 3 | DRY=true 4 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .env* 2 | build 3 | .vagrant 4 | scripts 5 | -------------------------------------------------------------------------------- /Dockerfile: -------------------------------------------------------------------------------- 1 | FROM golang:1.7.6 2 | MAINTAINER Eric Holmes 3 | 4 | ENV DOCKER_HOST unix:///var/run/docker.sock 5 | 6 | ADD . /go/src/github.com/remind101/conveyor 7 | WORKDIR /go/src/github.com/remind101/conveyor 8 | RUN go install ./cmd/conveyor 9 | 10 | ENTRYPOINT ["/go/bin/conveyor"] 11 | -------------------------------------------------------------------------------- /Gemfile: -------------------------------------------------------------------------------- 1 | source 'https://rubygems.org' 2 | 3 | gem 'prmd' 4 | -------------------------------------------------------------------------------- /Gemfile.lock: -------------------------------------------------------------------------------- 1 | GEM 2 | remote: https://rubygems.org/ 3 | specs: 4 | erubis (2.7.0) 5 | json_schema (0.12.1) 6 | prmd (0.11.4) 7 | erubis (~> 2.7) 8 | json_schema (~> 0.3, >= 0.3.1) 9 | 10 | PLATFORMS 11 | ruby 12 | 13 | DEPENDENCIES 14 | prmd 15 | 16 | BUNDLED WITH 17 | 1.10.4 18 | -------------------------------------------------------------------------------- /Godeps/Readme: -------------------------------------------------------------------------------- 1 | This directory tree is generated automatically by godep. 2 | 3 | Please do not edit. 4 | 5 | See https://github.com/tools/godep for more information. 6 | -------------------------------------------------------------------------------- /Godeps/_workspace/.gitignore: -------------------------------------------------------------------------------- 1 | /pkg 2 | /bin 3 | -------------------------------------------------------------------------------- /Vagrantfile: -------------------------------------------------------------------------------- 1 | # -*- mode: ruby -*- 2 | # vi: set ft=ruby : 3 | 4 | Vagrant.configure(2) do |config| 5 | config.vm.box = "ubuntu/trusty64" 6 | config.vm.provision "shell", path: "./bin/install_ansible" 7 | config.vm.provision "shell", inline: <<-SCRIPT 8 | sudo rm -rf /etc/ansible/playbook 9 | sudo mkdir /etc/ansible/playbook 10 | echo "127.0.0.1 ansible_connection=local" > /etc/ansible/hosts 11 | sudo chown -R vagrant:vagrant /etc/ansible 12 | SCRIPT 13 | config.vm.provision "file", source: "roles", destination: "/etc/ansible" 14 | config.vm.provision "file", source: "site.yml", destination: "/etc/ansible/playbook/site.yml" 15 | config.vm.provision "shell", path: "./bin/ansible", keep_color: true 16 | end 17 | -------------------------------------------------------------------------------- /bin/ansible: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | echo "Starting ansible" 4 | sudo PYTHONUNBUFFERED=1 ANSIBLE_FORCE_COLOR=true ansible-playbook \ 5 | -c local \ 6 | /etc/ansible/playbook/site.yml 7 | -------------------------------------------------------------------------------- /bin/install_ansible: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | # Initial setup script - gets us ansible 1.7 in trusty 3 | 4 | echo "deb http://us-east-1.ec2.archive.ubuntu.com/ubuntu/ trusty-backports main restricted universe multiverse" > /etc/apt/sources.list.d/trusty-backports.list 5 | 6 | cat >>/etc/apt/preferences.d/trusty-backports< 4 | 5 | Permission to use, copy, modify, and distribute this software for any 6 | purpose with or without fee is hereby granted, provided that the above 7 | copyright notice and this permission notice appear in all copies. 8 | 9 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10 | WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11 | MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12 | ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 | OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 | -------------------------------------------------------------------------------- /vendor/github.com/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/docker/docker/NOTICE: -------------------------------------------------------------------------------- 1 | Docker 2 | Copyright 2012-2017 Docker, Inc. 3 | 4 | This product includes software developed at Docker, Inc. (https://www.docker.com). 5 | 6 | This product contains software (https://github.com/kr/pty) developed 7 | by Keith Rarick, licensed under the MIT License. 8 | 9 | The following is courtesy of our legal counsel: 10 | 11 | 12 | Use and transfer of Docker may be subject to certain restrictions by the 13 | United States and other governments. 14 | It is your responsibility to ensure that your use and/or transfer does not 15 | violate applicable laws. 16 | 17 | For more information, please see https://www.bis.doc.gov 18 | 19 | See also https://www.apache.org/dev/crypto.html and/or seek legal counsel. 20 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/auth.go: -------------------------------------------------------------------------------- 1 | package types 2 | 3 | // AuthConfig contains authorization information for connecting to a Registry 4 | type AuthConfig struct { 5 | Username string `json:"username,omitempty"` 6 | Password string `json:"password,omitempty"` 7 | Auth string `json:"auth,omitempty"` 8 | 9 | // Email is an optional value associated with the username. 10 | // This field is deprecated and will be removed in a later 11 | // version of docker. 12 | Email string `json:"email,omitempty"` 13 | 14 | ServerAddress string `json:"serveraddress,omitempty"` 15 | 16 | // IdentityToken is used to authenticate the user and get 17 | // an access token for the registry. 18 | IdentityToken string `json:"identitytoken,omitempty"` 19 | 20 | // RegistryToken is a bearer token to be sent to a registry 21 | RegistryToken string `json:"registrytoken,omitempty"` 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/blkiodev/blkio.go: -------------------------------------------------------------------------------- 1 | package blkiodev 2 | 3 | import "fmt" 4 | 5 | // WeightDevice is a structure that holds device:weight pair 6 | type WeightDevice struct { 7 | Path string 8 | Weight uint16 9 | } 10 | 11 | func (w *WeightDevice) String() string { 12 | return fmt.Sprintf("%s:%d", w.Path, w.Weight) 13 | } 14 | 15 | // ThrottleDevice is a structure that holds device:rate_per_second pair 16 | type ThrottleDevice struct { 17 | Path string 18 | Rate uint64 19 | } 20 | 21 | func (t *ThrottleDevice) String() string { 22 | return fmt.Sprintf("%s:%d", t.Path, t.Rate) 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/container/container_changes.go: -------------------------------------------------------------------------------- 1 | package container 2 | 3 | // ---------------------------------------------------------------------------- 4 | // DO NOT EDIT THIS FILE 5 | // This file was generated by `swagger generate operation` 6 | // 7 | // See hack/generate-swagger-api.sh 8 | // ---------------------------------------------------------------------------- 9 | 10 | // ContainerChangeResponseItem change item in response to ContainerChanges operation 11 | // swagger:model ContainerChangeResponseItem 12 | type ContainerChangeResponseItem struct { 13 | 14 | // Kind of change 15 | // Required: true 16 | Kind uint8 `json:"Kind"` 17 | 18 | // Path to file that has changed 19 | // Required: true 20 | Path string `json:"Path"` 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/container/container_create.go: -------------------------------------------------------------------------------- 1 | package container 2 | 3 | // ---------------------------------------------------------------------------- 4 | // DO NOT EDIT THIS FILE 5 | // This file was generated by `swagger generate operation` 6 | // 7 | // See hack/generate-swagger-api.sh 8 | // ---------------------------------------------------------------------------- 9 | 10 | // ContainerCreateCreatedBody OK response to ContainerCreate operation 11 | // swagger:model ContainerCreateCreatedBody 12 | type ContainerCreateCreatedBody struct { 13 | 14 | // The ID of the created container 15 | // Required: true 16 | ID string `json:"Id"` 17 | 18 | // Warnings encountered when creating the container 19 | // Required: true 20 | Warnings []string `json:"Warnings"` 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/container/container_top.go: -------------------------------------------------------------------------------- 1 | package container 2 | 3 | // ---------------------------------------------------------------------------- 4 | // DO NOT EDIT THIS FILE 5 | // This file was generated by `swagger generate operation` 6 | // 7 | // See hack/generate-swagger-api.sh 8 | // ---------------------------------------------------------------------------- 9 | 10 | // ContainerTopOKBody OK response to ContainerTop operation 11 | // swagger:model ContainerTopOKBody 12 | type ContainerTopOKBody struct { 13 | 14 | // Each process running in the container, where each is process is an array of values corresponding to the titles 15 | // Required: true 16 | Processes [][]string `json:"Processes"` 17 | 18 | // The ps column titles 19 | // Required: true 20 | Titles []string `json:"Titles"` 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/container/container_update.go: -------------------------------------------------------------------------------- 1 | package container 2 | 3 | // ---------------------------------------------------------------------------- 4 | // DO NOT EDIT THIS FILE 5 | // This file was generated by `swagger generate operation` 6 | // 7 | // See hack/generate-swagger-api.sh 8 | // ---------------------------------------------------------------------------- 9 | 10 | // ContainerUpdateOKBody OK response to ContainerUpdate operation 11 | // swagger:model ContainerUpdateOKBody 12 | type ContainerUpdateOKBody struct { 13 | 14 | // warnings 15 | // Required: true 16 | Warnings []string `json:"Warnings"` 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/error_response.go: -------------------------------------------------------------------------------- 1 | package types 2 | 3 | // This file was generated by the swagger tool. 4 | // Editing this file might prove futile when you re-run the swagger generate command 5 | 6 | // ErrorResponse Represents an error. 7 | // swagger:model ErrorResponse 8 | type ErrorResponse struct { 9 | 10 | // The error message. 11 | // Required: true 12 | Message string `json:"message"` 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/filters/example_test.go: -------------------------------------------------------------------------------- 1 | package filters 2 | 3 | func ExampleArgs_MatchKVList() { 4 | args := NewArgs( 5 | Arg("label", "image=foo"), 6 | Arg("label", "state=running")) 7 | 8 | // returns true because there are no values for bogus 9 | args.MatchKVList("bogus", nil) 10 | 11 | // returns false because there are no sources 12 | args.MatchKVList("label", nil) 13 | 14 | // returns true because all sources are matched 15 | args.MatchKVList("label", map[string]string{ 16 | "image": "foo", 17 | "state": "running", 18 | }) 19 | 20 | // returns false because the values do not match 21 | args.MatchKVList("label", map[string]string{ 22 | "image": "other", 23 | }) 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/graph_driver_data.go: -------------------------------------------------------------------------------- 1 | package types 2 | 3 | // This file was generated by the swagger tool. 4 | // Editing this file might prove futile when you re-run the swagger generate command 5 | 6 | // GraphDriverData Information about a container's graph driver. 7 | // swagger:model GraphDriverData 8 | type GraphDriverData struct { 9 | 10 | // data 11 | // Required: true 12 | Data map[string]string `json:"Data"` 13 | 14 | // name 15 | // Required: true 16 | Name string `json:"Name"` 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/id_response.go: -------------------------------------------------------------------------------- 1 | package types 2 | 3 | // This file was generated by the swagger tool. 4 | // Editing this file might prove futile when you re-run the swagger generate command 5 | 6 | // IDResponse Response to an API call that returns just an Id 7 | // swagger:model IdResponse 8 | type IDResponse struct { 9 | 10 | // The id of the newly created object. 11 | // Required: true 12 | ID string `json:"Id"` 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/image_delete_response_item.go: -------------------------------------------------------------------------------- 1 | package types 2 | 3 | // This file was generated by the swagger tool. 4 | // Editing this file might prove futile when you re-run the swagger generate command 5 | 6 | // ImageDeleteResponseItem image delete response item 7 | // swagger:model ImageDeleteResponseItem 8 | type ImageDeleteResponseItem struct { 9 | 10 | // The image ID of an image that was deleted 11 | Deleted string `json:"Deleted,omitempty"` 12 | 13 | // The image ID of an image that was untagged 14 | Untagged string `json:"Untagged,omitempty"` 15 | } 16 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/plugin_device.go: -------------------------------------------------------------------------------- 1 | package types 2 | 3 | // This file was generated by the swagger tool. 4 | // Editing this file might prove futile when you re-run the swagger generate command 5 | 6 | // PluginDevice plugin device 7 | // swagger:model PluginDevice 8 | type PluginDevice struct { 9 | 10 | // description 11 | // Required: true 12 | Description string `json:"Description"` 13 | 14 | // name 15 | // Required: true 16 | Name string `json:"Name"` 17 | 18 | // path 19 | // Required: true 20 | Path *string `json:"Path"` 21 | 22 | // settable 23 | // Required: true 24 | Settable []string `json:"Settable"` 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/plugin_env.go: -------------------------------------------------------------------------------- 1 | package types 2 | 3 | // This file was generated by the swagger tool. 4 | // Editing this file might prove futile when you re-run the swagger generate command 5 | 6 | // PluginEnv plugin env 7 | // swagger:model PluginEnv 8 | type PluginEnv struct { 9 | 10 | // description 11 | // Required: true 12 | Description string `json:"Description"` 13 | 14 | // name 15 | // Required: true 16 | Name string `json:"Name"` 17 | 18 | // settable 19 | // Required: true 20 | Settable []string `json:"Settable"` 21 | 22 | // value 23 | // Required: true 24 | Value *string `json:"Value"` 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/plugin_interface_type.go: -------------------------------------------------------------------------------- 1 | package types 2 | 3 | // This file was generated by the swagger tool. 4 | // Editing this file might prove futile when you re-run the swagger generate command 5 | 6 | // PluginInterfaceType plugin interface type 7 | // swagger:model PluginInterfaceType 8 | type PluginInterfaceType struct { 9 | 10 | // capability 11 | // Required: true 12 | Capability string `json:"Capability"` 13 | 14 | // prefix 15 | // Required: true 16 | Prefix string `json:"Prefix"` 17 | 18 | // version 19 | // Required: true 20 | Version string `json:"Version"` 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/port.go: -------------------------------------------------------------------------------- 1 | package types 2 | 3 | // This file was generated by the swagger tool. 4 | // Editing this file might prove futile when you re-run the swagger generate command 5 | 6 | // Port An open port on a container 7 | // swagger:model Port 8 | type Port struct { 9 | 10 | // IP 11 | IP string `json:"IP,omitempty"` 12 | 13 | // Port on the container 14 | // Required: true 15 | PrivatePort uint16 `json:"PrivatePort"` 16 | 17 | // Port exposed on the host 18 | PublicPort uint16 `json:"PublicPort,omitempty"` 19 | 20 | // type 21 | // Required: true 22 | Type string `json:"Type"` 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/registry/authenticate.go: -------------------------------------------------------------------------------- 1 | package registry 2 | 3 | // ---------------------------------------------------------------------------- 4 | // DO NOT EDIT THIS FILE 5 | // This file was generated by `swagger generate operation` 6 | // 7 | // See hack/generate-swagger-api.sh 8 | // ---------------------------------------------------------------------------- 9 | 10 | // AuthenticateOKBody authenticate o k body 11 | // swagger:model AuthenticateOKBody 12 | type AuthenticateOKBody struct { 13 | 14 | // An opaque token used to authenticate a user after a successful login 15 | // Required: true 16 | IdentityToken string `json:"IdentityToken"` 17 | 18 | // The status of the authentication 19 | // Required: true 20 | Status string `json:"Status"` 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/service_update_response.go: -------------------------------------------------------------------------------- 1 | package types 2 | 3 | // This file was generated by the swagger tool. 4 | // Editing this file might prove futile when you re-run the swagger generate command 5 | 6 | // ServiceUpdateResponse service update response 7 | // swagger:model ServiceUpdateResponse 8 | type ServiceUpdateResponse struct { 9 | 10 | // Optional warning messages 11 | Warnings []string `json:"Warnings"` 12 | } 13 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/swarm/config.go: -------------------------------------------------------------------------------- 1 | package swarm 2 | 3 | import "os" 4 | 5 | // Config represents a config. 6 | type Config struct { 7 | ID string 8 | Meta 9 | Spec ConfigSpec 10 | } 11 | 12 | // ConfigSpec represents a config specification from a config in swarm 13 | type ConfigSpec struct { 14 | Annotations 15 | Data []byte `json:",omitempty"` 16 | } 17 | 18 | // ConfigReferenceFileTarget is a file target in a config reference 19 | type ConfigReferenceFileTarget struct { 20 | Name string 21 | UID string 22 | GID string 23 | Mode os.FileMode 24 | } 25 | 26 | // ConfigReference is a reference to a config in swarm 27 | type ConfigReference struct { 28 | File *ConfigReferenceFileTarget 29 | ConfigID string 30 | ConfigName string 31 | } 32 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/swarm/runtime.go: -------------------------------------------------------------------------------- 1 | package swarm 2 | 3 | // RuntimeType is the type of runtime used for the TaskSpec 4 | type RuntimeType string 5 | 6 | // RuntimeURL is the proto type url 7 | type RuntimeURL string 8 | 9 | const ( 10 | // RuntimeContainer is the container based runtime 11 | RuntimeContainer RuntimeType = "container" 12 | // RuntimePlugin is the plugin based runtime 13 | RuntimePlugin RuntimeType = "plugin" 14 | 15 | // RuntimeURLContainer is the proto url for the container type 16 | RuntimeURLContainer RuntimeURL = "types.docker.com/RuntimeContainer" 17 | // RuntimeURLPlugin is the proto url for the plugin type 18 | RuntimeURLPlugin RuntimeURL = "types.docker.com/RuntimePlugin" 19 | ) 20 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/swarm/runtime/gen.go: -------------------------------------------------------------------------------- 1 | //go:generate protoc -I . --gogofast_out=import_path=github.com/docker/docker/api/types/swarm/runtime:. plugin.proto 2 | 3 | package runtime 4 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/swarm/runtime/plugin.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | option go_package = "github.com/docker/docker/api/types/swarm/runtime;runtime"; 4 | 5 | // PluginSpec defines the base payload which clients can specify for creating 6 | // a service with the plugin runtime. 7 | message PluginSpec { 8 | string name = 1; 9 | string remote = 2; 10 | repeated PluginPrivilege privileges = 3; 11 | bool disabled = 4; 12 | } 13 | 14 | // PluginPrivilege describes a permission the user has to accept 15 | // upon installing a plugin. 16 | message PluginPrivilege { 17 | string name = 1; 18 | string description = 2; 19 | repeated string value = 3; 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/api/types/versions/compare_test.go: -------------------------------------------------------------------------------- 1 | package versions 2 | 3 | import ( 4 | "testing" 5 | ) 6 | 7 | func assertVersion(t *testing.T, a, b string, result int) { 8 | if r := compare(a, b); r != result { 9 | t.Fatalf("Unexpected version comparison result. Found %d, expected %d", r, result) 10 | } 11 | } 12 | 13 | func TestCompareVersion(t *testing.T) { 14 | assertVersion(t, "1.12", "1.12", 0) 15 | assertVersion(t, "1.0.0", "1", 0) 16 | assertVersion(t, "1", "1.0.0", 0) 17 | assertVersion(t, "1.05.00.0156", "1.0.221.9289", 1) 18 | assertVersion(t, "1", "1.0.1", -1) 19 | assertVersion(t, "1.0.1", "1", 1) 20 | assertVersion(t, "1.0.1", "1.0.2", -1) 21 | assertVersion(t, "1.0.2", "1.0.3", -1) 22 | assertVersion(t, "1.0.3", "1.1", -1) 23 | assertVersion(t, "1.1", "1.1.1", -1) 24 | assertVersion(t, "1.1.1", "1.1.2", -1) 25 | assertVersion(t, "1.1.2", "1.2", -1) 26 | } 27 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/opts/hosts_unix.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package opts 4 | 5 | import "fmt" 6 | 7 | // DefaultHost constant defines the default host string used by docker on other hosts than Windows 8 | var DefaultHost = fmt.Sprintf("unix://%s", DefaultUnixSocket) 9 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/opts/hosts_windows.go: -------------------------------------------------------------------------------- 1 | package opts 2 | 3 | // DefaultHost constant defines the default host string used by docker on Windows 4 | var DefaultHost = "npipe://" + DefaultNamedPipe 5 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/opts/opts_unix.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package opts 4 | 5 | // DefaultHTTPHost Default HTTP Host used if only port is provided to -H flag e.g. dockerd -H tcp://:8080 6 | const DefaultHTTPHost = "localhost" 7 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/opts/quotedstring_test.go: -------------------------------------------------------------------------------- 1 | package opts 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/stretchr/testify/assert" 7 | ) 8 | 9 | func TestQuotedStringSetWithQuotes(t *testing.T) { 10 | value := "" 11 | qs := NewQuotedString(&value) 12 | assert.NoError(t, qs.Set(`"something"`)) 13 | assert.Equal(t, "something", qs.String()) 14 | assert.Equal(t, "something", value) 15 | } 16 | 17 | func TestQuotedStringSetWithMismatchedQuotes(t *testing.T) { 18 | value := "" 19 | qs := NewQuotedString(&value) 20 | assert.NoError(t, qs.Set(`"something'`)) 21 | assert.Equal(t, `"something'`, qs.String()) 22 | } 23 | 24 | func TestQuotedStringSetWithNoQuotes(t *testing.T) { 25 | value := "" 26 | qs := NewQuotedString(&value) 27 | assert.NoError(t, qs.Set("something")) 28 | assert.Equal(t, "something", qs.String()) 29 | } 30 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/archive/README.md: -------------------------------------------------------------------------------- 1 | This code provides helper functions for dealing with archive files. 2 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/archive/archive_other.go: -------------------------------------------------------------------------------- 1 | // +build !linux 2 | 3 | package archive 4 | 5 | func getWhiteoutConverter(format WhiteoutFormat) tarWhiteoutConverter { 6 | return nil 7 | } 8 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/archive/changes_windows.go: -------------------------------------------------------------------------------- 1 | package archive 2 | 3 | import ( 4 | "os" 5 | 6 | "github.com/docker/docker/pkg/system" 7 | ) 8 | 9 | func statDifferent(oldStat *system.StatT, newStat *system.StatT) bool { 10 | 11 | // Don't look at size for dirs, its not a good measure of change 12 | if oldStat.Mtim() != newStat.Mtim() || 13 | oldStat.Mode() != newStat.Mode() || 14 | oldStat.Size() != newStat.Size() && !oldStat.Mode().IsDir() { 15 | return true 16 | } 17 | return false 18 | } 19 | 20 | func (info *FileInfo) isDir() bool { 21 | return info.parent == nil || info.stat.Mode().IsDir() 22 | } 23 | 24 | func getIno(fi os.FileInfo) (inode uint64) { 25 | return 26 | } 27 | 28 | func hasHardlinks(fi os.FileInfo) bool { 29 | return false 30 | } 31 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/archive/copy_unix.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package archive 4 | 5 | import ( 6 | "path/filepath" 7 | ) 8 | 9 | func normalizePath(path string) string { 10 | return filepath.ToSlash(path) 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/archive/copy_windows.go: -------------------------------------------------------------------------------- 1 | package archive 2 | 3 | import ( 4 | "path/filepath" 5 | ) 6 | 7 | func normalizePath(path string) string { 8 | return filepath.FromSlash(path) 9 | } 10 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/archive/testdata/broken.tar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/remind101/conveyor/8c30bff03fe366f848bc8ac31478a5f8acfdfd8c/vendor/github.com/docker/docker/pkg/archive/testdata/broken.tar -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/archive/time_linux.go: -------------------------------------------------------------------------------- 1 | package archive 2 | 3 | import ( 4 | "syscall" 5 | "time" 6 | ) 7 | 8 | func timeToTimespec(time time.Time) (ts syscall.Timespec) { 9 | if time.IsZero() { 10 | // Return UTIME_OMIT special value 11 | ts.Sec = 0 12 | ts.Nsec = ((1 << 30) - 2) 13 | return 14 | } 15 | return syscall.NsecToTimespec(time.UnixNano()) 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/archive/time_unsupported.go: -------------------------------------------------------------------------------- 1 | // +build !linux 2 | 3 | package archive 4 | 5 | import ( 6 | "syscall" 7 | "time" 8 | ) 9 | 10 | func timeToTimespec(time time.Time) (ts syscall.Timespec) { 11 | nsec := int64(0) 12 | if !time.IsZero() { 13 | nsec = time.UnixNano() 14 | } 15 | return syscall.NsecToTimespec(nsec) 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/fileutils/fileutils_darwin.go: -------------------------------------------------------------------------------- 1 | package fileutils 2 | 3 | import ( 4 | "os" 5 | "os/exec" 6 | "strconv" 7 | "strings" 8 | ) 9 | 10 | // GetTotalUsedFds returns the number of used File Descriptors by 11 | // executing `lsof -p PID` 12 | func GetTotalUsedFds() int { 13 | pid := os.Getpid() 14 | 15 | cmd := exec.Command("lsof", "-p", strconv.Itoa(pid)) 16 | 17 | output, err := cmd.CombinedOutput() 18 | if err != nil { 19 | return -1 20 | } 21 | 22 | outputStr := strings.TrimSpace(string(output)) 23 | 24 | fds := strings.Split(outputStr, "\n") 25 | 26 | return len(fds) - 1 27 | } 28 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/fileutils/fileutils_unix.go: -------------------------------------------------------------------------------- 1 | // +build linux freebsd 2 | 3 | package fileutils 4 | 5 | import ( 6 | "fmt" 7 | "io/ioutil" 8 | "os" 9 | 10 | "github.com/sirupsen/logrus" 11 | ) 12 | 13 | // GetTotalUsedFds Returns the number of used File Descriptors by 14 | // reading it via /proc filesystem. 15 | func GetTotalUsedFds() int { 16 | if fds, err := ioutil.ReadDir(fmt.Sprintf("/proc/%d/fd", os.Getpid())); err != nil { 17 | logrus.Errorf("Error opening /proc/%d/fd: %s", os.Getpid(), err) 18 | } else { 19 | return len(fds) 20 | } 21 | return -1 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/fileutils/fileutils_windows.go: -------------------------------------------------------------------------------- 1 | package fileutils 2 | 3 | // GetTotalUsedFds Returns the number of used File Descriptors. Not supported 4 | // on Windows. 5 | func GetTotalUsedFds() int { 6 | return -1 7 | } 8 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/homedir/homedir_linux.go: -------------------------------------------------------------------------------- 1 | package homedir 2 | 3 | import ( 4 | "os" 5 | 6 | "github.com/docker/docker/pkg/idtools" 7 | ) 8 | 9 | // GetStatic returns the home directory for the current user without calling 10 | // os/user.Current(). This is useful for static-linked binary on glibc-based 11 | // system, because a call to os/user.Current() in a static binary leads to 12 | // segfault due to a glibc issue that won't be fixed in a short term. 13 | // (#29344, golang/go#13470, https://sourceware.org/bugzilla/show_bug.cgi?id=19341) 14 | func GetStatic() (string, error) { 15 | uid := os.Getuid() 16 | usr, err := idtools.LookupUID(uid) 17 | if err != nil { 18 | return "", err 19 | } 20 | return usr.Home, nil 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/homedir/homedir_others.go: -------------------------------------------------------------------------------- 1 | // +build !linux 2 | 3 | package homedir 4 | 5 | import ( 6 | "errors" 7 | ) 8 | 9 | // GetStatic is not needed for non-linux systems. 10 | // (Precisely, it is needed only for glibc-based linux systems.) 11 | func GetStatic() (string, error) { 12 | return "", errors.New("homedir.GetStatic() is not supported on this system") 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/homedir/homedir_test.go: -------------------------------------------------------------------------------- 1 | package homedir 2 | 3 | import ( 4 | "path/filepath" 5 | "testing" 6 | ) 7 | 8 | func TestGet(t *testing.T) { 9 | home := Get() 10 | if home == "" { 11 | t.Fatal("returned home directory is empty") 12 | } 13 | 14 | if !filepath.IsAbs(home) { 15 | t.Fatalf("returned path is not absolute: %s", home) 16 | } 17 | } 18 | 19 | func TestGetShortcutString(t *testing.T) { 20 | shortcut := GetShortcutString() 21 | if shortcut == "" { 22 | t.Fatal("returned shortcut string is empty") 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/homedir/homedir_windows.go: -------------------------------------------------------------------------------- 1 | package homedir 2 | 3 | import ( 4 | "os" 5 | ) 6 | 7 | // Key returns the env var name for the user's home dir based on 8 | // the platform being run on 9 | func Key() string { 10 | return "USERPROFILE" 11 | } 12 | 13 | // Get returns the home directory of the current user with the help of 14 | // environment variables depending on the target operating system. 15 | // Returned path should be used with "path/filepath" to form new paths. 16 | func Get() string { 17 | return os.Getenv(Key()) 18 | } 19 | 20 | // GetShortcutString returns the string that is shortcut to user's home directory 21 | // in the native shell of the platform running on. 22 | func GetShortcutString() string { 23 | return "%USERPROFILE%" // be careful while using in format functions 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/idtools/idtools_windows.go: -------------------------------------------------------------------------------- 1 | package idtools 2 | 3 | import ( 4 | "os" 5 | 6 | "github.com/docker/docker/pkg/system" 7 | ) 8 | 9 | // Platforms such as Windows do not support the UID/GID concept. So make this 10 | // just a wrapper around system.MkdirAll. 11 | func mkdirAs(path string, mode os.FileMode, ownerUID, ownerGID int, mkAll, chownExisting bool) error { 12 | if err := system.MkdirAll(path, mode, ""); err != nil { 13 | return err 14 | } 15 | return nil 16 | } 17 | 18 | // CanAccess takes a valid (existing) directory and a uid, gid pair and determines 19 | // if that uid, gid pair has access (execute bit) to the directory 20 | // Windows does not require/support this function, so always return true 21 | func CanAccess(path string, pair IDPair) bool { 22 | return true 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/idtools/usergroupadd_unsupported.go: -------------------------------------------------------------------------------- 1 | // +build !linux 2 | 3 | package idtools 4 | 5 | import "fmt" 6 | 7 | // AddNamespaceRangesUser takes a name and finds an unused uid, gid pair 8 | // and calls the appropriate helper function to add the group and then 9 | // the user to the group in /etc/group and /etc/passwd respectively. 10 | func AddNamespaceRangesUser(name string) (int, int, error) { 11 | return -1, -1, fmt.Errorf("No support for adding users or groups on this OS") 12 | } 13 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/ioutils/temp_unix.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package ioutils 4 | 5 | import "io/ioutil" 6 | 7 | // TempDir on Unix systems is equivalent to ioutil.TempDir. 8 | func TempDir(dir, prefix string) (string, error) { 9 | return ioutil.TempDir(dir, prefix) 10 | } 11 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/ioutils/temp_windows.go: -------------------------------------------------------------------------------- 1 | package ioutils 2 | 3 | import ( 4 | "io/ioutil" 5 | 6 | "github.com/docker/docker/pkg/longpath" 7 | ) 8 | 9 | // TempDir is the equivalent of ioutil.TempDir, except that the result is in Windows longpath format. 10 | func TempDir(dir, prefix string) (string, error) { 11 | tempDir, err := ioutil.TempDir(dir, prefix) 12 | if err != nil { 13 | return "", err 14 | } 15 | return longpath.AddPrefix(tempDir), nil 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/longpath/longpath.go: -------------------------------------------------------------------------------- 1 | // longpath introduces some constants and helper functions for handling long paths 2 | // in Windows, which are expected to be prepended with `\\?\` and followed by either 3 | // a drive letter, a UNC server\share, or a volume identifier. 4 | 5 | package longpath 6 | 7 | import ( 8 | "strings" 9 | ) 10 | 11 | // Prefix is the longpath prefix for Windows file paths. 12 | const Prefix = `\\?\` 13 | 14 | // AddPrefix will add the Windows long path prefix to the path provided if 15 | // it does not already have it. 16 | func AddPrefix(path string) string { 17 | if !strings.HasPrefix(path, Prefix) { 18 | if strings.HasPrefix(path, `\\`) { 19 | // This is a UNC path, so we need to add 'UNC' to the path as well. 20 | path = Prefix + `UNC` + path[1:] 21 | } else { 22 | path = Prefix + path 23 | } 24 | } 25 | return path 26 | } 27 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/longpath/longpath_test.go: -------------------------------------------------------------------------------- 1 | package longpath 2 | 3 | import ( 4 | "strings" 5 | "testing" 6 | ) 7 | 8 | func TestStandardLongPath(t *testing.T) { 9 | c := `C:\simple\path` 10 | longC := AddPrefix(c) 11 | if !strings.EqualFold(longC, `\\?\C:\simple\path`) { 12 | t.Errorf("Wrong long path returned. Original = %s ; Long = %s", c, longC) 13 | } 14 | } 15 | 16 | func TestUNCLongPath(t *testing.T) { 17 | c := `\\server\share\path` 18 | longC := AddPrefix(c) 19 | if !strings.EqualFold(longC, `\\?\UNC\server\share\path`) { 20 | t.Errorf("Wrong UNC long path returned. Original = %s ; Long = %s", c, longC) 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/mount/flags_unsupported.go: -------------------------------------------------------------------------------- 1 | // +build !linux,!freebsd freebsd,!cgo 2 | 3 | package mount 4 | 5 | // These flags are unsupported. 6 | const ( 7 | BIND = 0 8 | DIRSYNC = 0 9 | MANDLOCK = 0 10 | NOATIME = 0 11 | NODEV = 0 12 | NODIRATIME = 0 13 | NOEXEC = 0 14 | NOSUID = 0 15 | UNBINDABLE = 0 16 | RUNBINDABLE = 0 17 | PRIVATE = 0 18 | RPRIVATE = 0 19 | SHARED = 0 20 | RSHARED = 0 21 | SLAVE = 0 22 | RSLAVE = 0 23 | RBIND = 0 24 | RELATIME = 0 25 | RELATIVE = 0 26 | REMOUNT = 0 27 | STRICTATIME = 0 28 | SYNCHRONOUS = 0 29 | RDONLY = 0 30 | mntDetach = 0 31 | ) 32 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/mount/mounter_unsupported.go: -------------------------------------------------------------------------------- 1 | // +build !linux,!freebsd freebsd,!cgo 2 | 3 | package mount 4 | 5 | func mount(device, target, mType string, flag uintptr, data string) error { 6 | panic("Not implemented") 7 | } 8 | 9 | func unmount(target string, flag int) error { 10 | panic("Not implemented") 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/mount/mountinfo_unsupported.go: -------------------------------------------------------------------------------- 1 | // +build !windows,!linux,!freebsd freebsd,!cgo 2 | 3 | package mount 4 | 5 | import ( 6 | "fmt" 7 | "runtime" 8 | ) 9 | 10 | func parseMountTable() ([]*Info, error) { 11 | return nil, fmt.Errorf("mount.parseMountTable is not implemented on %s/%s", runtime.GOOS, runtime.GOARCH) 12 | } 13 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/mount/mountinfo_windows.go: -------------------------------------------------------------------------------- 1 | package mount 2 | 3 | func parseMountTable() ([]*Info, error) { 4 | // Do NOT return an error! 5 | return nil, nil 6 | } 7 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/chtimes_unix.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package system 4 | 5 | import ( 6 | "time" 7 | ) 8 | 9 | //setCTime will set the create time on a file. On Unix, the create 10 | //time is updated as a side effect of setting the modified time, so 11 | //no action is required. 12 | func setCTime(path string, ctime time.Time) error { 13 | return nil 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/chtimes_windows.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | import ( 4 | "time" 5 | 6 | "golang.org/x/sys/windows" 7 | ) 8 | 9 | //setCTime will set the create time on a file. On Windows, this requires 10 | //calling SetFileTime and explicitly including the create time. 11 | func setCTime(path string, ctime time.Time) error { 12 | ctimespec := windows.NsecToTimespec(ctime.UnixNano()) 13 | pathp, e := windows.UTF16PtrFromString(path) 14 | if e != nil { 15 | return e 16 | } 17 | h, e := windows.CreateFile(pathp, 18 | windows.FILE_WRITE_ATTRIBUTES, windows.FILE_SHARE_WRITE, nil, 19 | windows.OPEN_EXISTING, windows.FILE_FLAG_BACKUP_SEMANTICS, 0) 20 | if e != nil { 21 | return e 22 | } 23 | defer windows.Close(h) 24 | c := windows.NsecToFiletime(windows.TimespecToNsec(ctimespec)) 25 | return windows.SetFileTime(h, &c, nil, nil) 26 | } 27 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/errors.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | import ( 4 | "errors" 5 | ) 6 | 7 | var ( 8 | // ErrNotSupportedPlatform means the platform is not supported. 9 | ErrNotSupportedPlatform = errors.New("platform and architecture is not supported") 10 | ) 11 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/exitcode.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | import ( 4 | "fmt" 5 | "os/exec" 6 | "syscall" 7 | ) 8 | 9 | // GetExitCode returns the ExitStatus of the specified error if its type is 10 | // exec.ExitError, returns 0 and an error otherwise. 11 | func GetExitCode(err error) (int, error) { 12 | exitCode := 0 13 | if exiterr, ok := err.(*exec.ExitError); ok { 14 | if procExit, ok := exiterr.Sys().(syscall.WaitStatus); ok { 15 | return procExit.ExitStatus(), nil 16 | } 17 | } 18 | return exitCode, fmt.Errorf("failed to get exit code") 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/init.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | import ( 4 | "syscall" 5 | "time" 6 | "unsafe" 7 | ) 8 | 9 | // Used by chtimes 10 | var maxTime time.Time 11 | 12 | func init() { 13 | // chtimes initialization 14 | if unsafe.Sizeof(syscall.Timespec{}.Nsec) == 8 { 15 | // This is a 64 bit timespec 16 | // os.Chtimes limits time to the following 17 | maxTime = time.Unix(0, 1<<63-1) 18 | } else { 19 | // This is a 32 bit timespec 20 | maxTime = time.Unix(1<<31-1, 0) 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/init_unix.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package system 4 | 5 | // InitLCOW does nothing since LCOW is a windows only feature 6 | func InitLCOW(experimental bool) { 7 | } 8 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/init_windows.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | import "os" 4 | 5 | // lcowSupported determines if Linux Containers on Windows are supported. 6 | var lcowSupported = false 7 | 8 | // InitLCOW sets whether LCOW is supported or not 9 | // TODO @jhowardmsft. 10 | // 1. Replace with RS3 RTM build number. 11 | // 2. Remove the getenv check when image-store is coalesced as shouldn't be needed anymore. 12 | func InitLCOW(experimental bool) { 13 | v := GetOSVersion() 14 | if experimental && v.Build > 16270 && os.Getenv("LCOW_SUPPORTED") != "" { 15 | lcowSupported = true 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/lcow_unix.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package system 4 | 5 | // LCOWSupported returns true if Linux containers on Windows are supported. 6 | func LCOWSupported() bool { 7 | return false 8 | } 9 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/lcow_windows.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | // LCOWSupported returns true if Linux containers on Windows are supported. 4 | func LCOWSupported() bool { 5 | return lcowSupported 6 | } 7 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/lstat_unix.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package system 4 | 5 | import ( 6 | "syscall" 7 | ) 8 | 9 | // Lstat takes a path to a file and returns 10 | // a system.StatT type pertaining to that file. 11 | // 12 | // Throws an error if the file does not exist 13 | func Lstat(path string) (*StatT, error) { 14 | s := &syscall.Stat_t{} 15 | if err := syscall.Lstat(path, s); err != nil { 16 | return nil, err 17 | } 18 | return fromStatT(s) 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/lstat_unix_test.go: -------------------------------------------------------------------------------- 1 | // +build linux freebsd 2 | 3 | package system 4 | 5 | import ( 6 | "os" 7 | "testing" 8 | ) 9 | 10 | // TestLstat tests Lstat for existing and non existing files 11 | func TestLstat(t *testing.T) { 12 | file, invalid, _, dir := prepareFiles(t) 13 | defer os.RemoveAll(dir) 14 | 15 | statFile, err := Lstat(file) 16 | if err != nil { 17 | t.Fatal(err) 18 | } 19 | if statFile == nil { 20 | t.Fatal("returned empty stat for existing file") 21 | } 22 | 23 | statInvalid, err := Lstat(invalid) 24 | if err == nil { 25 | t.Fatal("did not return error for non-existing file") 26 | } 27 | if statInvalid != nil { 28 | t.Fatal("returned non-nil stat for non-existing file") 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/lstat_windows.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | import "os" 4 | 5 | // Lstat calls os.Lstat to get a fileinfo interface back. 6 | // This is then copied into our own locally defined structure. 7 | func Lstat(path string) (*StatT, error) { 8 | fi, err := os.Lstat(path) 9 | if err != nil { 10 | return nil, err 11 | } 12 | 13 | return fromStatT(&fi) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/meminfo.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | // MemInfo contains memory statistics of the host system. 4 | type MemInfo struct { 5 | // Total usable RAM (i.e. physical RAM minus a few reserved bits and the 6 | // kernel binary code). 7 | MemTotal int64 8 | 9 | // Amount of free memory. 10 | MemFree int64 11 | 12 | // Total amount of swap space available. 13 | SwapTotal int64 14 | 15 | // Amount of swap space that is currently unused. 16 | SwapFree int64 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/meminfo_unsupported.go: -------------------------------------------------------------------------------- 1 | // +build !linux,!windows 2 | 3 | package system 4 | 5 | // ReadMemInfo is not supported on platforms other than linux and windows. 6 | func ReadMemInfo() (*MemInfo, error) { 7 | return nil, ErrNotSupportedPlatform 8 | } 9 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/mknod.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package system 4 | 5 | import ( 6 | "golang.org/x/sys/unix" 7 | ) 8 | 9 | // Mknod creates a filesystem node (file, device special file or named pipe) named path 10 | // with attributes specified by mode and dev. 11 | func Mknod(path string, mode uint32, dev int) error { 12 | return unix.Mknod(path, mode, dev) 13 | } 14 | 15 | // Mkdev is used to build the value of linux devices (in /dev/) which specifies major 16 | // and minor number of the newly created device special file. 17 | // Linux device nodes are a bit weird due to backwards compat with 16 bit device nodes. 18 | // They are, from low to high: the lower 8 bits of the minor, then 12 bits of the major, 19 | // then the top 12 bits of the minor. 20 | func Mkdev(major int64, minor int64) uint32 { 21 | return uint32(unix.Mkdev(uint32(major), uint32(minor))) 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/mknod_windows.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | // Mknod is not implemented on Windows. 4 | func Mknod(path string, mode uint32, dev int) error { 5 | return ErrNotSupportedPlatform 6 | } 7 | 8 | // Mkdev is not implemented on Windows. 9 | func Mkdev(major int64, minor int64) uint32 { 10 | panic("Mkdev not implemented on Windows.") 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/process_unix.go: -------------------------------------------------------------------------------- 1 | // +build linux freebsd darwin 2 | 3 | package system 4 | 5 | import ( 6 | "syscall" 7 | 8 | "golang.org/x/sys/unix" 9 | ) 10 | 11 | // IsProcessAlive returns true if process with a given pid is running. 12 | func IsProcessAlive(pid int) bool { 13 | err := unix.Kill(pid, syscall.Signal(0)) 14 | if err == nil || err == unix.EPERM { 15 | return true 16 | } 17 | 18 | return false 19 | } 20 | 21 | // KillProcess force-stops a process. 22 | func KillProcess(pid int) { 23 | unix.Kill(pid, unix.SIGKILL) 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/process_windows.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | import "os" 4 | 5 | // IsProcessAlive returns true if process with a given pid is running. 6 | func IsProcessAlive(pid int) bool { 7 | _, err := os.FindProcess(pid) 8 | 9 | return err == nil 10 | } 11 | 12 | // KillProcess force-stops a process. 13 | func KillProcess(pid int) { 14 | p, err := os.FindProcess(pid) 15 | if err == nil { 16 | p.Kill() 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/stat_darwin.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | import "syscall" 4 | 5 | // fromStatT converts a syscall.Stat_t type to a system.Stat_t type 6 | func fromStatT(s *syscall.Stat_t) (*StatT, error) { 7 | return &StatT{size: s.Size, 8 | mode: uint32(s.Mode), 9 | uid: s.Uid, 10 | gid: s.Gid, 11 | rdev: uint64(s.Rdev), 12 | mtim: s.Mtimespec}, nil 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/stat_freebsd.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | import "syscall" 4 | 5 | // fromStatT converts a syscall.Stat_t type to a system.Stat_t type 6 | func fromStatT(s *syscall.Stat_t) (*StatT, error) { 7 | return &StatT{size: s.Size, 8 | mode: uint32(s.Mode), 9 | uid: s.Uid, 10 | gid: s.Gid, 11 | rdev: uint64(s.Rdev), 12 | mtim: s.Mtimespec}, nil 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/stat_linux.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | import "syscall" 4 | 5 | // fromStatT converts a syscall.Stat_t type to a system.Stat_t type 6 | func fromStatT(s *syscall.Stat_t) (*StatT, error) { 7 | return &StatT{size: s.Size, 8 | mode: s.Mode, 9 | uid: s.Uid, 10 | gid: s.Gid, 11 | rdev: s.Rdev, 12 | mtim: s.Mtim}, nil 13 | } 14 | 15 | // FromStatT converts a syscall.Stat_t type to a system.Stat_t type 16 | // This is exposed on Linux as pkg/archive/changes uses it. 17 | func FromStatT(s *syscall.Stat_t) (*StatT, error) { 18 | return fromStatT(s) 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/stat_openbsd.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | import "syscall" 4 | 5 | // fromStatT converts a syscall.Stat_t type to a system.Stat_t type 6 | func fromStatT(s *syscall.Stat_t) (*StatT, error) { 7 | return &StatT{size: s.Size, 8 | mode: uint32(s.Mode), 9 | uid: s.Uid, 10 | gid: s.Gid, 11 | rdev: uint64(s.Rdev), 12 | mtim: s.Mtim}, nil 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/stat_solaris.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | import "syscall" 4 | 5 | // fromStatT converts a syscall.Stat_t type to a system.Stat_t type 6 | func fromStatT(s *syscall.Stat_t) (*StatT, error) { 7 | return &StatT{size: s.Size, 8 | mode: uint32(s.Mode), 9 | uid: s.Uid, 10 | gid: s.Gid, 11 | rdev: uint64(s.Rdev), 12 | mtim: s.Mtim}, nil 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/syscall_unix.go: -------------------------------------------------------------------------------- 1 | // +build linux freebsd 2 | 3 | package system 4 | 5 | import "golang.org/x/sys/unix" 6 | 7 | // Unmount is a platform-specific helper function to call 8 | // the unmount syscall. 9 | func Unmount(dest string) error { 10 | return unix.Unmount(dest, 0) 11 | } 12 | 13 | // CommandLineToArgv should not be used on Unix. 14 | // It simply returns commandLine in the only element in the returned array. 15 | func CommandLineToArgv(commandLine string) ([]string, error) { 16 | return []string{commandLine}, nil 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/syscall_windows_test.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | import "testing" 4 | 5 | func TestHasWin32KSupport(t *testing.T) { 6 | s := HasWin32KSupport() // make sure this doesn't panic 7 | 8 | t.Logf("win32k: %v", s) // will be different on different platforms -- informative only 9 | } 10 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/umask.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package system 4 | 5 | import ( 6 | "golang.org/x/sys/unix" 7 | ) 8 | 9 | // Umask sets current process's file mode creation mask to newmask 10 | // and returns oldmask. 11 | func Umask(newmask int) (oldmask int, err error) { 12 | return unix.Umask(newmask), nil 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/umask_windows.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | // Umask is not supported on the windows platform. 4 | func Umask(newmask int) (oldmask int, err error) { 5 | // should not be called on cli code path 6 | return 0, ErrNotSupportedPlatform 7 | } 8 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/utimes_freebsd.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | import ( 4 | "syscall" 5 | "unsafe" 6 | 7 | "golang.org/x/sys/unix" 8 | ) 9 | 10 | // LUtimesNano is used to change access and modification time of the specified path. 11 | // It's used for symbol link file because unix.UtimesNano doesn't support a NOFOLLOW flag atm. 12 | func LUtimesNano(path string, ts []syscall.Timespec) error { 13 | var _path *byte 14 | _path, err := unix.BytePtrFromString(path) 15 | if err != nil { 16 | return err 17 | } 18 | 19 | if _, _, err := unix.Syscall(unix.SYS_LUTIMES, uintptr(unsafe.Pointer(_path)), uintptr(unsafe.Pointer(&ts[0])), 0); err != 0 && err != unix.ENOSYS { 20 | return err 21 | } 22 | 23 | return nil 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/utimes_linux.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | import ( 4 | "syscall" 5 | "unsafe" 6 | 7 | "golang.org/x/sys/unix" 8 | ) 9 | 10 | // LUtimesNano is used to change access and modification time of the specified path. 11 | // It's used for symbol link file because unix.UtimesNano doesn't support a NOFOLLOW flag atm. 12 | func LUtimesNano(path string, ts []syscall.Timespec) error { 13 | atFdCwd := unix.AT_FDCWD 14 | 15 | var _path *byte 16 | _path, err := unix.BytePtrFromString(path) 17 | if err != nil { 18 | return err 19 | } 20 | if _, _, err := unix.Syscall6(unix.SYS_UTIMENSAT, uintptr(atFdCwd), uintptr(unsafe.Pointer(_path)), uintptr(unsafe.Pointer(&ts[0])), unix.AT_SYMLINK_NOFOLLOW, 0, 0); err != 0 && err != unix.ENOSYS { 21 | return err 22 | } 23 | 24 | return nil 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/utimes_unsupported.go: -------------------------------------------------------------------------------- 1 | // +build !linux,!freebsd 2 | 3 | package system 4 | 5 | import "syscall" 6 | 7 | // LUtimesNano is only supported on linux and freebsd. 8 | func LUtimesNano(path string, ts []syscall.Timespec) error { 9 | return ErrNotSupportedPlatform 10 | } 11 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/system/xattrs_unsupported.go: -------------------------------------------------------------------------------- 1 | // +build !linux 2 | 3 | package system 4 | 5 | // Lgetxattr is not supported on platforms other than linux. 6 | func Lgetxattr(path string, attr string) ([]byte, error) { 7 | return nil, ErrNotSupportedPlatform 8 | } 9 | 10 | // Lsetxattr is not supported on platforms other than linux. 11 | func Lsetxattr(path string, attr string, data []byte, flags int) error { 12 | return ErrNotSupportedPlatform 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/term/ascii_test.go: -------------------------------------------------------------------------------- 1 | package term 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/stretchr/testify/assert" 7 | "github.com/stretchr/testify/require" 8 | ) 9 | 10 | func TestToBytes(t *testing.T) { 11 | codes, err := ToBytes("ctrl-a,a") 12 | require.NoError(t, err) 13 | assert.Equal(t, []byte{1, 97}, codes) 14 | 15 | _, err = ToBytes("shift-z") 16 | assert.Error(t, err) 17 | 18 | codes, err = ToBytes("ctrl-@,ctrl-[,~,ctrl-o") 19 | require.NoError(t, err) 20 | assert.Equal(t, []byte{0, 27, 126, 15}, codes) 21 | 22 | codes, err = ToBytes("DEL,+") 23 | require.NoError(t, err) 24 | assert.Equal(t, []byte{127, 43}, codes) 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/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/docker/docker/pkg/term/windows/windows_test.go: -------------------------------------------------------------------------------- 1 | // This file is necessary to pass the Docker tests. 2 | 3 | package windowsconsole 4 | -------------------------------------------------------------------------------- /vendor/github.com/docker/docker/pkg/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/docker/go-units/README.md: -------------------------------------------------------------------------------- 1 | [![GoDoc](https://godoc.org/github.com/docker/go-units?status.svg)](https://godoc.org/github.com/docker/go-units) 2 | 3 | # Introduction 4 | 5 | go-units is a library to transform human friendly measurements into machine friendly values. 6 | 7 | ## Usage 8 | 9 | See the [docs in godoc](https://godoc.org/github.com/docker/go-units) for examples and documentation. 10 | 11 | ## Copyright and license 12 | 13 | Copyright © 2015 Docker, Inc. 14 | 15 | go-units is licensed under the Apache License, Version 2.0. 16 | See [LICENSE](LICENSE) for the full text of the license. 17 | -------------------------------------------------------------------------------- /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/ejholmes/cloudwatch/README.md: -------------------------------------------------------------------------------- 1 | This is a Go library to treat CloudWatch Log streams as io.Writers and io.Readers. 2 | 3 | 4 | ## Usage 5 | 6 | ```go 7 | group := NewGroup("group", cloudwatchlogs.New(defaults.DefaultConfig)) 8 | w, err := group.Create("stream") 9 | 10 | io.WriteString(w, "Hello World") 11 | 12 | r, err := group.Open("stream") 13 | io.Copy(os.Stdout, r) 14 | ``` 15 | 16 | ## Dependencies 17 | 18 | This library depends on [aws-sdk-go](https://github.com/aws/aws-sdk-go/). 19 | -------------------------------------------------------------------------------- /vendor/github.com/ejholmes/hookshot/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | go: 4 | - 1.3 5 | 6 | before_install: 7 | - go install -a -race std 8 | - go get ./... 9 | - export PATH=$HOME/gopath/bin:$PATH 10 | 11 | script: 12 | - go test -race ./... 13 | -------------------------------------------------------------------------------- /vendor/github.com/ejholmes/hookshot/README.md: -------------------------------------------------------------------------------- 1 | # [Hookshot](https://github.com/ejholmes/hookshot) [![Build Status](https://travis-ci.org/ejholmes/hookshot.svg?branch=master)](https://travis-ci.org/ejholmes/hookshot) 2 | 3 | [Godoc](http://godoc.org/github.com/ejholmes/hookshot) 4 | 5 | Hookshot is a Go http router that de-multiplexes and authorizes GitHub Webhooks. 6 | 7 | 8 | ## Usage 9 | 10 | ```go 11 | r := hookshot.NewRouter() 12 | 13 | r.Handle("deployment_status", DeploymentStatusHandler) 14 | r.Handle("deployment", DeploymentHandler) 15 | ``` 16 | 17 | To automatically verify the `X-Hub-Signature`: 18 | 19 | 20 | ```go 21 | r.Handle("deployment", hookshot.Authorize(DeploymentHandler, "secret")) 22 | ``` 23 | -------------------------------------------------------------------------------- /vendor/github.com/ejholmes/hookshot/events/events.go: -------------------------------------------------------------------------------- 1 | // Package events containers types representing GitHub webhook payloads. This 2 | // package is autogenerated from https://github.com/github/developer.github.com/tree/master/lib/webhooks 3 | package events 4 | 5 | //go:generate ./generate 6 | -------------------------------------------------------------------------------- /vendor/github.com/ejholmes/hookshot/events/generate: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | events=" 4 | commit_comment 5 | create 6 | delete 7 | deployment 8 | deployment_status 9 | fork 10 | gollum 11 | issue_comment 12 | issues 13 | member 14 | membership 15 | page_build 16 | ping 17 | public 18 | pull_request 19 | pull_request_review_comment 20 | push 21 | release 22 | repository 23 | status 24 | team_add 25 | watch 26 | " 27 | 28 | for event in $events; do 29 | name=$(ruby -r 'active_support' -r 'active_support/core_ext' -e "print '${event}'.camelize") 30 | curl -Ls https://raw.githubusercontent.com/github/developer.github.com/master/lib/webhooks/${event}.payload.json | gojson -pkg=events -name=${name} > ${event}.go 31 | done 32 | -------------------------------------------------------------------------------- /vendor/github.com/ejholmes/hookshot/example_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014 Eric Holmes. All rights reserved. 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 hookshot_test 6 | 7 | import ( 8 | "net/http" 9 | 10 | "github.com/ejholmes/hookshot" 11 | ) 12 | 13 | func HandlePing(w http.ResponseWriter, r *http.Request) { 14 | w.WriteHeader(200) 15 | w.Write([]byte(`Pong`)) 16 | } 17 | 18 | func Example() { 19 | r := hookshot.NewRouter() 20 | r.HandleFunc("ping", HandlePing) 21 | 22 | http.ListenAndServe(":8080", r) 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/fsouza/go-dockerclient/DOCKER-LICENSE: -------------------------------------------------------------------------------- 1 | Apache License 2 | Version 2.0, January 2004 3 | http://www.apache.org/licenses/ 4 | 5 | You can find the Docker license at the following link: 6 | https://raw.githubusercontent.com/docker/docker/master/LICENSE 7 | -------------------------------------------------------------------------------- /vendor/github.com/fsouza/go-dockerclient/Makefile: -------------------------------------------------------------------------------- 1 | .PHONY: \ 2 | all \ 3 | lint \ 4 | vet \ 5 | fmt \ 6 | fmtcheck \ 7 | pretest \ 8 | test \ 9 | integration \ 10 | clean 11 | 12 | all: test 13 | 14 | lint: 15 | @ go get -v github.com/golang/lint/golint 16 | [ -z "$$(golint . | grep -v 'type name will be used as docker.DockerInfo' | grep -v 'context.Context should be the first' | tee /dev/stderr)" ] 17 | 18 | vet: 19 | go vet ./... 20 | 21 | fmt: 22 | gofmt -s -w . 23 | 24 | fmtcheck: 25 | [ -z "$$(gofmt -s -d . | tee /dev/stderr)" ] 26 | 27 | testdeps: 28 | go get -d -t ./... 29 | 30 | pretest: testdeps lint vet fmtcheck 31 | 32 | gotest: 33 | go test $(GO_TEST_FLAGS) ./... 34 | 35 | test: pretest gotest 36 | 37 | integration: 38 | go test -tags docker_integration -run TestIntegration -v 39 | 40 | clean: 41 | go clean ./... 42 | -------------------------------------------------------------------------------- /vendor/github.com/fsouza/go-dockerclient/appveyor.yml: -------------------------------------------------------------------------------- 1 | version: '{build}' 2 | platform: x64 3 | clone_depth: 2 4 | clone_folder: c:\gopath\src\github.com\fsouza\go-dockerclient 5 | environment: 6 | GOPATH: c:\gopath 7 | matrix: 8 | - GOVERSION: 1.7.5 9 | - GOVERSION: 1.8.3 10 | - GOVERSION: 1.9rc1 11 | install: 12 | - set PATH=%GOPATH%\bin;c:\go\bin;%PATH% 13 | - rmdir c:\go /s /q 14 | - appveyor DownloadFile https://storage.googleapis.com/golang/go%GOVERSION%.windows-amd64.zip 15 | - 7z x go%GOVERSION%.windows-amd64.zip -y -oC:\ > NUL 16 | build_script: 17 | - go get -race -d -t ./... 18 | test_script: 19 | - go test -race ./... 20 | matrix: 21 | fast_finish: true 22 | -------------------------------------------------------------------------------- /vendor/github.com/fsouza/go-dockerclient/change_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014 go-dockerclient authors. All rights reserved. 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 docker 6 | 7 | import "testing" 8 | 9 | func TestChangeString(t *testing.T) { 10 | t.Parallel() 11 | var tests = []struct { 12 | change Change 13 | expected string 14 | }{ 15 | {Change{"/etc/passwd", ChangeModify}, "C /etc/passwd"}, 16 | {Change{"/etc/passwd", ChangeAdd}, "A /etc/passwd"}, 17 | {Change{"/etc/passwd", ChangeDelete}, "D /etc/passwd"}, 18 | {Change{"/etc/passwd", 33}, " /etc/passwd"}, 19 | } 20 | for _, tt := range tests { 21 | if got := tt.change.String(); got != tt.expected { 22 | t.Errorf("Change.String(): want %q. Got %q.", tt.expected, got) 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/go-ini/ini/Makefile: -------------------------------------------------------------------------------- 1 | .PHONY: build test bench vet 2 | 3 | build: vet bench 4 | 5 | test: 6 | go test -v -cover -race 7 | 8 | bench: 9 | go test -v -cover -race -test.bench=. -test.benchmem 10 | 11 | vet: 12 | go vet 13 | -------------------------------------------------------------------------------- /vendor/github.com/go-ini/ini/testdata/UTF-16-BE-BOM.ini: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/remind101/conveyor/8c30bff03fe366f848bc8ac31478a5f8acfdfd8c/vendor/github.com/go-ini/ini/testdata/UTF-16-BE-BOM.ini -------------------------------------------------------------------------------- /vendor/github.com/go-ini/ini/testdata/UTF-16-LE-BOM.ini: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/remind101/conveyor/8c30bff03fe366f848bc8ac31478a5f8acfdfd8c/vendor/github.com/go-ini/ini/testdata/UTF-16-LE-BOM.ini -------------------------------------------------------------------------------- /vendor/github.com/go-ini/ini/testdata/UTF-8-BOM.ini: -------------------------------------------------------------------------------- 1 | [author] 2 | E-MAIL = u@gogs.io -------------------------------------------------------------------------------- /vendor/github.com/go-ini/ini/testdata/aicc.ini: -------------------------------------------------------------------------------- 1 | [Core] 2 | Lesson_Location = 87 3 | Lesson_Status = C 4 | Score = 3 5 | Time = 00:02:30 6 | 7 | [CORE_LESSON] 8 | my lesson state data – 1111111111111111111000000000000000001110000 9 | 111111111111111111100000000000111000000000 – end my lesson state data 10 | [COMMENTS] 11 | <1> This slide has the fuel listed in the wrong units 12 | -------------------------------------------------------------------------------- /vendor/github.com/go-ini/ini/testdata/conf.ini: -------------------------------------------------------------------------------- 1 | [author] 2 | E-MAIL = u@gogs.io -------------------------------------------------------------------------------- /vendor/github.com/goji/httpauth/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | sudo: false 3 | go: 4 | - 1.2 5 | - 1.3 6 | - 1.4 7 | - 1.5 8 | - tip 9 | install: 10 | - go get golang.org/x/tools/cmd/vet 11 | script: 12 | - go get -t -v ./... 13 | - diff -u <(echo -n) <(gofmt -d -s .) 14 | - go tool vet . 15 | - go test -v -race ./... 16 | -------------------------------------------------------------------------------- /vendor/github.com/google/go-github/github/git.go: -------------------------------------------------------------------------------- 1 | // Copyright 2013 The go-github AUTHORS. All rights reserved. 2 | // 3 | // Use of this source code is governed by a BSD-style 4 | // license that can be found in the LICENSE file. 5 | 6 | package github 7 | 8 | // GitService handles communication with the git data related 9 | // methods of the GitHub API. 10 | // 11 | // GitHub API docs: https://developer.github.com/v3/git/ 12 | type GitService service 13 | -------------------------------------------------------------------------------- /vendor/github.com/google/go-github/github/teams.go: -------------------------------------------------------------------------------- 1 | package github 2 | 3 | // TeamsService provides access to the team-related functions 4 | // in the GitHub API. 5 | // 6 | // GitHub API docs: https://developer.github.com/v3/teams/ 7 | type TeamsService service 8 | -------------------------------------------------------------------------------- /vendor/github.com/google/go-github/github/with_appengine.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The go-github AUTHORS. All rights reserved. 2 | // 3 | // Use of this source code is governed by a BSD-style 4 | // license that can be found in the LICENSE file. 5 | 6 | // +build appengine 7 | 8 | // This file provides glue for making github work on App Engine. 9 | 10 | package github 11 | 12 | import ( 13 | "context" 14 | "net/http" 15 | ) 16 | 17 | func withContext(ctx context.Context, req *http.Request) *http.Request { 18 | // No-op because App Engine adds context to a request differently. 19 | return req 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/google/go-github/github/without_appengine.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The go-github AUTHORS. All rights reserved. 2 | // 3 | // Use of this source code is governed by a BSD-style 4 | // license that can be found in the LICENSE file. 5 | 6 | // +build !appengine 7 | 8 | // This file provides glue for making github work without App Engine. 9 | 10 | package github 11 | 12 | import ( 13 | "context" 14 | "net/http" 15 | ) 16 | 17 | func withContext(ctx context.Context, req *http.Request) *http.Request { 18 | return req.WithContext(ctx) 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/gorilla/context/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | go: 4 | - 1.0 5 | - 1.1 6 | - 1.2 7 | - 1.3 8 | - 1.4 9 | - tip 10 | -------------------------------------------------------------------------------- /vendor/github.com/gorilla/context/README.md: -------------------------------------------------------------------------------- 1 | context 2 | ======= 3 | [![Build Status](https://travis-ci.org/gorilla/context.png?branch=master)](https://travis-ci.org/gorilla/context) 4 | 5 | gorilla/context is a general purpose registry for global request variables. 6 | 7 | Read the full documentation here: http://www.gorillatoolkit.org/pkg/context 8 | -------------------------------------------------------------------------------- /vendor/github.com/gorilla/mux/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | go: 4 | - 1.0 5 | - 1.1 6 | - 1.2 7 | - tip 8 | -------------------------------------------------------------------------------- /vendor/github.com/gorilla/mux/README.md: -------------------------------------------------------------------------------- 1 | mux 2 | === 3 | [![Build Status](https://travis-ci.org/gorilla/mux.png?branch=master)](https://travis-ci.org/gorilla/mux) 4 | 5 | gorilla/mux is a powerful URL router and dispatcher. 6 | 7 | Read the full documentation here: http://www.gorillatoolkit.org/pkg/mux 8 | -------------------------------------------------------------------------------- /vendor/github.com/gorilla/mux/bench_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Gorilla Authors. All rights reserved. 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 mux 6 | 7 | import ( 8 | "net/http" 9 | "testing" 10 | ) 11 | 12 | func BenchmarkMux(b *testing.B) { 13 | router := new(Router) 14 | handler := func(w http.ResponseWriter, r *http.Request) {} 15 | router.HandleFunc("/v1/{v1}", handler) 16 | 17 | request, _ := http.NewRequest("GET", "/v1/anything", nil) 18 | for i := 0; i < b.N; i++ { 19 | router.ServeHTTP(nil, request) 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/gotestyourself/gotestyourself/internal/format/format.go: -------------------------------------------------------------------------------- 1 | package format 2 | 3 | import "fmt" 4 | 5 | // Message accepts a msgAndArgs varargs and formats it using fmt.Sprintf 6 | func Message(msgAndArgs ...interface{}) string { 7 | switch len(msgAndArgs) { 8 | case 0: 9 | return "" 10 | case 1: 11 | return fmt.Sprintf("%v", msgAndArgs[0]) 12 | default: 13 | return fmt.Sprintf(msgAndArgs[0].(string), msgAndArgs[1:]...) 14 | } 15 | } 16 | 17 | // WithCustomMessage accepts one or two messages and formats them appropriately 18 | func WithCustomMessage(source string, msgAndArgs ...interface{}) string { 19 | custom := Message(msgAndArgs...) 20 | switch { 21 | case custom == "": 22 | return source 23 | case source == "": 24 | return custom 25 | } 26 | return fmt.Sprintf("%s: %s", source, custom) 27 | } 28 | -------------------------------------------------------------------------------- /vendor/github.com/honeybadger-io/honeybadger-go/.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects) 2 | *.o 3 | *.a 4 | *.so 5 | 6 | # Folders 7 | _obj 8 | _test 9 | 10 | # Architecture specific extensions/prefixes 11 | *.[568vq] 12 | [568vq].out 13 | 14 | *.cgo1.go 15 | *.cgo2.c 16 | _cgo_defun.c 17 | _cgo_gotypes.go 18 | _cgo_export.* 19 | 20 | _testmain.go 21 | 22 | *.exe 23 | *.test 24 | *.prof 25 | 26 | cover.out 27 | -------------------------------------------------------------------------------- /vendor/github.com/honeybadger-io/honeybadger-go/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | install: make prepare 3 | -------------------------------------------------------------------------------- /vendor/github.com/honeybadger-io/honeybadger-go/Makefile: -------------------------------------------------------------------------------- 1 | all: test 2 | 3 | prepare: 4 | # dependencies 5 | go get code.google.com/p/go-uuid/uuid 6 | go get github.com/shirou/gopsutil/load 7 | # needed for `make fmt` 8 | go get golang.org/x/tools/cmd/goimports 9 | # linters 10 | go get github.com/alecthomas/gometalinter 11 | gometalinter --install 12 | # needed for `make cover` 13 | go get golang.org/x/tools/cmd/cover 14 | @echo Now you should be ready to run "make" 15 | 16 | test: 17 | @go test -parallel 4 ./... 18 | 19 | # goimports produces slightly different formatted code from go fmt 20 | fmt: 21 | find . -name "*.go" -exec goimports -w {} \; 22 | 23 | lint: 24 | gometalinter 25 | 26 | cover: 27 | go test -cover -coverprofile cover.out 28 | go tool cover -html=cover.out 29 | 30 | .PHONY: all prepare test fmt lint cover 31 | -------------------------------------------------------------------------------- /vendor/github.com/honeybadger-io/honeybadger-go/context.go: -------------------------------------------------------------------------------- 1 | package honeybadger 2 | 3 | // Context is used to send extra data to Honeybadger. 4 | type Context hash 5 | 6 | // Update applies the values in other Context to context. 7 | func (context Context) Update(other Context) { 8 | for k, v := range other { 9 | context[k] = v 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/honeybadger-io/honeybadger-go/context_test.go: -------------------------------------------------------------------------------- 1 | package honeybadger 2 | 3 | import "testing" 4 | 5 | func TestContextUpdate(t *testing.T) { 6 | c := Context{"foo": "bar"} 7 | c.Update(Context{"foo": "baz"}) 8 | if c["foo"] != "baz" { 9 | t.Errorf("Context should update values. expected=%#v actual=%#v", "baz", c["foo"]) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/honeybadger-io/honeybadger-go/worker.go: -------------------------------------------------------------------------------- 1 | package honeybadger 2 | 3 | type envelope func() error 4 | 5 | type worker interface { 6 | Push(envelope) error 7 | Flush() 8 | } 9 | -------------------------------------------------------------------------------- /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_test.go: -------------------------------------------------------------------------------- 1 | package jmespath 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/stretchr/testify/assert" 7 | ) 8 | 9 | func TestValidPrecompiledExpressionSearches(t *testing.T) { 10 | assert := assert.New(t) 11 | data := make(map[string]interface{}) 12 | data["foo"] = "bar" 13 | precompiled, err := Compile("foo") 14 | assert.Nil(err) 15 | result, err := precompiled.Search(data) 16 | assert.Nil(err) 17 | assert.Equal("bar", result) 18 | } 19 | 20 | func TestInvalidPrecompileErrors(t *testing.T) { 21 | assert := assert.New(t) 22 | _, err := Compile("not a valid expression") 23 | assert.NotNil(err) 24 | } 25 | 26 | func TestInvalidMustCompilePanics(t *testing.T) { 27 | defer func() { 28 | r := recover() 29 | assert.NotNil(t, r) 30 | }() 31 | MustCompile("not a valid expression") 32 | } 33 | -------------------------------------------------------------------------------- /vendor/github.com/jmespath/go-jmespath/astnodetype_string.go: -------------------------------------------------------------------------------- 1 | // generated by stringer -type astNodeType; DO NOT EDIT 2 | 3 | package jmespath 4 | 5 | import "fmt" 6 | 7 | const _astNodeType_name = "ASTEmptyASTComparatorASTCurrentNodeASTExpRefASTFunctionExpressionASTFieldASTFilterProjectionASTFlattenASTIdentityASTIndexASTIndexExpressionASTKeyValPairASTLiteralASTMultiSelectHashASTMultiSelectListASTOrExpressionASTAndExpressionASTNotExpressionASTPipeASTProjectionASTSubexpressionASTSliceASTValueProjection" 8 | 9 | var _astNodeType_index = [...]uint16{0, 8, 21, 35, 44, 65, 73, 92, 102, 113, 121, 139, 152, 162, 180, 198, 213, 229, 245, 252, 265, 281, 289, 307} 10 | 11 | func (i astNodeType) String() string { 12 | if i < 0 || i >= astNodeType(len(_astNodeType_index)-1) { 13 | return fmt.Sprintf("astNodeType(%d)", i) 14 | } 15 | return _astNodeType_name[_astNodeType_index[i]:_astNodeType_index[i+1]] 16 | } 17 | -------------------------------------------------------------------------------- /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/jmoiron/sqlx/.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 | tags 24 | environ 25 | -------------------------------------------------------------------------------- /vendor/github.com/jmoiron/sqlx/doc.go: -------------------------------------------------------------------------------- 1 | // Package sqlx provides general purpose extensions to database/sql. 2 | // 3 | // It is intended to seamlessly wrap database/sql and provide convenience 4 | // methods which are useful in the development of database driven applications. 5 | // None of the underlying database/sql methods are changed. Instead all extended 6 | // behavior is implemented through new methods defined on wrapper types. 7 | // 8 | // Additions include scanning into structs, named query support, rebinding 9 | // queries for different drivers, convenient shorthands for common error handling 10 | // and more. 11 | // 12 | package sqlx 13 | -------------------------------------------------------------------------------- /vendor/github.com/jmoiron/sqlx/reflectx/README.md: -------------------------------------------------------------------------------- 1 | # reflectx 2 | 3 | The sqlx package has special reflect needs. In particular, it needs to: 4 | 5 | * be able to map a name to a field 6 | * understand embedded structs 7 | * understand mapping names to fields by a particular tag 8 | * user specified name -> field mapping functions 9 | 10 | These behaviors mimic the behaviors by the standard library marshallers and also the 11 | behavior of standard Go accessors. 12 | 13 | The first two are amply taken care of by `Reflect.Value.FieldByName`, and the third is 14 | addressed by `Reflect.Value.FieldByNameFunc`, but these don't quite understand struct 15 | tags in the ways that are vital to most marshalers, and they are slow. 16 | 17 | This reflectx package extends reflect to achieve these goals. 18 | -------------------------------------------------------------------------------- /vendor/github.com/jmoiron/sqlx/types/README.md: -------------------------------------------------------------------------------- 1 | # types 2 | 3 | The types package provides some useful types which implement the `sql.Scanner` 4 | and `driver.Valuer` interfaces, suitable for use as scan and value targets with 5 | database/sql. 6 | -------------------------------------------------------------------------------- /vendor/github.com/lib/pq/.gitignore: -------------------------------------------------------------------------------- 1 | .db 2 | *.test 3 | *~ 4 | *.swp 5 | -------------------------------------------------------------------------------- /vendor/github.com/lib/pq/certs/README: -------------------------------------------------------------------------------- 1 | This directory contains certificates and private keys for testing some 2 | SSL-related functionality in Travis. Do NOT use these certificates for 3 | anything other than testing. 4 | -------------------------------------------------------------------------------- /vendor/github.com/lib/pq/oid/doc.go: -------------------------------------------------------------------------------- 1 | // Package oid contains OID constants 2 | // as defined by the Postgres server. 3 | package oid 4 | 5 | // Oid is a Postgres Object ID. 6 | type Oid uint32 7 | -------------------------------------------------------------------------------- /vendor/github.com/lib/pq/user_posix.go: -------------------------------------------------------------------------------- 1 | // Package pq is a pure Go Postgres driver for the database/sql package. 2 | 3 | // +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris 4 | 5 | package pq 6 | 7 | import ( 8 | "os" 9 | "os/user" 10 | ) 11 | 12 | func userCurrent() (string, error) { 13 | u, err := user.Current() 14 | if err == nil { 15 | return u.Username, nil 16 | } 17 | 18 | name := os.Getenv("USER") 19 | if name != "" { 20 | return name, nil 21 | } 22 | 23 | return "", ErrCouldNotDetectUsername 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-runewidth/runewidth_js.go: -------------------------------------------------------------------------------- 1 | // +build js 2 | 3 | package runewidth 4 | 5 | func IsEastAsian() bool { 6 | // TODO: Implement this for the web. Detect east asian in a compatible way, and return true. 7 | return false 8 | } 9 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-runewidth/runewidth_windows.go: -------------------------------------------------------------------------------- 1 | package runewidth 2 | 3 | import ( 4 | "syscall" 5 | ) 6 | 7 | var ( 8 | kernel32 = syscall.NewLazyDLL("kernel32") 9 | procGetConsoleOutputCP = kernel32.NewProc("GetConsoleOutputCP") 10 | ) 11 | 12 | // IsEastAsian return true if the current locale is CJK 13 | func IsEastAsian() bool { 14 | r1, _, _ := procGetConsoleOutputCP.Call() 15 | if r1 == 0 { 16 | return false 17 | } 18 | 19 | switch int(r1) { 20 | case 932, 51932, 936, 949, 950: 21 | return true 22 | } 23 | 24 | return false 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-sqlite3/sqlite3_fts5.go: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2014 Yasuhiro Matsumoto . 2 | // 3 | // Use of this source code is governed by an MIT-style 4 | // license that can be found in the LICENSE file. 5 | // +build fts5 6 | 7 | package sqlite3 8 | 9 | /* 10 | #cgo CFLAGS: -DSQLITE_ENABLE_FTS5 11 | #cgo LDFLAGS: -lm 12 | */ 13 | import "C" 14 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-sqlite3/sqlite3_icu.go: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2014 Yasuhiro Matsumoto . 2 | // 3 | // Use of this source code is governed by an MIT-style 4 | // license that can be found in the LICENSE file. 5 | // +build icu 6 | 7 | package sqlite3 8 | 9 | /* 10 | #cgo LDFLAGS: -licuuc -licui18n 11 | #cgo CFLAGS: -DSQLITE_ENABLE_ICU 12 | */ 13 | import "C" 14 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-sqlite3/sqlite3_json1.go: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2014 Yasuhiro Matsumoto . 2 | // 3 | // Use of this source code is governed by an MIT-style 4 | // license that can be found in the LICENSE file. 5 | // +build json1 6 | 7 | package sqlite3 8 | 9 | /* 10 | #cgo CFLAGS: -DSQLITE_ENABLE_JSON1 11 | */ 12 | import "C" 13 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-sqlite3/sqlite3_libsqlite3.go: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2014 Yasuhiro Matsumoto . 2 | // 3 | // Use of this source code is governed by an MIT-style 4 | // license that can be found in the LICENSE file. 5 | // +build libsqlite3 6 | 7 | package sqlite3 8 | 9 | /* 10 | #cgo CFLAGS: -DUSE_LIBSQLITE3 11 | #cgo linux LDFLAGS: -lsqlite3 12 | #cgo darwin LDFLAGS: -L/usr/local/opt/sqlite/lib -lsqlite3 13 | */ 14 | import "C" 15 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-sqlite3/sqlite3_omit_load_extension.go: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2014 Yasuhiro Matsumoto . 2 | // 3 | // Use of this source code is governed by an MIT-style 4 | // license that can be found in the LICENSE file. 5 | // +build sqlite_omit_load_extension 6 | 7 | package sqlite3 8 | 9 | /* 10 | #cgo CFLAGS: -DSQLITE_OMIT_LOAD_EXTENSION 11 | */ 12 | import "C" 13 | import ( 14 | "errors" 15 | ) 16 | 17 | func (c *SQLiteConn) loadExtensions(extensions []string) error { 18 | return errors.New("Extensions have been disabled for static builds") 19 | } 20 | 21 | func (c *SQLiteConn) LoadExtension(lib string, entry string) error { 22 | return errors.New("Extensions have been disabled for static builds") 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-sqlite3/sqlite3_other.go: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2014 Yasuhiro Matsumoto . 2 | // 3 | // Use of this source code is governed by an MIT-style 4 | // license that can be found in the LICENSE file. 5 | // +build !windows 6 | 7 | package sqlite3 8 | 9 | /* 10 | #cgo CFLAGS: -I. 11 | #cgo linux LDFLAGS: -ldl 12 | */ 13 | import "C" 14 | -------------------------------------------------------------------------------- /vendor/github.com/mattn/go-sqlite3/sqlite3_windows.go: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2014 Yasuhiro Matsumoto . 2 | // 3 | // Use of this source code is governed by an MIT-style 4 | // license that can be found in the LICENSE file. 5 | // +build windows 6 | 7 | package sqlite3 8 | 9 | /* 10 | #cgo CFLAGS: -I. -fno-stack-check -fno-stack-protector -mno-stack-arg-probe 11 | #cgo windows,386 CFLAGS: -D_USE_32BIT_TIME_T 12 | #cgo LDFLAGS: -lmingwex -lmingw32 13 | */ 14 | import "C" 15 | -------------------------------------------------------------------------------- /vendor/github.com/olekukonko/tablewriter/test.csv: -------------------------------------------------------------------------------- 1 | first_name,last_name,ssn 2 | John,Barry,123456 3 | Kathy,Smith,687987 4 | Bob,McCornick,3979870 -------------------------------------------------------------------------------- /vendor/github.com/olekukonko/tablewriter/test_info.csv: -------------------------------------------------------------------------------- 1 | Field,Type,Null,Key,Default,Extra 2 | user_id,smallint(5),NO,PRI,NULL,auto_increment 3 | username,varchar(10),NO,,NULL, 4 | password,varchar(100),NO,,NULL, -------------------------------------------------------------------------------- /vendor/github.com/opencontainers/go-digest/digester.go: -------------------------------------------------------------------------------- 1 | package digest 2 | 3 | import "hash" 4 | 5 | // Digester calculates the digest of written data. Writes should go directly 6 | // to the return value of Hash, while calling Digest will return the current 7 | // value of the digest. 8 | type Digester interface { 9 | Hash() hash.Hash // provides direct access to underlying hash instance. 10 | Digest() Digest 11 | } 12 | 13 | // digester provides a simple digester definition that embeds a hasher. 14 | type digester struct { 15 | alg Algorithm 16 | hash hash.Hash 17 | } 18 | 19 | func (d *digester) Hash() hash.Hash { 20 | return d.hash 21 | } 22 | 23 | func (d *digester) Digest() Digest { 24 | return NewDigest(d.alg, d.hash) 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/opencontainers/go-digest/verifiers.go: -------------------------------------------------------------------------------- 1 | package digest 2 | 3 | import ( 4 | "hash" 5 | "io" 6 | ) 7 | 8 | // Verifier presents a general verification interface to be used with message 9 | // digests and other byte stream verifications. Users instantiate a Verifier 10 | // from one of the various methods, write the data under test to it then check 11 | // the result with the Verified method. 12 | type Verifier interface { 13 | io.Writer 14 | 15 | // Verified will return true if the content written to Verifier matches 16 | // the digest. 17 | Verified() bool 18 | } 19 | 20 | type hashVerifier struct { 21 | digest Digest 22 | hash hash.Hash 23 | } 24 | 25 | func (hv hashVerifier) Write(p []byte) (n int, err error) { 26 | return hv.hash.Write(p) 27 | } 28 | 29 | func (hv hashVerifier) Verified() bool { 30 | return hv.digest == NewDigest(hv.digest.Algorithm(), hv.hash) 31 | } 32 | -------------------------------------------------------------------------------- /vendor/github.com/opencontainers/runc/NOTICE: -------------------------------------------------------------------------------- 1 | runc 2 | 3 | Copyright 2012-2015 Docker, Inc. 4 | 5 | This product includes software developed at Docker, Inc. (http://www.docker.com). 6 | 7 | The following is courtesy of our legal counsel: 8 | 9 | 10 | Use and transfer of Docker may be subject to certain restrictions by the 11 | United States and other governments. 12 | It is your responsibility to ensure that your use and/or transfer does not 13 | violate applicable laws. 14 | 15 | For more information, please see http://www.bis.doc.gov 16 | 17 | See also http://www.apache.org/dev/crypto.html and/or seek legal counsel. 18 | -------------------------------------------------------------------------------- /vendor/github.com/opencontainers/runc/libcontainer/system/syscall_linux_32.go: -------------------------------------------------------------------------------- 1 | // +build linux 2 | // +build 386 arm 3 | 4 | package system 5 | 6 | import ( 7 | "golang.org/x/sys/unix" 8 | ) 9 | 10 | // Setuid sets the uid of the calling thread to the specified uid. 11 | func Setuid(uid int) (err error) { 12 | _, _, e1 := unix.RawSyscall(unix.SYS_SETUID32, uintptr(uid), 0, 0) 13 | if e1 != 0 { 14 | err = e1 15 | } 16 | return 17 | } 18 | 19 | // Setgid sets the gid of the calling thread to the specified gid. 20 | func Setgid(gid int) (err error) { 21 | _, _, e1 := unix.RawSyscall(unix.SYS_SETGID32, uintptr(gid), 0, 0) 22 | if e1 != 0 { 23 | err = e1 24 | } 25 | return 26 | } 27 | -------------------------------------------------------------------------------- /vendor/github.com/opencontainers/runc/libcontainer/system/syscall_linux_64.go: -------------------------------------------------------------------------------- 1 | // +build linux 2 | // +build arm64 amd64 mips mipsle mips64 mips64le ppc ppc64 ppc64le s390x 3 | 4 | package system 5 | 6 | import ( 7 | "golang.org/x/sys/unix" 8 | ) 9 | 10 | // Setuid sets the uid of the calling thread to the specified uid. 11 | func Setuid(uid int) (err error) { 12 | _, _, e1 := unix.RawSyscall(unix.SYS_SETUID, uintptr(uid), 0, 0) 13 | if e1 != 0 { 14 | err = e1 15 | } 16 | return 17 | } 18 | 19 | // Setgid sets the gid of the calling thread to the specified gid. 20 | func Setgid(gid int) (err error) { 21 | _, _, e1 := unix.RawSyscall(unix.SYS_SETGID, uintptr(gid), 0, 0) 22 | if e1 != 0 { 23 | err = e1 24 | } 25 | return 26 | } 27 | -------------------------------------------------------------------------------- /vendor/github.com/opencontainers/runc/libcontainer/system/sysconfig.go: -------------------------------------------------------------------------------- 1 | // +build cgo,linux cgo,freebsd 2 | 3 | package system 4 | 5 | /* 6 | #include 7 | */ 8 | import "C" 9 | 10 | func GetClockTicks() int { 11 | return int(C.sysconf(C._SC_CLK_TCK)) 12 | } 13 | -------------------------------------------------------------------------------- /vendor/github.com/opencontainers/runc/libcontainer/system/sysconfig_notcgo.go: -------------------------------------------------------------------------------- 1 | // +build !cgo windows 2 | 3 | package system 4 | 5 | func GetClockTicks() int { 6 | // TODO figure out a better alternative for platforms where we're missing cgo 7 | // 8 | // TODO Windows. This could be implemented using Win32 QueryPerformanceFrequency(). 9 | // https://msdn.microsoft.com/en-us/library/windows/desktop/ms644905(v=vs.85).aspx 10 | // 11 | // An example of its usage can be found here. 12 | // https://msdn.microsoft.com/en-us/library/windows/desktop/dn553408(v=vs.85).aspx 13 | 14 | return 100 15 | } 16 | -------------------------------------------------------------------------------- /vendor/github.com/opencontainers/runc/libcontainer/system/unsupported.go: -------------------------------------------------------------------------------- 1 | // +build !linux 2 | 3 | package system 4 | 5 | // RunningInUserNS is a stub for non-Linux systems 6 | // Always returns false 7 | func RunningInUserNS() bool { 8 | return false 9 | } 10 | -------------------------------------------------------------------------------- /vendor/github.com/remind101/newrelic/Dockerfile: -------------------------------------------------------------------------------- 1 | FROM remind101/go:1.4-newrelic 2 | 3 | COPY . /go/src/github.com/remind101/newrelic 4 | 5 | WORKDIR /go/src/github.com/remind101/newrelic 6 | 7 | RUN go-wrapper download -tags newrelic_enabled ./... 8 | RUN go-wrapper install -tags newrelic_enabled ./... -------------------------------------------------------------------------------- /vendor/github.com/remind101/newrelic/Makefile: -------------------------------------------------------------------------------- 1 | .PHONY: build test docker docker_test 2 | 3 | build: 4 | go build . 5 | 6 | test: build 7 | go test -tags newrelic_enabled -v ./... 8 | 9 | docker: 10 | docker build -t remind101/newrelic . 11 | 12 | docker_test: docker 13 | docker run remind101/newrelic bash -c "cd /go/src/github.com/remind101/newrelic && make test" 14 | -------------------------------------------------------------------------------- /vendor/github.com/remind101/newrelic/circle.yml: -------------------------------------------------------------------------------- 1 | machine: 2 | services: 3 | - docker 4 | 5 | dependencies: 6 | override: 7 | - make docker 8 | 9 | test: 10 | override: 11 | - make docker_test 12 | -------------------------------------------------------------------------------- /vendor/github.com/remind101/newrelic/newrelic_test.go: -------------------------------------------------------------------------------- 1 | package newrelic 2 | 3 | import "testing" 4 | 5 | func TestNew(t *testing.T) { 6 | Init("Test App", "") 7 | } 8 | -------------------------------------------------------------------------------- /vendor/github.com/remind101/newrelic/recorder_newrelic_disabled.go: -------------------------------------------------------------------------------- 1 | // +build !newrelic_enabled 2 | 3 | package newrelic 4 | 5 | import "time" 6 | 7 | type recorder struct { 8 | interval time.Duration 9 | } 10 | 11 | func newRecorder(interval time.Duration) *recorder { 12 | return &recorder{interval: interval} 13 | } 14 | 15 | func (r *recorder) Interval() time.Duration { 16 | return r.interval 17 | } 18 | 19 | func (r *recorder) Record() error { 20 | return nil 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/remind101/newrelic/recorder_newrelic_enabled.go: -------------------------------------------------------------------------------- 1 | // +build newrelic_enabled 2 | 3 | package newrelic 4 | 5 | import ( 6 | "runtime" 7 | "time" 8 | 9 | "github.com/remind101/newrelic/sdk" 10 | ) 11 | 12 | // recorder is the default implementation of the Recorder interface. It 13 | // records CPU and Memory metrics. 14 | type recorder struct { 15 | interval time.Duration 16 | } 17 | 18 | func newRecorder(interval time.Duration) *recorder { 19 | return &recorder{interval: interval} 20 | } 21 | 22 | func (r *recorder) Interval() time.Duration { 23 | return r.interval 24 | } 25 | 26 | func (r *recorder) Record() error { 27 | return recordMemory() 28 | } 29 | 30 | func recordMemory() error { 31 | m := &runtime.MemStats{} 32 | runtime.ReadMemStats(m) 33 | mb := float64(m.Alloc) / (1024 * 1024) 34 | _, err := sdk.RecordMemoryUsage(mb) 35 | return err 36 | } 37 | -------------------------------------------------------------------------------- /vendor/github.com/remind101/newrelic/reporter_newrelic_disabled.go: -------------------------------------------------------------------------------- 1 | // +build !newrelic_enabled 2 | 3 | package newrelic 4 | 5 | type NRTxReporter struct{} 6 | 7 | func (r *NRTxReporter) ReportError(txnID int64, exceptionType, errorMessage, stackTrace, stackFrameDelim string) (int, error) { 8 | return 0, nil 9 | } 10 | 11 | func (r *NRTxReporter) ReportCustomMetric(name string, value float64) (int, error) { 12 | return 0, nil 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/remind101/newrelic/reporter_newrelic_enabled.go: -------------------------------------------------------------------------------- 1 | // +build newrelic_enabled 2 | 3 | package newrelic 4 | 5 | import ( 6 | "github.com/remind101/newrelic/sdk" 7 | ) 8 | 9 | type NRTxReporter struct{} 10 | 11 | func (r *NRTxReporter) ReportError(txnID int64, exceptionType, errorMessage, stackTrace, stackFrameDelim string) (int, error) { 12 | return sdk.TransactionNoticeError(txnID, exceptionType, errorMessage, stackTrace, stackFrameDelim) 13 | } 14 | 15 | func (r *NRTxReporter) ReportCustomMetric(name string, value float64) (int, error) { 16 | return sdk.RecordMetric(name, value) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/remind101/pkg/logger/example_test.go: -------------------------------------------------------------------------------- 1 | package logger 2 | 3 | import ( 4 | "log" 5 | "os" 6 | ) 7 | 8 | func ExampleLogger_Log() { 9 | l := New(log.New(os.Stdout, "", 0)) 10 | 11 | // Consecutive arguments after the message are treated as key value pairs. 12 | l.Info("message", "key", "value") 13 | 14 | // Output: 15 | // message key=value 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/remind101/pkg/reporter/fallback.go: -------------------------------------------------------------------------------- 1 | package reporter 2 | 3 | import "golang.org/x/net/context" 4 | 5 | type FallbackReporter struct { 6 | // The first reporter to call. 7 | Reporter Reporter 8 | 9 | // This reporter will be used to report an error if the first Reporter 10 | // fails for some reason. 11 | Fallback Reporter 12 | } 13 | 14 | func (r *FallbackReporter) Report(ctx context.Context, err error) error { 15 | if err2 := r.Reporter.Report(ctx, err); err2 != nil { 16 | r.Fallback.Report(ctx, err2) 17 | return err2 18 | } 19 | 20 | return nil 21 | } 22 | -------------------------------------------------------------------------------- /vendor/github.com/remind101/pkg/reporter/fallback_test.go: -------------------------------------------------------------------------------- 1 | package reporter 2 | 3 | import ( 4 | "errors" 5 | "testing" 6 | 7 | "golang.org/x/net/context" 8 | ) 9 | 10 | func TestFallback(t *testing.T) { 11 | var called bool 12 | 13 | errTimeout := errors.New("net: timeout") 14 | 15 | r := &FallbackReporter{ 16 | Reporter: ReporterFunc(func(ctx context.Context, err error) error { 17 | return errTimeout 18 | }), 19 | Fallback: ReporterFunc(func(ctx context.Context, err error) error { 20 | called = true 21 | 22 | if got, want := err, errTimeout; got != want { 23 | t.Fatalf("err => %v; want %v", got, want) 24 | } 25 | 26 | return nil 27 | }), 28 | } 29 | 30 | r.Report(context.Background(), errBoom) 31 | 32 | if !called { 33 | t.Fatal("fallback not called") 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /vendor/github.com/remind101/pkg/reporter/multi.go: -------------------------------------------------------------------------------- 1 | package reporter 2 | 3 | import "golang.org/x/net/context" 4 | 5 | // MultiReporter is an implementation of the Reporter interface that reports the 6 | // error to multiple Reporters. If any of the individual error reporters returns 7 | // an error, a MutliError will be returned. 8 | type MultiReporter []Reporter 9 | 10 | func (r MultiReporter) Report(ctx context.Context, err error) error { 11 | var errors []error 12 | 13 | for _, reporter := range r { 14 | if err2 := reporter.Report(ctx, err); err2 != nil { 15 | errors = append(errors, err2) 16 | } 17 | } 18 | 19 | if len(errors) == 0 { 20 | return nil 21 | } 22 | 23 | return &MultiError{Errors: errors} 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/remind101/pkg/reporter/util/util.go: -------------------------------------------------------------------------------- 1 | package util 2 | 3 | import ( 4 | "reflect" 5 | "runtime" 6 | ) 7 | 8 | func ClassName(err error) string { 9 | return reflect.TypeOf(err).String() 10 | } 11 | 12 | func FunctionName(pc uintptr) string { 13 | fn := runtime.FuncForPC(pc) 14 | if fn == nil { 15 | return "???" 16 | } 17 | return fn.Name() 18 | } 19 | -------------------------------------------------------------------------------- /vendor/github.com/remind101/pkg/stream/stream.go: -------------------------------------------------------------------------------- 1 | // Package stream provides types that make it easier to perform streaming io. 2 | package stream 3 | 4 | import ( 5 | "fmt" 6 | "io" 7 | "time" 8 | ) 9 | 10 | // Heartbeat sends the null character periodically, to keep the connection alive. 11 | func Heartbeat(outStream io.Writer, interval time.Duration) chan struct{} { 12 | stop := make(chan struct{}) 13 | t := time.NewTicker(interval) 14 | 15 | go func() { 16 | for { 17 | select { 18 | case <-t.C: 19 | fmt.Fprintf(outStream, "\x00") 20 | continue 21 | case <-stop: 22 | t.Stop() 23 | return 24 | } 25 | } 26 | }() 27 | 28 | return stop 29 | } 30 | -------------------------------------------------------------------------------- /vendor/github.com/remind101/pkg/stream/stream_test.go: -------------------------------------------------------------------------------- 1 | package stream 2 | 3 | import ( 4 | "os" 5 | "time" 6 | ) 7 | 8 | func ExampleHeartbeat() { 9 | w := os.Stdout 10 | defer close(Heartbeat(w, time.Second)) // close to cleanup resources 11 | } 12 | -------------------------------------------------------------------------------- /vendor/github.com/rubenv/sql-migrate/.gitignore: -------------------------------------------------------------------------------- 1 | .*.swp 2 | *.test 3 | 4 | /sql-migrate/test.db 5 | /test.db 6 | -------------------------------------------------------------------------------- /vendor/github.com/rubenv/sql-migrate/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | go: 4 | - 1.2 5 | - 1.3 6 | - 1.4 7 | - tip 8 | 9 | services: 10 | - mysql 11 | 12 | before_install: 13 | - mysql -e "CREATE DATABASE IF NOT EXISTS test;" -uroot 14 | - psql -c "CREATE DATABASE test;" -U postgres 15 | 16 | install: 17 | - go get -t ./... 18 | - go install ./... 19 | 20 | script: 21 | - go test -v ./... 22 | - bash test-integration/postgres.sh 23 | - bash test-integration/mysql.sh 24 | - bash test-integration/mysql-flag.sh 25 | - bash test-integration/sqlite.sh 26 | -------------------------------------------------------------------------------- /vendor/github.com/rubenv/sql-migrate/sql-migrate/mssql.go: -------------------------------------------------------------------------------- 1 | // +build go1.3 2 | 3 | package main 4 | 5 | import ( 6 | _ "github.com/denisenkom/go-mssqldb" 7 | "gopkg.in/gorp.v1" 8 | ) 9 | 10 | func init() { 11 | dialects["mssql"] = gorp.SqlServerDialect{} 12 | } 13 | -------------------------------------------------------------------------------- /vendor/github.com/rubenv/sql-migrate/test-integration/dbconfig.yml: -------------------------------------------------------------------------------- 1 | postgres: 2 | dialect: postgres 3 | datasource: dbname=test sslmode=disable 4 | dir: test-migrations 5 | 6 | mysql: 7 | dialect: mysql 8 | datasource: root@/test?parseTime=true 9 | dir: test-migrations 10 | 11 | mysql_noflag: 12 | dialect: mysql 13 | datasource: root@/test 14 | dir: test-migrations 15 | 16 | sqlite: 17 | dialect: sqlite3 18 | datasource: test.db 19 | dir: test-migrations 20 | table: migrations 21 | -------------------------------------------------------------------------------- /vendor/github.com/rubenv/sql-migrate/test-integration/mysql-flag.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Tweak PATH for Travis 4 | export PATH=$PATH:$HOME/gopath/bin 5 | 6 | OPTIONS="-config=test-integration/dbconfig.yml -env mysql_noflag" 7 | 8 | set -ex 9 | 10 | sql-migrate status $OPTIONS | grep -q "Make sure that the parseTime option is supplied" 11 | -------------------------------------------------------------------------------- /vendor/github.com/rubenv/sql-migrate/test-integration/mysql.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Tweak PATH for Travis 4 | export PATH=$PATH:$HOME/gopath/bin 5 | 6 | OPTIONS="-config=test-integration/dbconfig.yml -env mysql" 7 | 8 | set -ex 9 | 10 | sql-migrate status $OPTIONS 11 | sql-migrate up $OPTIONS 12 | sql-migrate down $OPTIONS 13 | sql-migrate redo $OPTIONS 14 | sql-migrate status $OPTIONS 15 | -------------------------------------------------------------------------------- /vendor/github.com/rubenv/sql-migrate/test-integration/postgres.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Tweak PATH for Travis 4 | export PATH=$PATH:$HOME/gopath/bin 5 | 6 | OPTIONS="-config=test-integration/dbconfig.yml -env postgres" 7 | 8 | set -ex 9 | 10 | sql-migrate status $OPTIONS 11 | sql-migrate up $OPTIONS 12 | sql-migrate down $OPTIONS 13 | sql-migrate redo $OPTIONS 14 | sql-migrate status $OPTIONS 15 | -------------------------------------------------------------------------------- /vendor/github.com/rubenv/sql-migrate/test-integration/sqlite.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Tweak PATH for Travis 4 | export PATH=$PATH:$HOME/gopath/bin 5 | 6 | OPTIONS="-config=test-integration/dbconfig.yml -env sqlite" 7 | 8 | set -ex 9 | 10 | sql-migrate status $OPTIONS 11 | sql-migrate up $OPTIONS 12 | sql-migrate down $OPTIONS 13 | sql-migrate redo $OPTIONS 14 | sql-migrate status $OPTIONS 15 | 16 | # Should have used the custom migrations table 17 | sqlite3 test.db "SELECT COUNT(*) FROM migrations" 18 | -------------------------------------------------------------------------------- /vendor/github.com/rubenv/sql-migrate/test-migrations/1_initial.sql: -------------------------------------------------------------------------------- 1 | -- +migrate Up 2 | -- SQL in section 'Up' is executed when this migration is applied 3 | CREATE TABLE people (id int); 4 | 5 | 6 | -- +migrate Down 7 | -- SQL section 'Down' is executed when this migration is rolled back 8 | DROP TABLE people; 9 | -------------------------------------------------------------------------------- /vendor/github.com/rubenv/sql-migrate/test-migrations/2_record.sql: -------------------------------------------------------------------------------- 1 | -- +migrate Up 2 | INSERT INTO people (id) VALUES (1); 3 | 4 | -- +migrate Down 5 | DELETE FROM people WHERE id=1; 6 | -------------------------------------------------------------------------------- /vendor/github.com/shirou/gopsutil/load/load.go: -------------------------------------------------------------------------------- 1 | package load 2 | 3 | import ( 4 | "encoding/json" 5 | ) 6 | 7 | type LoadAvgStat struct { 8 | Load1 float64 `json:"load1"` 9 | Load5 float64 `json:"load5"` 10 | Load15 float64 `json:"load15"` 11 | } 12 | 13 | func (l LoadAvgStat) String() string { 14 | s, _ := json.Marshal(l) 15 | return string(s) 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/shirou/gopsutil/load/load_darwin.go: -------------------------------------------------------------------------------- 1 | // +build darwin 2 | 3 | package load 4 | 5 | import ( 6 | "strconv" 7 | 8 | common "github.com/shirou/gopsutil/common" 9 | ) 10 | 11 | func LoadAvg() (*LoadAvgStat, error) { 12 | values, err := common.DoSysctrl("vm.loadavg") 13 | if err != nil { 14 | return nil, err 15 | } 16 | 17 | load1, err := strconv.ParseFloat(values[0], 64) 18 | if err != nil { 19 | return nil, err 20 | } 21 | load5, err := strconv.ParseFloat(values[1], 64) 22 | if err != nil { 23 | return nil, err 24 | } 25 | load15, err := strconv.ParseFloat(values[2], 64) 26 | if err != nil { 27 | return nil, err 28 | } 29 | 30 | ret := &LoadAvgStat{ 31 | Load1: float64(load1), 32 | Load5: float64(load5), 33 | Load15: float64(load15), 34 | } 35 | 36 | return ret, nil 37 | } 38 | -------------------------------------------------------------------------------- /vendor/github.com/shirou/gopsutil/load/load_freebsd.go: -------------------------------------------------------------------------------- 1 | // +build freebsd 2 | 3 | package load 4 | 5 | import ( 6 | "strconv" 7 | 8 | common "github.com/shirou/gopsutil/common" 9 | ) 10 | 11 | func LoadAvg() (*LoadAvgStat, error) { 12 | values, err := common.DoSysctrl("vm.loadavg") 13 | if err != nil { 14 | return nil, err 15 | } 16 | 17 | load1, err := strconv.ParseFloat(values[0], 64) 18 | if err != nil { 19 | return nil, err 20 | } 21 | load5, err := strconv.ParseFloat(values[1], 64) 22 | if err != nil { 23 | return nil, err 24 | } 25 | load15, err := strconv.ParseFloat(values[2], 64) 26 | if err != nil { 27 | return nil, err 28 | } 29 | 30 | ret := &LoadAvgStat{ 31 | Load1: float64(load1), 32 | Load5: float64(load5), 33 | Load15: float64(load15), 34 | } 35 | 36 | return ret, nil 37 | } 38 | -------------------------------------------------------------------------------- /vendor/github.com/shirou/gopsutil/load/load_linux.go: -------------------------------------------------------------------------------- 1 | // +build linux 2 | 3 | package load 4 | 5 | import ( 6 | "io/ioutil" 7 | "strconv" 8 | "strings" 9 | ) 10 | 11 | func LoadAvg() (*LoadAvgStat, error) { 12 | filename := "/proc/loadavg" 13 | line, err := ioutil.ReadFile(filename) 14 | if err != nil { 15 | return nil, err 16 | } 17 | 18 | values := strings.Fields(string(line)) 19 | 20 | load1, err := strconv.ParseFloat(values[0], 64) 21 | if err != nil { 22 | return nil, err 23 | } 24 | load5, err := strconv.ParseFloat(values[1], 64) 25 | if err != nil { 26 | return nil, err 27 | } 28 | load15, err := strconv.ParseFloat(values[2], 64) 29 | if err != nil { 30 | return nil, err 31 | } 32 | 33 | ret := &LoadAvgStat{ 34 | Load1: load1, 35 | Load5: load5, 36 | Load15: load15, 37 | } 38 | 39 | return ret, nil 40 | } 41 | -------------------------------------------------------------------------------- /vendor/github.com/shirou/gopsutil/load/load_test.go: -------------------------------------------------------------------------------- 1 | package load 2 | 3 | import ( 4 | "fmt" 5 | "testing" 6 | ) 7 | 8 | func TestLoad(t *testing.T) { 9 | v, err := LoadAvg() 10 | if err != nil { 11 | t.Errorf("error %v", err) 12 | } 13 | 14 | empty := &LoadAvgStat{} 15 | if v == empty { 16 | t.Errorf("error load: %v", v) 17 | } 18 | } 19 | 20 | func TestLoadAvgStat_String(t *testing.T) { 21 | v := LoadAvgStat{ 22 | Load1: 10.1, 23 | Load5: 20.1, 24 | Load15: 30.1, 25 | } 26 | e := `{"load1":10.1,"load5":20.1,"load15":30.1}` 27 | if e != fmt.Sprintf("%v", v) { 28 | t.Errorf("LoadAvgStat string is invalid: %v", v) 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /vendor/github.com/shirou/gopsutil/load/load_windows.go: -------------------------------------------------------------------------------- 1 | // +build windows 2 | 3 | package load 4 | 5 | import ( 6 | common "github.com/shirou/gopsutil/common" 7 | ) 8 | 9 | func LoadAvg() (*LoadAvgStat, error) { 10 | ret := LoadAvgStat{} 11 | 12 | return &ret, common.NotImplementedError 13 | } 14 | -------------------------------------------------------------------------------- /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/terminal_bsd.go: -------------------------------------------------------------------------------- 1 | // +build darwin freebsd openbsd netbsd dragonfly 2 | // +build !appengine 3 | 4 | package logrus 5 | 6 | import "golang.org/x/sys/unix" 7 | 8 | const ioctlReadTermios = unix.TIOCGETA 9 | 10 | type Termios unix.Termios 11 | -------------------------------------------------------------------------------- /vendor/github.com/sirupsen/logrus/terminal_linux.go: -------------------------------------------------------------------------------- 1 | // Based on ssh/terminal: 2 | // Copyright 2013 The Go Authors. All rights reserved. 3 | // Use of this source code is governed by a BSD-style 4 | // license that can be found in the LICENSE file. 5 | 6 | // +build !appengine 7 | 8 | package logrus 9 | 10 | import "golang.org/x/sys/unix" 11 | 12 | const ioctlReadTermios = unix.TCGETS 13 | 14 | type Termios unix.Termios 15 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/objx/.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/stretchr/objx/README.md: -------------------------------------------------------------------------------- 1 | # objx 2 | 3 | * Jump into the [API Documentation](http://godoc.org/github.com/stretchr/objx) 4 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/objx/codegen/array-access.txt: -------------------------------------------------------------------------------- 1 | case []{1}: 2 | a := object.([]{1}) 3 | if isSet { 4 | a[index] = value.({1}) 5 | } else { 6 | if index >= len(a) { 7 | if panics { 8 | panic(fmt.Sprintf("objx: Index %d is out of range because the []{1} only contains %d items.", index, len(a))) 9 | } 10 | return nil 11 | } else { 12 | return a[index] 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/objx/codegen/types_list.txt: -------------------------------------------------------------------------------- 1 | Interface,interface{},"something",nil,Inter 2 | Map,map[string]interface{},map[string]interface{}{"name":"Tyler"},nil,MSI 3 | ObjxMap,(Map),New(1),New(nil),ObjxMap 4 | Bool,bool,true,false,Bool 5 | String,string,"hello","",Str 6 | Int,int,1,0,Int 7 | Int8,int8,1,0,Int8 8 | Int16,int16,1,0,Int16 9 | Int32,int32,1,0,Int32 10 | Int64,int64,1,0,Int64 11 | Uint,uint,1,0,Uint 12 | Uint8,uint8,1,0,Uint8 13 | Uint16,uint16,1,0,Uint16 14 | Uint32,uint32,1,0,Uint32 15 | Uint64,uint64,1,0,Uint64 16 | Uintptr,uintptr,1,0,Uintptr 17 | Float32,float32,1,0,Float32 18 | Float64,float64,1,0,Float64 19 | Complex64,complex64,1,0,Complex64 20 | Complex128,complex128,1,0,Complex128 21 | -------------------------------------------------------------------------------- /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/map_for_test.go: -------------------------------------------------------------------------------- 1 | package objx 2 | 3 | var TestMap map[string]interface{} = map[string]interface{}{ 4 | "name": "Tyler", 5 | "address": map[string]interface{}{ 6 | "city": "Salt Lake City", 7 | "state": "UT", 8 | }, 9 | "numbers": []interface{}{"one", "two", "three", "four", "five"}, 10 | } 11 | -------------------------------------------------------------------------------- /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 9 | // key. 10 | func HashWithKey(data, key string) string { 11 | hash := sha1.New() 12 | hash.Write([]byte(data + ":" + key)) 13 | return hex.EncodeToString(hash.Sum(nil)) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/objx/security_test.go: -------------------------------------------------------------------------------- 1 | package objx 2 | 3 | import ( 4 | "github.com/stretchr/testify/assert" 5 | "testing" 6 | ) 7 | 8 | func TestHashWithKey(t *testing.T) { 9 | 10 | assert.Equal(t, "0ce84d8d01f2c7b6e0882b784429c54d280ea2d9", HashWithKey("abc", "def")) 11 | 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/objx/tests_test.go: -------------------------------------------------------------------------------- 1 | package objx 2 | 3 | import ( 4 | "github.com/stretchr/testify/assert" 5 | "testing" 6 | ) 7 | 8 | func TestHas(t *testing.T) { 9 | 10 | m := New(TestMap) 11 | 12 | assert.True(t, m.Has("name")) 13 | assert.True(t, m.Has("address.state")) 14 | assert.True(t, m.Has("numbers[4]")) 15 | 16 | assert.False(t, m.Has("address.state.nope")) 17 | assert.False(t, m.Has("address.nope")) 18 | assert.False(t, m.Has("nope")) 19 | assert.False(t, m.Has("numbers[5]")) 20 | 21 | m = nil 22 | assert.False(t, m.Has("nothing")) 23 | 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/objx/value.go: -------------------------------------------------------------------------------- 1 | package objx 2 | 3 | // Value provides methods for extracting interface{} data in various 4 | // types. 5 | type Value struct { 6 | // data contains the raw data being managed by this Value 7 | data interface{} 8 | } 9 | 10 | // Data returns the raw data contained by this Value 11 | func (v *Value) Data() interface{} { 12 | return v.data 13 | } 14 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/objx/value_test.go: -------------------------------------------------------------------------------- 1 | package objx 2 | -------------------------------------------------------------------------------- /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/require/forward_requirements.go: -------------------------------------------------------------------------------- 1 | package require 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=require -template=require_forward.go.tmpl 17 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/testify/require/require.go.tmpl: -------------------------------------------------------------------------------- 1 | {{.Comment}} 2 | func {{.DocInfo.Name}}(t TestingT, {{.Params}}) { 3 | if !assert.{{.DocInfo.Name}}(t, {{.ForwardedParams}}) { 4 | t.FailNow() 5 | } 6 | } 7 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/testify/require/require_forward.go.tmpl: -------------------------------------------------------------------------------- 1 | {{.CommentWithoutT "a"}} 2 | func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) { 3 | {{.DocInfo.Name}}(a.t, {{.ForwardedParams}}) 4 | } 5 | -------------------------------------------------------------------------------- /vendor/github.com/stretchr/testify/require/requirements.go: -------------------------------------------------------------------------------- 1 | package require 2 | 3 | // TestingT is an interface wrapper around *testing.T 4 | type TestingT interface { 5 | Errorf(format string, args ...interface{}) 6 | FailNow() 7 | } 8 | 9 | //go:generate go run ../_codegen/main.go -output-package=require -template=require.go.tmpl 10 | -------------------------------------------------------------------------------- /vendor/github.com/vaughan0/go-ini/test.ini: -------------------------------------------------------------------------------- 1 | [default] 2 | stuff = things 3 | -------------------------------------------------------------------------------- /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/context/ctxhttp/ctxhttp_17_test.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 !plan9,go1.7 6 | 7 | package ctxhttp 8 | 9 | import ( 10 | "io" 11 | "net/http" 12 | "net/http/httptest" 13 | "testing" 14 | 15 | "context" 16 | ) 17 | 18 | func TestGo17Context(t *testing.T) { 19 | ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 20 | io.WriteString(w, "ok") 21 | })) 22 | defer ts.Close() 23 | ctx := context.Background() 24 | resp, err := Get(ctx, http.DefaultClient, ts.URL) 25 | if resp == nil || err != nil { 26 | t.Fatalf("error received from client: %v %v", err, resp) 27 | } 28 | resp.Body.Close() 29 | } 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/context/withtimeout_test.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 | package context_test 6 | 7 | import ( 8 | "fmt" 9 | "time" 10 | 11 | "golang.org/x/net/context" 12 | ) 13 | 14 | func ExampleWithTimeout() { 15 | // Pass a context with a timeout to tell a blocking function that it 16 | // should abandon its work after the timeout elapses. 17 | ctx, _ := context.WithTimeout(context.Background(), 100*time.Millisecond) 18 | select { 19 | case <-time.After(200 * time.Millisecond): 20 | fmt.Println("overslept") 21 | case <-ctx.Done(): 22 | fmt.Println(ctx.Err()) // prints "context deadline exceeded" 23 | } 24 | // Output: 25 | // context deadline exceeded 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/Makefile: -------------------------------------------------------------------------------- 1 | curlimage: 2 | docker build -t gohttp2/curl . 3 | 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/README: -------------------------------------------------------------------------------- 1 | This is a work-in-progress HTTP/2 implementation for Go. 2 | 3 | It will eventually live in the Go standard library and won't require 4 | any changes to your code to use. It will just be automatic. 5 | 6 | Status: 7 | 8 | * The server support is pretty good. A few things are missing 9 | but are being worked on. 10 | * The client work has just started but shares a lot of code 11 | is coming along much quicker. 12 | 13 | Docs are at https://godoc.org/golang.org/x/net/http2 14 | 15 | Demo test server at https://http2.golang.org/ 16 | 17 | Help & bug reports welcome! 18 | 19 | Contributing: https://golang.org/doc/contribute.html 20 | Bugs: https://golang.org/issue/new?title=x/net/http2:+ 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/errors_test.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 | package http2 6 | 7 | import "testing" 8 | 9 | func TestErrCodeString(t *testing.T) { 10 | tests := []struct { 11 | err ErrCode 12 | want string 13 | }{ 14 | {ErrCodeProtocol, "PROTOCOL_ERROR"}, 15 | {0xd, "HTTP_1_1_REQUIRED"}, 16 | {0xf, "unknown error code 0xf"}, 17 | } 18 | for i, tt := range tests { 19 | got := tt.err.String() 20 | if got != tt.want { 21 | t.Errorf("%d. Error = %q; want %q", i, got, tt.want) 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/go16.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build go1.6 6 | 7 | package http2 8 | 9 | import ( 10 | "net/http" 11 | "time" 12 | ) 13 | 14 | func transportExpectContinueTimeout(t1 *http.Transport) time.Duration { 15 | return t1.ExpectContinueTimeout 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/go19.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build go1.9 6 | 7 | package http2 8 | 9 | import ( 10 | "net/http" 11 | ) 12 | 13 | func configureServer19(s *http.Server, conf *Server) error { 14 | s.RegisterOnShutdown(conf.state.startGracefulShutdown) 15 | return nil 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/not_go16.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !go1.6 6 | 7 | package http2 8 | 9 | import ( 10 | "net/http" 11 | "time" 12 | ) 13 | 14 | func configureTransport(t1 *http.Transport) (*Transport, error) { 15 | return nil, errTransportVersion 16 | } 17 | 18 | func transportExpectContinueTimeout(t1 *http.Transport) time.Duration { 19 | return 0 20 | 21 | } 22 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/not_go18.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !go1.8 6 | 7 | package http2 8 | 9 | import ( 10 | "io" 11 | "net/http" 12 | ) 13 | 14 | func configureServer18(h1 *http.Server, h2 *Server) error { 15 | // No IdleTimeout to sync prior to Go 1.8. 16 | return nil 17 | } 18 | 19 | func shouldLogPanic(panicValue interface{}) bool { 20 | return panicValue != nil 21 | } 22 | 23 | func reqGetBody(req *http.Request) func() (io.ReadCloser, error) { 24 | return nil 25 | } 26 | 27 | func reqBodyIsNoBody(io.ReadCloser) bool { return false } 28 | 29 | func go18httpNoBody() io.ReadCloser { return nil } // for tests only 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/http2/not_go19.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !go1.9 6 | 7 | package http2 8 | 9 | import ( 10 | "net/http" 11 | ) 12 | 13 | func configureServer19(s *http.Server, conf *Server) error { 14 | // not supported prior to go1.9 15 | return nil 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/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 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 appengine appenginevm 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/facebook/facebook.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 | // Package facebook provides constants for using OAuth2 to access Facebook. 6 | package facebook 7 | 8 | import ( 9 | "golang.org/x/oauth2" 10 | ) 11 | 12 | // Endpoint is Facebook's OAuth 2.0 endpoint. 13 | var Endpoint = oauth2.Endpoint{ 14 | AuthURL: "https://www.facebook.com/dialog/oauth", 15 | TokenURL: "https://graph.facebook.com/oauth/access_token", 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/oauth2/github/github.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014 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 | // Package github provides constants for using OAuth2 to access Github. 6 | package github 7 | 8 | import ( 9 | "golang.org/x/oauth2" 10 | ) 11 | 12 | // Endpoint is Github's OAuth 2.0 endpoint. 13 | var Endpoint = oauth2.Endpoint{ 14 | AuthURL: "https://github.com/login/oauth/authorize", 15 | TokenURL: "https://github.com/login/oauth/access_token", 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/oauth2/google/appengine_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 appengine appenginevm 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/testdata/gcloud/properties: -------------------------------------------------------------------------------- 1 | [core] 2 | account = bar@example.com -------------------------------------------------------------------------------- /vendor/golang.org/x/oauth2/internal/token_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014 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 | // Package internal contains support packages for oauth2 package. 6 | package internal 7 | 8 | import ( 9 | "fmt" 10 | "testing" 11 | ) 12 | 13 | func Test_providerAuthHeaderWorks(t *testing.T) { 14 | for _, p := range brokenAuthHeaderProviders { 15 | if providerAuthHeaderWorks(p) { 16 | t.Errorf("URL: %s not found in list", p) 17 | } 18 | p := fmt.Sprintf("%ssomesuffix", p) 19 | if providerAuthHeaderWorks(p) { 20 | t.Errorf("URL: %s not found in list", p) 21 | } 22 | } 23 | p := "https://api.not-in-the-list-example.com/" 24 | if !providerAuthHeaderWorks(p) { 25 | t.Errorf("URL: %s found in list", p) 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /vendor/golang.org/x/oauth2/linkedin/linkedin.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 | // Package linkedin provides constants for using OAuth2 to access LinkedIn. 6 | package linkedin 7 | 8 | import ( 9 | "golang.org/x/oauth2" 10 | ) 11 | 12 | // Endpoint is LinkedIn's OAuth 2.0 endpoint. 13 | var Endpoint = oauth2.Endpoint{ 14 | AuthURL: "https://www.linkedin.com/uas/oauth2/authorization", 15 | TokenURL: "https://www.linkedin.com/uas/oauth2/accessToken", 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/oauth2/odnoklassniki/odnoklassniki.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 | // Package odnoklassniki provides constants for using OAuth2 to access Odnoklassniki. 6 | package odnoklassniki 7 | 8 | import ( 9 | "golang.org/x/oauth2" 10 | ) 11 | 12 | // Endpoint is Odnoklassniki's OAuth 2.0 endpoint. 13 | var Endpoint = oauth2.Endpoint{ 14 | AuthURL: "https://www.odnoklassniki.ru/oauth/authorize", 15 | TokenURL: "https://api.odnoklassniki.ru/oauth/token.do", 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/oauth2/vk/vk.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 | // Package vk provides constants for using OAuth2 to access VK.com. 6 | package vk 7 | 8 | import ( 9 | "golang.org/x/oauth2" 10 | ) 11 | 12 | // Endpoint is VK's OAuth 2.0 endpoint. 13 | var Endpoint = oauth2.Endpoint{ 14 | AuthURL: "https://oauth.vk.com/authorize", 15 | TokenURL: "https://oauth.vk.com/access_token", 16 | } 17 | -------------------------------------------------------------------------------- /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-64 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-88 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-112 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-64 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-88 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_linux_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 calls for AMD64, Linux 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 ·RawSyscall(SB),NOSPLIT,$0-56 23 | JMP syscall·RawSyscall(SB) 24 | 25 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 26 | JMP syscall·RawSyscall6(SB) 27 | 28 | TEXT ·gettimeofday(SB),NOSPLIT,$0-16 29 | JMP syscall·gettimeofday(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_linux_arm.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 calls for arm, Linux 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 ·RawSyscall(SB),NOSPLIT,$0-28 23 | B syscall·RawSyscall(SB) 24 | 25 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 26 | B syscall·RawSyscall6(SB) 27 | 28 | TEXT ·seek(SB),NOSPLIT,$0-32 29 | B syscall·seek(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_linux_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 linux 6 | // +build arm64 7 | // +build !gccgo 8 | 9 | #include "textflag.h" 10 | 11 | // Just jump to package syscall's implementation for all these functions. 12 | // The runtime may know about them. 13 | 14 | TEXT ·Syscall(SB),NOSPLIT,$0-56 15 | B syscall·Syscall(SB) 16 | 17 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 18 | B syscall·Syscall6(SB) 19 | 20 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 21 | B syscall·RawSyscall(SB) 22 | 23 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 24 | B syscall·RawSyscall6(SB) 25 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_linux_mips64x.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 linux 6 | // +build mips64 mips64le 7 | // +build !gccgo 8 | 9 | #include "textflag.h" 10 | 11 | // 12 | // System calls for mips64, Linux 13 | // 14 | 15 | // Just jump to package syscall's implementation for all these functions. 16 | // The runtime may know about them. 17 | 18 | TEXT ·Syscall(SB),NOSPLIT,$0-56 19 | JMP syscall·Syscall(SB) 20 | 21 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 22 | JMP syscall·Syscall6(SB) 23 | 24 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 25 | JMP syscall·RawSyscall(SB) 26 | 27 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 28 | JMP syscall·RawSyscall6(SB) 29 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_linux_mipsx.s: -------------------------------------------------------------------------------- 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 linux 6 | // +build mips mipsle 7 | // +build !gccgo 8 | 9 | #include "textflag.h" 10 | 11 | // 12 | // System calls for mips, Linux 13 | // 14 | 15 | // Just jump to package syscall's implementation for all these functions. 16 | // The runtime may know about them. 17 | 18 | TEXT ·Syscall(SB),NOSPLIT,$0-28 19 | JMP syscall·Syscall(SB) 20 | 21 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 22 | JMP syscall·Syscall6(SB) 23 | 24 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 25 | JMP syscall·Syscall9(SB) 26 | 27 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 28 | JMP syscall·RawSyscall(SB) 29 | 30 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 31 | JMP syscall·RawSyscall6(SB) 32 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_linux_ppc64x.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 linux 6 | // +build ppc64 ppc64le 7 | // +build !gccgo 8 | 9 | #include "textflag.h" 10 | 11 | // 12 | // System calls for ppc64, Linux 13 | // 14 | 15 | // Just jump to package syscall's implementation for all these functions. 16 | // The runtime may know about them. 17 | 18 | TEXT ·Syscall(SB),NOSPLIT,$0-56 19 | BR syscall·Syscall(SB) 20 | 21 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 22 | BR syscall·Syscall6(SB) 23 | 24 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 25 | BR syscall·RawSyscall(SB) 26 | 27 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 28 | BR syscall·RawSyscall6(SB) 29 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_linux_s390x.s: -------------------------------------------------------------------------------- 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 s390x 6 | // +build linux 7 | // +build !gccgo 8 | 9 | #include "textflag.h" 10 | 11 | // 12 | // System calls for s390x, Linux 13 | // 14 | 15 | // Just jump to package syscall's implementation for all these functions. 16 | // The runtime may know about them. 17 | 18 | TEXT ·Syscall(SB),NOSPLIT,$0-56 19 | BR syscall·Syscall(SB) 20 | 21 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 22 | BR syscall·Syscall6(SB) 23 | 24 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 25 | BR syscall·RawSyscall(SB) 26 | 27 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 28 | BR syscall·RawSyscall6(SB) 29 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_netbsd_386.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for 386, NetBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-28 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_netbsd_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for AMD64, NetBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_netbsd_arm.s: -------------------------------------------------------------------------------- 1 | // Copyright 2013 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for ARM, NetBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-28 17 | B syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | B syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | B syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | B syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | B syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_openbsd_386.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for 386, OpenBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-28 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_openbsd_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for AMD64, OpenBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-56 17 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104 23 | JMP syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56 26 | JMP syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 29 | JMP syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_openbsd_arm.s: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System call support for ARM, OpenBSD 11 | // 12 | 13 | // Just jump to package syscall's implementation for all these functions. 14 | // The runtime may know about them. 15 | 16 | TEXT ·Syscall(SB),NOSPLIT,$0-28 17 | B syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | B syscall·Syscall6(SB) 21 | 22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52 23 | B syscall·Syscall9(SB) 24 | 25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 26 | B syscall·RawSyscall(SB) 27 | 28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 29 | B syscall·RawSyscall6(SB) 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/asm_solaris_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !gccgo 6 | 7 | #include "textflag.h" 8 | 9 | // 10 | // System calls for amd64, Solaris are implemented in runtime/syscall_solaris.go 11 | // 12 | 13 | TEXT ·sysvicall6(SB),NOSPLIT,$0-88 14 | JMP syscall·sysvicall6(SB) 15 | 16 | TEXT ·rawSysvicall6(SB),NOSPLIT,$0-88 17 | JMP syscall·rawSysvicall6(SB) 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/bluetooth_linux.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Bluetooth sockets and messages 6 | 7 | package unix 8 | 9 | // Bluetooth Protocols 10 | const ( 11 | BTPROTO_L2CAP = 0 12 | BTPROTO_HCI = 1 13 | BTPROTO_SCO = 2 14 | BTPROTO_RFCOMM = 3 15 | BTPROTO_BNEP = 4 16 | BTPROTO_CMTP = 5 17 | BTPROTO_HIDP = 6 18 | BTPROTO_AVDTP = 7 19 | ) 20 | 21 | const ( 22 | HCI_CHANNEL_RAW = 0 23 | HCI_CHANNEL_USER = 1 24 | HCI_CHANNEL_MONITOR = 2 25 | HCI_CHANNEL_CONTROL = 3 26 | ) 27 | 28 | // Socketoption Level 29 | const ( 30 | SOL_BLUETOOTH = 0x112 31 | SOL_HCI = 0x0 32 | SOL_L2CAP = 0x6 33 | SOL_RFCOMM = 0x12 34 | SOL_SCO = 0x11 35 | ) 36 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/constants.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build darwin dragonfly freebsd linux netbsd openbsd solaris 6 | 7 | package unix 8 | 9 | const ( 10 | R_OK = 0x4 11 | W_OK = 0x2 12 | X_OK = 0x1 13 | ) 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/dev_darwin.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Functions to access/create device major and minor numbers matching the 6 | // encoding used in Darwin's sys/types.h header. 7 | 8 | package unix 9 | 10 | // Major returns the major component of a Darwin device number. 11 | func Major(dev uint64) uint32 { 12 | return uint32((dev >> 24) & 0xff) 13 | } 14 | 15 | // Minor returns the minor component of a Darwin device number. 16 | func Minor(dev uint64) uint32 { 17 | return uint32(dev & 0xffffff) 18 | } 19 | 20 | // Mkdev returns a Darwin device number generated from the given major and minor 21 | // components. 22 | func Mkdev(major, minor uint32) uint64 { 23 | return (uint64(major) << 24) | uint64(minor) 24 | } 25 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/endian_big.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | // 5 | // +build ppc64 s390x mips mips64 6 | 7 | package unix 8 | 9 | const isBigEndian = true 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/endian_little.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | // 5 | // +build 386 amd64 amd64p32 arm arm64 ppc64le mipsle mips64le 6 | 7 | package unix 8 | 9 | const isBigEndian = false 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/env_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2010 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build darwin dragonfly freebsd linux netbsd openbsd solaris 6 | 7 | // Unix environment variables. 8 | 9 | package unix 10 | 11 | import "syscall" 12 | 13 | func Getenv(key string) (value string, found bool) { 14 | return syscall.Getenv(key) 15 | } 16 | 17 | func Setenv(key, value string) error { 18 | return syscall.Setenv(key, value) 19 | } 20 | 21 | func Clearenv() { 22 | syscall.Clearenv() 23 | } 24 | 25 | func Environ() []string { 26 | return syscall.Environ() 27 | } 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/env_unset.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 go1.4 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | func Unsetenv(key string) error { 12 | // This was added in Go 1.4. 13 | return syscall.Unsetenv(key) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/file_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 | package unix 6 | 7 | import ( 8 | "os" 9 | "syscall" 10 | ) 11 | 12 | // FIXME: unexported function from os 13 | // syscallMode returns the syscall-specific mode bits from Go's portable mode bits. 14 | func syscallMode(i os.FileMode) (o uint32) { 15 | o |= uint32(i.Perm()) 16 | if i&os.ModeSetuid != 0 { 17 | o |= syscall.S_ISUID 18 | } 19 | if i&os.ModeSetgid != 0 { 20 | o |= syscall.S_ISGID 21 | } 22 | if i&os.ModeSticky != 0 { 23 | o |= syscall.S_ISVTX 24 | } 25 | // No mapping for Go's ModeTemporary (plan9 only). 26 | return 27 | } 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/flock.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 darwin dragonfly freebsd linux netbsd openbsd 6 | 7 | package unix 8 | 9 | import "unsafe" 10 | 11 | // fcntl64Syscall is usually SYS_FCNTL, but is overridden on 32-bit Linux 12 | // systems by flock_linux_32bit.go to be SYS_FCNTL64. 13 | var fcntl64Syscall uintptr = SYS_FCNTL 14 | 15 | // FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command. 16 | func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error { 17 | _, _, errno := Syscall(fcntl64Syscall, fd, uintptr(cmd), uintptr(unsafe.Pointer(lk))) 18 | if errno == 0 { 19 | return nil 20 | } 21 | return errno 22 | } 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/flock_linux_32bit.go: -------------------------------------------------------------------------------- 1 | // +build linux,386 linux,arm linux,mips linux,mipsle 2 | 3 | // Copyright 2014 The Go Authors. All rights reserved. 4 | // Use of this source code is governed by a BSD-style 5 | // license that can be found in the LICENSE file. 6 | 7 | package unix 8 | 9 | func init() { 10 | // On 32-bit Linux systems, the fcntl syscall that matches Go's 11 | // Flock_t type is SYS_FCNTL64, not SYS_FCNTL. 12 | fcntl64Syscall = SYS_FCNTL64 13 | } 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/gccgo_linux_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build gccgo,linux,amd64 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | //extern gettimeofday 12 | func realGettimeofday(*Timeval, *byte) int32 13 | 14 | func gettimeofday(tv *Timeval) (err syscall.Errno) { 15 | r := realGettimeofday(tv, nil) 16 | if r < 0 { 17 | return syscall.GetErrno() 18 | } 19 | return 0 20 | } 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/pagesize_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build darwin dragonfly freebsd linux netbsd openbsd solaris 6 | 7 | // For Unix, get the pagesize from the runtime. 8 | 9 | package unix 10 | 11 | import "syscall" 12 | 13 | func Getpagesize() int { 14 | return syscall.Getpagesize() 15 | } 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/race.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build darwin,race linux,race freebsd,race 6 | 7 | package unix 8 | 9 | import ( 10 | "runtime" 11 | "unsafe" 12 | ) 13 | 14 | const raceenabled = true 15 | 16 | func raceAcquire(addr unsafe.Pointer) { 17 | runtime.RaceAcquire(addr) 18 | } 19 | 20 | func raceReleaseMerge(addr unsafe.Pointer) { 21 | runtime.RaceReleaseMerge(addr) 22 | } 23 | 24 | func raceReadRange(addr unsafe.Pointer, len int) { 25 | runtime.RaceReadRange(addr, len) 26 | } 27 | 28 | func raceWriteRange(addr unsafe.Pointer, len int) { 29 | runtime.RaceWriteRange(addr, len) 30 | } 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/race0.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build darwin,!race linux,!race freebsd,!race netbsd openbsd solaris dragonfly 6 | 7 | package unix 8 | 9 | import ( 10 | "unsafe" 11 | ) 12 | 13 | const raceenabled = false 14 | 15 | func raceAcquire(addr unsafe.Pointer) { 16 | } 17 | 18 | func raceReleaseMerge(addr unsafe.Pointer) { 19 | } 20 | 21 | func raceReadRange(addr unsafe.Pointer, len int) { 22 | } 23 | 24 | func raceWriteRange(addr unsafe.Pointer, len int) { 25 | } 26 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/str.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build darwin dragonfly freebsd linux netbsd openbsd solaris 6 | 7 | package unix 8 | 9 | func itoa(val int) string { // do it here rather than with fmt to avoid dependency 10 | if val < 0 { 11 | return "-" + uitoa(uint(-val)) 12 | } 13 | return uitoa(uint(val)) 14 | } 15 | 16 | func uitoa(val uint) string { 17 | var buf [32]byte // big enough for int64 18 | i := len(buf) - 1 19 | for val >= 10 { 20 | buf[i] = byte(val%10 + '0') 21 | i-- 22 | val /= 10 23 | } 24 | buf[i] = byte(val + '0') 25 | return string(buf[i:]) 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_linux_amd64_gc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build amd64,linux 6 | // +build !gccgo 7 | 8 | package unix 9 | 10 | import "syscall" 11 | 12 | //go:noescape 13 | func gettimeofday(tv *Timeval) (err syscall.Errno) 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_no_getwd.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 dragonfly freebsd netbsd openbsd 6 | 7 | package unix 8 | 9 | const ImplementsGetwd = false 10 | 11 | func Getwd() (string, error) { return "", ENOTSUP } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_solaris_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build amd64,solaris 6 | 7 | package unix 8 | 9 | func setTimespec(sec, nsec int64) Timespec { 10 | return Timespec{Sec: sec, Nsec: nsec} 11 | } 12 | 13 | func setTimeval(sec, usec int64) Timeval { 14 | return Timeval{Sec: sec, Usec: usec} 15 | } 16 | 17 | func (iov *Iovec) SetLen(length int) { 18 | iov.Len = uint64(length) 19 | } 20 | 21 | func (cmsg *Cmsghdr) SetLen(length int) { 22 | cmsg.Len = uint32(length) 23 | } 24 | 25 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { 26 | // TODO(aram): implement this, see issue 5847. 27 | panic("unimplemented") 28 | } 29 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/syscall_unix_gc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build darwin dragonfly freebsd linux netbsd openbsd solaris 6 | // +build !gccgo 7 | 8 | package unix 9 | 10 | import "syscall" 11 | 12 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) 13 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) 14 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) 15 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/unix/zsysnum_solaris_amd64.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 amd64,solaris 6 | 7 | package unix 8 | 9 | // TODO(aram): remove these before Go 1.3. 10 | const ( 11 | SYS_EXECVE = 59 12 | SYS_FCNTL = 62 13 | ) 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/asm_windows_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 | // 6 | // System calls for 386, Windows are implemented in runtime/syscall_windows.goc 7 | // 8 | 9 | TEXT ·getprocaddress(SB), 7, $0-8 10 | JMP syscall·getprocaddress(SB) 11 | 12 | TEXT ·loadlibrary(SB), 7, $0-4 13 | JMP syscall·loadlibrary(SB) 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/asm_windows_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 | // 6 | // System calls for amd64, Windows are implemented in runtime/syscall_windows.goc 7 | // 8 | 9 | TEXT ·getprocaddress(SB), 7, $0-32 10 | JMP syscall·getprocaddress(SB) 11 | 12 | TEXT ·loadlibrary(SB), 7, $0-8 13 | JMP syscall·loadlibrary(SB) 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/env_unset.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 windows 6 | // +build go1.4 7 | 8 | package windows 9 | 10 | import "syscall" 11 | 12 | func Unsetenv(key string) error { 13 | // This was added in Go 1.4. 14 | return syscall.Unsetenv(key) 15 | } 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/env_windows.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 | // Windows environment variables. 6 | 7 | package windows 8 | 9 | import "syscall" 10 | 11 | func Getenv(key string) (value string, found bool) { 12 | return syscall.Getenv(key) 13 | } 14 | 15 | func Setenv(key, value string) error { 16 | return syscall.Setenv(key, value) 17 | } 18 | 19 | func Clearenv() { 20 | syscall.Clearenv() 21 | } 22 | 23 | func Environ() []string { 24 | return syscall.Environ() 25 | } 26 | -------------------------------------------------------------------------------- /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 | package windows 6 | 7 | //go:generate go run $GOROOT/src/syscall/mksyscall_windows.go -output zsyscall_windows.go eventlog.go service.go syscall_windows.go security_windows.go 8 | -------------------------------------------------------------------------------- /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/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/text/internal/testtext/flag.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 | package testtext 6 | 7 | import ( 8 | "flag" 9 | "testing" 10 | 11 | "golang.org/x/text/internal/gen" 12 | ) 13 | 14 | var long = flag.Bool("long", false, 15 | "run tests that require fetching data online") 16 | 17 | // SkipIfNotLong returns whether long tests should be performed. 18 | func SkipIfNotLong(t *testing.T) { 19 | if testing.Short() || !(gen.IsLocal() || *long) { 20 | t.Skip("skipping test to prevent downloading; to run use -long or use -local or UNICODE_DIR to specify a local source") 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/internal/testtext/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 !gccgo 6 | 7 | package testtext 8 | 9 | import "testing" 10 | 11 | // AllocsPerRun wraps testing.AllocsPerRun. 12 | func AllocsPerRun(runs int, f func()) (avg float64) { 13 | return testing.AllocsPerRun(runs, f) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/internal/testtext/gccgo.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 gccgo 6 | 7 | package testtext 8 | 9 | // AllocsPerRun always returns 0 for gccgo until gccgo implements escape 10 | // analysis equal or better to that of gc. 11 | func AllocsPerRun(runs int, f func()) (avg float64) { return 0 } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/internal/testtext/go1_6.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !go1.7 6 | 7 | package testtext 8 | 9 | import "testing" 10 | 11 | func Run(t *testing.T, name string, fn func(t *testing.T)) bool { 12 | t.Logf("Running %s...", name) 13 | fn(t) 14 | return t.Failed() 15 | } 16 | 17 | // Bench runs the given benchmark function. This pre-1.7 implementation renders 18 | // the measurement useless, but allows the code to be compiled at least. 19 | func Bench(b *testing.B, name string, fn func(b *testing.B)) bool { 20 | b.Logf("Running %s...", name) 21 | fn(b) 22 | return b.Failed() 23 | } 24 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/internal/testtext/go1_7.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build go1.7 6 | 7 | package testtext 8 | 9 | import "testing" 10 | 11 | func Run(t *testing.T, name string, fn func(t *testing.T)) bool { 12 | return t.Run(name, fn) 13 | } 14 | 15 | func Bench(b *testing.B, name string, fn func(b *testing.B)) bool { 16 | return b.Run(name, fn) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/unicode/cldr/cldr_test.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 | package cldr 6 | 7 | import "testing" 8 | 9 | func TestParseDraft(t *testing.T) { 10 | tests := []struct { 11 | in string 12 | draft Draft 13 | err bool 14 | }{ 15 | {"unconfirmed", Unconfirmed, false}, 16 | {"provisional", Provisional, false}, 17 | {"contributed", Contributed, false}, 18 | {"approved", Approved, false}, 19 | {"", Approved, false}, 20 | {"foo", Approved, true}, 21 | } 22 | for _, tt := range tests { 23 | if d, err := ParseDraft(tt.in); d != tt.draft || (err != nil) != tt.err { 24 | t.Errorf("%q: was %v, %v; want %v, %v", tt.in, d, err != nil, tt.draft, tt.err) 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/unicode/cldr/examples_test.go: -------------------------------------------------------------------------------- 1 | package cldr_test 2 | 3 | import ( 4 | "fmt" 5 | 6 | "golang.org/x/text/unicode/cldr" 7 | ) 8 | 9 | func ExampleSlice() { 10 | var dr *cldr.CLDR // assume this is initialized 11 | 12 | x, _ := dr.LDML("en") 13 | cs := x.Collations.Collation 14 | // remove all but the default 15 | cldr.MakeSlice(&cs).Filter(func(e cldr.Elem) bool { 16 | return e.GetCommon().Type != x.Collations.Default() 17 | }) 18 | for i, c := range cs { 19 | fmt.Println(i, c.Type) 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/unicode/norm/example_test.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 norm_test 6 | 7 | import ( 8 | "fmt" 9 | 10 | "golang.org/x/text/unicode/norm" 11 | ) 12 | 13 | func ExampleForm_NextBoundary() { 14 | s := norm.NFD.String("Mêlée") 15 | 16 | for i := 0; i < len(s); { 17 | d := norm.NFC.NextBoundaryInString(s[i:], true) 18 | fmt.Printf("%[1]s: %+[1]q\n", s[i:i+d]) 19 | i += d 20 | } 21 | // Output: 22 | // M: "M" 23 | // ê: "e\u0302" 24 | // l: "l" 25 | // é: "e\u0301" 26 | // e: "e" 27 | } 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/unicode/norm/norm_test.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 norm_test 6 | 7 | import ( 8 | "testing" 9 | ) 10 | 11 | func TestPlaceHolder(t *testing.T) { 12 | // Does nothing, just allows the Makefile to be canonical 13 | // while waiting for the package itself to be written. 14 | } 15 | -------------------------------------------------------------------------------- /vendor/gopkg.in/gorp.v1/.gitignore: -------------------------------------------------------------------------------- 1 | _test 2 | _testmain.go 3 | _obj 4 | *~ 5 | *.6 6 | 6.out 7 | gorptest.bin 8 | tmp 9 | -------------------------------------------------------------------------------- /vendor/gopkg.in/gorp.v1/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | go: 3 | - 1.1 4 | - tip 5 | 6 | services: 7 | - mysql 8 | - postgres 9 | - sqlite3 10 | 11 | before_script: 12 | - mysql -e "CREATE DATABASE gorptest;" 13 | - mysql -u root -e "GRANT ALL ON gorptest.* TO gorptest@localhost IDENTIFIED BY 'gorptest'" 14 | - psql -c "CREATE DATABASE gorptest;" -U postgres 15 | - psql -c "CREATE USER "gorptest" WITH SUPERUSER PASSWORD 'gorptest';" -U postgres 16 | - go get github.com/lib/pq 17 | - go get github.com/mattn/go-sqlite3 18 | - go get github.com/ziutek/mymysql/godrv 19 | - go get github.com/go-sql-driver/mysql 20 | 21 | script: ./test_all.sh 22 | -------------------------------------------------------------------------------- /vendor/gopkg.in/gorp.v1/Makefile: -------------------------------------------------------------------------------- 1 | include $(GOROOT)/src/Make.inc 2 | 3 | TARG = github.com/coopernurse/gorp 4 | GOFILES = gorp.go dialect.go 5 | 6 | include $(GOROOT)/src/Make.pkg -------------------------------------------------------------------------------- /vendor/gopkg.in/gorp.v1/errors.go: -------------------------------------------------------------------------------- 1 | package gorp 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | // A non-fatal error, when a select query returns columns that do not exist 8 | // as fields in the struct it is being mapped to 9 | type NoFieldInTypeError struct { 10 | TypeName string 11 | MissingColNames []string 12 | } 13 | 14 | func (err *NoFieldInTypeError) Error() string { 15 | return fmt.Sprintf("gorp: No fields %+v in type %s", err.MissingColNames, err.TypeName) 16 | } 17 | 18 | // returns true if the error is non-fatal (ie, we shouldn't immediately return) 19 | func NonFatalError(err error) bool { 20 | switch err.(type) { 21 | case *NoFieldInTypeError: 22 | return true 23 | default: 24 | return false 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /vendor/gopkg.in/gorp.v1/test_all.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | # on macs, you may need to: 4 | # export GOBUILDFLAG=-ldflags -linkmode=external 5 | 6 | set -e 7 | 8 | export GORP_TEST_DSN=gorptest/gorptest/gorptest 9 | export GORP_TEST_DIALECT=mysql 10 | go test $GOBUILDFLAG . 11 | 12 | export GORP_TEST_DSN=gorptest:gorptest@/gorptest 13 | export GORP_TEST_DIALECT=gomysql 14 | go test $GOBUILDFLAG . 15 | 16 | export GORP_TEST_DSN="user=gorptest password=gorptest dbname=gorptest sslmode=disable" 17 | export GORP_TEST_DIALECT=postgres 18 | go test $GOBUILDFLAG . 19 | 20 | export GORP_TEST_DSN=/tmp/gorptest.bin 21 | export GORP_TEST_DIALECT=sqlite 22 | go test $GOBUILDFLAG . 23 | -------------------------------------------------------------------------------- /worker/builder_test.go: -------------------------------------------------------------------------------- 1 | package worker 2 | 3 | import ( 4 | "bytes" 5 | "testing" 6 | 7 | "github.com/remind101/conveyor/builder" 8 | "github.com/stretchr/testify/assert" 9 | "golang.org/x/net/context" 10 | ) 11 | 12 | func TestBuilder_Build(t *testing.T) { 13 | b := new(mockBuilder) 14 | bb := &Builder{ 15 | builder: b, 16 | } 17 | 18 | w := new(bytes.Buffer) 19 | options := builder.BuildOptions{} 20 | 21 | b.On("Build", w, options).Return("", nil) 22 | 23 | _, err := bb.Build(context.Background(), w, options) 24 | assert.NoError(t, err) 25 | } 26 | --------------------------------------------------------------------------------