├── .gitignore ├── .travis.yml ├── Dockerfile ├── Godeps ├── Godeps.json ├── Readme └── _workspace │ ├── .gitignore │ └── src │ ├── github.com │ ├── docker │ │ ├── docker │ │ │ ├── LICENSE │ │ │ ├── NOTICE │ │ │ ├── api │ │ │ │ └── types │ │ │ │ │ ├── auth.go │ │ │ │ │ ├── backend │ │ │ │ │ ├── backend.go │ │ │ │ │ └── build.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 │ │ │ │ │ ├── events │ │ │ │ │ └── events.go │ │ │ │ │ ├── filters │ │ │ │ │ └── parse.go │ │ │ │ │ ├── graph_driver_data.go │ │ │ │ │ ├── id_response.go │ │ │ │ │ ├── image │ │ │ │ │ └── image_history.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 │ │ │ │ │ ├── plugins │ │ │ │ │ └── logdriver │ │ │ │ │ │ ├── entry.pb.go │ │ │ │ │ │ ├── entry.proto │ │ │ │ │ │ ├── gen.go │ │ │ │ │ │ └── io.go │ │ │ │ │ ├── port.go │ │ │ │ │ ├── registry │ │ │ │ │ ├── authenticate.go │ │ │ │ │ └── registry.go │ │ │ │ │ ├── seccomp.go │ │ │ │ │ ├── service_update_response.go │ │ │ │ │ ├── stats.go │ │ │ │ │ ├── strslice │ │ │ │ │ └── strslice.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 │ │ │ │ │ ├── time │ │ │ │ │ ├── duration_convert.go │ │ │ │ │ └── timestamp.go │ │ │ │ │ ├── types.go │ │ │ │ │ ├── versions │ │ │ │ │ ├── README.md │ │ │ │ │ ├── compare.go │ │ │ │ │ ├── v1p19 │ │ │ │ │ │ └── types.go │ │ │ │ │ └── v1p20 │ │ │ │ │ │ └── types.go │ │ │ │ │ ├── volume.go │ │ │ │ │ └── volume │ │ │ │ │ ├── volumes_create.go │ │ │ │ │ └── volumes_list.go │ │ │ ├── contrib │ │ │ │ ├── selinux-fedora-24 │ │ │ │ │ └── docker-engine-selinux │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── selinux-oraclelinux-7 │ │ │ │ │ └── docker-engine-selinux │ │ │ │ │ │ └── LICENSE │ │ │ │ └── syntax │ │ │ │ │ └── vim │ │ │ │ │ └── LICENSE │ │ │ ├── daemon │ │ │ │ └── cluster │ │ │ │ │ └── convert │ │ │ │ │ ├── config.go │ │ │ │ │ ├── container.go │ │ │ │ │ ├── network.go │ │ │ │ │ ├── node.go │ │ │ │ │ ├── secret.go │ │ │ │ │ ├── service.go │ │ │ │ │ ├── swarm.go │ │ │ │ │ └── task.go │ │ │ ├── hack │ │ │ │ └── integration-cli-on-swarm │ │ │ │ │ └── agent │ │ │ │ │ └── vendor │ │ │ │ │ └── github.com │ │ │ │ │ └── bfirsh │ │ │ │ │ └── funker-go │ │ │ │ │ └── LICENSE │ │ │ ├── opts │ │ │ │ ├── env.go │ │ │ │ ├── hosts.go │ │ │ │ ├── hosts_unix.go │ │ │ │ ├── hosts_windows.go │ │ │ │ ├── ip.go │ │ │ │ ├── opts.go │ │ │ │ ├── opts_unix.go │ │ │ │ ├── opts_windows.go │ │ │ │ ├── quotedstring.go │ │ │ │ ├── runtime.go │ │ │ │ └── ulimit.go │ │ │ ├── pkg │ │ │ │ ├── archive │ │ │ │ │ ├── README.md │ │ │ │ │ ├── archive.go │ │ │ │ │ ├── archive_linux.go │ │ │ │ │ ├── archive_other.go │ │ │ │ │ ├── archive_unix.go │ │ │ │ │ ├── archive_windows.go │ │ │ │ │ ├── changes.go │ │ │ │ │ ├── changes_linux.go │ │ │ │ │ ├── changes_other.go │ │ │ │ │ ├── changes_unix.go │ │ │ │ │ ├── changes_windows.go │ │ │ │ │ ├── copy.go │ │ │ │ │ ├── copy_unix.go │ │ │ │ │ ├── copy_windows.go │ │ │ │ │ ├── diff.go │ │ │ │ │ ├── example_changes.go │ │ │ │ │ ├── time_linux.go │ │ │ │ │ ├── time_unsupported.go │ │ │ │ │ ├── whiteouts.go │ │ │ │ │ └── wrap.go │ │ │ │ ├── fileutils │ │ │ │ │ ├── fileutils.go │ │ │ │ │ ├── fileutils_darwin.go │ │ │ │ │ ├── fileutils_solaris.go │ │ │ │ │ ├── fileutils_unix.go │ │ │ │ │ └── fileutils_windows.go │ │ │ │ ├── homedir │ │ │ │ │ ├── homedir_linux.go │ │ │ │ │ ├── homedir_others.go │ │ │ │ │ ├── homedir_unix.go │ │ │ │ │ └── homedir_windows.go │ │ │ │ ├── idtools │ │ │ │ │ ├── idtools.go │ │ │ │ │ ├── idtools_unix.go │ │ │ │ │ ├── idtools_windows.go │ │ │ │ │ ├── usergroupadd_linux.go │ │ │ │ │ ├── usergroupadd_unsupported.go │ │ │ │ │ └── utils_unix.go │ │ │ │ ├── ioutils │ │ │ │ │ ├── buffer.go │ │ │ │ │ ├── bytespipe.go │ │ │ │ │ ├── fswriters.go │ │ │ │ │ ├── readers.go │ │ │ │ │ ├── temp_unix.go │ │ │ │ │ ├── temp_windows.go │ │ │ │ │ ├── writeflusher.go │ │ │ │ │ └── writers.go │ │ │ │ ├── jsonlog │ │ │ │ │ ├── jsonlog.go │ │ │ │ │ ├── jsonlog_marshalling.go │ │ │ │ │ ├── jsonlogbytes.go │ │ │ │ │ └── time_marshalling.go │ │ │ │ ├── jsonmessage │ │ │ │ │ └── jsonmessage.go │ │ │ │ ├── mount │ │ │ │ │ ├── flags.go │ │ │ │ │ ├── flags_freebsd.go │ │ │ │ │ ├── flags_linux.go │ │ │ │ │ ├── flags_unsupported.go │ │ │ │ │ ├── mount.go │ │ │ │ │ ├── mounter_freebsd.go │ │ │ │ │ ├── mounter_linux.go │ │ │ │ │ ├── mounter_solaris.go │ │ │ │ │ ├── mounter_unsupported.go │ │ │ │ │ ├── mountinfo.go │ │ │ │ │ ├── mountinfo_freebsd.go │ │ │ │ │ ├── mountinfo_linux.go │ │ │ │ │ ├── mountinfo_solaris.go │ │ │ │ │ ├── mountinfo_unsupported.go │ │ │ │ │ ├── mountinfo_windows.go │ │ │ │ │ ├── sharedsubtree_linux.go │ │ │ │ │ └── sharedsubtree_solaris.go │ │ │ │ ├── namesgenerator │ │ │ │ │ ├── cmd │ │ │ │ │ │ └── names-generator │ │ │ │ │ │ │ └── main.go │ │ │ │ │ └── names-generator.go │ │ │ │ ├── pools │ │ │ │ │ └── pools.go │ │ │ │ ├── promise │ │ │ │ │ └── promise.go │ │ │ │ ├── stdcopy │ │ │ │ │ └── stdcopy.go │ │ │ │ ├── symlink │ │ │ │ │ ├── LICENSE.APACHE │ │ │ │ │ └── LICENSE.BSD │ │ │ │ ├── system │ │ │ │ │ ├── chtimes.go │ │ │ │ │ ├── chtimes_unix.go │ │ │ │ │ ├── chtimes_windows.go │ │ │ │ │ ├── errors.go │ │ │ │ │ ├── events_windows.go │ │ │ │ │ ├── exitcode.go │ │ │ │ │ ├── filesys.go │ │ │ │ │ ├── filesys_windows.go │ │ │ │ │ ├── init.go │ │ │ │ │ ├── init_windows.go │ │ │ │ │ ├── lcow_unix.go │ │ │ │ │ ├── lcow_windows.go │ │ │ │ │ ├── lstat_unix.go │ │ │ │ │ ├── lstat_windows.go │ │ │ │ │ ├── meminfo.go │ │ │ │ │ ├── meminfo_linux.go │ │ │ │ │ ├── meminfo_solaris.go │ │ │ │ │ ├── meminfo_unsupported.go │ │ │ │ │ ├── meminfo_windows.go │ │ │ │ │ ├── mknod.go │ │ │ │ │ ├── mknod_windows.go │ │ │ │ │ ├── path.go │ │ │ │ │ ├── path_unix.go │ │ │ │ │ ├── path_windows.go │ │ │ │ │ ├── process_unix.go │ │ │ │ │ ├── rm.go │ │ │ │ │ ├── stat_darwin.go │ │ │ │ │ ├── stat_freebsd.go │ │ │ │ │ ├── stat_linux.go │ │ │ │ │ ├── stat_openbsd.go │ │ │ │ │ ├── stat_solaris.go │ │ │ │ │ ├── stat_unix.go │ │ │ │ │ ├── stat_windows.go │ │ │ │ │ ├── syscall_unix.go │ │ │ │ │ ├── syscall_windows.go │ │ │ │ │ ├── umask.go │ │ │ │ │ ├── umask_windows.go │ │ │ │ │ ├── utimes_freebsd.go │ │ │ │ │ ├── utimes_linux.go │ │ │ │ │ ├── utimes_unsupported.go │ │ │ │ │ ├── xattrs_linux.go │ │ │ │ │ └── xattrs_unsupported.go │ │ │ │ └── term │ │ │ │ │ ├── ascii.go │ │ │ │ │ ├── proxy.go │ │ │ │ │ ├── tc.go │ │ │ │ │ ├── tc_solaris_cgo.go │ │ │ │ │ ├── term.go │ │ │ │ │ ├── term_windows.go │ │ │ │ │ ├── termios_bsd.go │ │ │ │ │ ├── termios_linux.go │ │ │ │ │ ├── windows │ │ │ │ │ ├── ansi_reader.go │ │ │ │ │ ├── ansi_writer.go │ │ │ │ │ ├── console.go │ │ │ │ │ └── windows.go │ │ │ │ │ ├── winsize.go │ │ │ │ │ └── winsize_solaris_cgo.go │ │ │ └── vendor │ │ │ │ ├── archive │ │ │ │ └── tar │ │ │ │ │ ├── common.go │ │ │ │ │ ├── format.go │ │ │ │ │ ├── reader.go │ │ │ │ │ ├── stat_atim.go │ │ │ │ │ ├── stat_atimespec.go │ │ │ │ │ ├── stat_unix.go │ │ │ │ │ ├── strconv.go │ │ │ │ │ └── writer.go │ │ │ │ ├── cloud.google.com │ │ │ │ └── go │ │ │ │ │ └── LICENSE │ │ │ │ ├── github.com │ │ │ │ ├── Azure │ │ │ │ │ └── go-ansiterm │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── BurntSushi │ │ │ │ │ └── toml │ │ │ │ │ │ └── COPYING │ │ │ │ ├── Graylog2 │ │ │ │ │ └── go-gelf │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── Microsoft │ │ │ │ │ ├── go-winio │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ └── archive │ │ │ │ │ │ │ └── tar │ │ │ │ │ │ │ └── LICENSE │ │ │ │ │ ├── hcsshim │ │ │ │ │ │ └── LICENSE │ │ │ │ │ └── opengcs │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── Nvveen │ │ │ │ │ └── Gotty │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ ├── README │ │ │ │ │ │ ├── attributes.go │ │ │ │ │ │ ├── gotty.go │ │ │ │ │ │ ├── parser.go │ │ │ │ │ │ └── types.go │ │ │ │ ├── RackSec │ │ │ │ │ └── srslog │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── armon │ │ │ │ │ ├── go-metrics │ │ │ │ │ │ └── LICENSE │ │ │ │ │ └── go-radix │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── aws │ │ │ │ │ └── aws-sdk-go │ │ │ │ │ │ ├── LICENSE.txt │ │ │ │ │ │ └── NOTICE.txt │ │ │ │ ├── beorn7 │ │ │ │ │ └── perks │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ └── quantile │ │ │ │ │ │ └── stream.go │ │ │ │ ├── boltdb │ │ │ │ │ └── bolt │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── bsphere │ │ │ │ │ └── le_go │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── cloudflare │ │ │ │ │ └── cfssl │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ ├── api │ │ │ │ │ │ └── api.go │ │ │ │ │ │ ├── auth │ │ │ │ │ │ └── auth.go │ │ │ │ │ │ ├── certdb │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ └── certdb.go │ │ │ │ │ │ ├── config │ │ │ │ │ │ └── config.go │ │ │ │ │ │ ├── crypto │ │ │ │ │ │ └── pkcs7 │ │ │ │ │ │ │ └── pkcs7.go │ │ │ │ │ │ ├── csr │ │ │ │ │ │ └── csr.go │ │ │ │ │ │ ├── errors │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── error.go │ │ │ │ │ │ └── http.go │ │ │ │ │ │ ├── helpers │ │ │ │ │ │ ├── derhelpers │ │ │ │ │ │ │ └── derhelpers.go │ │ │ │ │ │ └── helpers.go │ │ │ │ │ │ ├── info │ │ │ │ │ │ └── info.go │ │ │ │ │ │ ├── initca │ │ │ │ │ │ └── initca.go │ │ │ │ │ │ ├── log │ │ │ │ │ │ └── log.go │ │ │ │ │ │ ├── ocsp │ │ │ │ │ │ └── config │ │ │ │ │ │ │ └── config.go │ │ │ │ │ │ └── signer │ │ │ │ │ │ ├── local │ │ │ │ │ │ └── local.go │ │ │ │ │ │ └── signer.go │ │ │ │ ├── containerd │ │ │ │ │ └── containerd │ │ │ │ │ │ ├── LICENSE.code │ │ │ │ │ │ ├── LICENSE.docs │ │ │ │ │ │ └── NOTICE │ │ │ │ ├── coreos │ │ │ │ │ ├── etcd │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ ├── NOTICE │ │ │ │ │ │ └── raft │ │ │ │ │ │ │ └── raftpb │ │ │ │ │ │ │ ├── raft.pb.go │ │ │ │ │ │ │ └── raft.proto │ │ │ │ │ ├── go-semver │ │ │ │ │ │ └── LICENSE │ │ │ │ │ ├── go-systemd │ │ │ │ │ │ └── LICENSE │ │ │ │ │ └── pkg │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ └── NOTICE │ │ │ │ ├── davecgh │ │ │ │ │ └── go-spew │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── deckarep │ │ │ │ │ └── golang-set │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── docker │ │ │ │ │ ├── distribution │ │ │ │ │ │ └── LICENSE │ │ │ │ │ ├── go-connections │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ └── nat │ │ │ │ │ │ │ ├── nat.go │ │ │ │ │ │ │ ├── parse.go │ │ │ │ │ │ │ └── sort.go │ │ │ │ │ ├── go-events │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ ├── broadcast.go │ │ │ │ │ │ ├── channel.go │ │ │ │ │ │ ├── errors.go │ │ │ │ │ │ ├── event.go │ │ │ │ │ │ ├── filter.go │ │ │ │ │ │ ├── queue.go │ │ │ │ │ │ └── retry.go │ │ │ │ │ ├── go-metrics │ │ │ │ │ │ ├── LICENSE.code │ │ │ │ │ │ ├── LICENSE.docs │ │ │ │ │ │ └── NOTICE │ │ │ │ │ ├── go-units │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ ├── duration.go │ │ │ │ │ │ ├── size.go │ │ │ │ │ │ └── ulimit.go │ │ │ │ │ ├── libkv │ │ │ │ │ │ ├── LICENSE.code │ │ │ │ │ │ ├── LICENSE.docs │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ ├── libkv.go │ │ │ │ │ │ └── store │ │ │ │ │ │ │ ├── boltdb │ │ │ │ │ │ │ └── boltdb.go │ │ │ │ │ │ │ ├── consul │ │ │ │ │ │ │ └── consul.go │ │ │ │ │ │ │ ├── etcd │ │ │ │ │ │ │ └── etcd.go │ │ │ │ │ │ │ ├── helpers.go │ │ │ │ │ │ │ ├── store.go │ │ │ │ │ │ │ └── zookeeper │ │ │ │ │ │ │ └── zookeeper.go │ │ │ │ │ ├── libnetwork │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ ├── datastore │ │ │ │ │ │ │ ├── cache.go │ │ │ │ │ │ │ ├── datastore.go │ │ │ │ │ │ │ └── mock_store.go │ │ │ │ │ │ ├── discoverapi │ │ │ │ │ │ │ └── discoverapi.go │ │ │ │ │ │ └── types │ │ │ │ │ │ │ └── types.go │ │ │ │ │ ├── libtrust │ │ │ │ │ │ └── LICENSE │ │ │ │ │ └── swarmkit │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ ├── api │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ ├── ca.pb.go │ │ │ │ │ │ ├── ca.proto │ │ │ │ │ │ ├── control.pb.go │ │ │ │ │ │ ├── control.proto │ │ │ │ │ │ ├── deepcopy │ │ │ │ │ │ │ └── copy.go │ │ │ │ │ │ ├── defaults │ │ │ │ │ │ │ └── service.go │ │ │ │ │ │ ├── dispatcher.pb.go │ │ │ │ │ │ ├── dispatcher.proto │ │ │ │ │ │ ├── equality │ │ │ │ │ │ │ └── equality.go │ │ │ │ │ │ ├── gen.go │ │ │ │ │ │ ├── genericresource │ │ │ │ │ │ │ ├── helpers.go │ │ │ │ │ │ │ ├── parse.go │ │ │ │ │ │ │ ├── resource_management.go │ │ │ │ │ │ │ ├── string.go │ │ │ │ │ │ │ └── validate.go │ │ │ │ │ │ ├── health.pb.go │ │ │ │ │ │ ├── health.proto │ │ │ │ │ │ ├── logbroker.pb.go │ │ │ │ │ │ ├── logbroker.proto │ │ │ │ │ │ ├── naming │ │ │ │ │ │ │ └── naming.go │ │ │ │ │ │ ├── objects.pb.go │ │ │ │ │ │ ├── objects.proto │ │ │ │ │ │ ├── raft.pb.go │ │ │ │ │ │ ├── raft.proto │ │ │ │ │ │ ├── resource.pb.go │ │ │ │ │ │ ├── resource.proto │ │ │ │ │ │ ├── snapshot.pb.go │ │ │ │ │ │ ├── snapshot.proto │ │ │ │ │ │ ├── specs.pb.go │ │ │ │ │ │ ├── specs.proto │ │ │ │ │ │ ├── storeobject.go │ │ │ │ │ │ ├── types.pb.go │ │ │ │ │ │ ├── types.proto │ │ │ │ │ │ ├── validation │ │ │ │ │ │ │ └── secrets.go │ │ │ │ │ │ ├── watch.pb.go │ │ │ │ │ │ └── watch.proto │ │ │ │ │ │ ├── ca │ │ │ │ │ │ ├── auth.go │ │ │ │ │ │ ├── certificates.go │ │ │ │ │ │ ├── config.go │ │ │ │ │ │ ├── external.go │ │ │ │ │ │ ├── forward.go │ │ │ │ │ │ ├── keyreadwriter.go │ │ │ │ │ │ ├── reconciler.go │ │ │ │ │ │ ├── renewer.go │ │ │ │ │ │ ├── server.go │ │ │ │ │ │ └── transport.go │ │ │ │ │ │ ├── connectionbroker │ │ │ │ │ │ └── broker.go │ │ │ │ │ │ ├── identity │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ └── randomid.go │ │ │ │ │ │ ├── ioutils │ │ │ │ │ │ └── ioutils.go │ │ │ │ │ │ ├── log │ │ │ │ │ │ ├── context.go │ │ │ │ │ │ └── grpc.go │ │ │ │ │ │ ├── manager │ │ │ │ │ │ ├── raftselector │ │ │ │ │ │ │ └── raftselector.go │ │ │ │ │ │ └── state │ │ │ │ │ │ │ ├── proposer.go │ │ │ │ │ │ │ ├── raft │ │ │ │ │ │ │ ├── membership │ │ │ │ │ │ │ │ └── cluster.go │ │ │ │ │ │ │ ├── raft.go │ │ │ │ │ │ │ ├── storage.go │ │ │ │ │ │ │ ├── storage │ │ │ │ │ │ │ │ ├── snapwrap.go │ │ │ │ │ │ │ │ ├── storage.go │ │ │ │ │ │ │ │ └── walwrap.go │ │ │ │ │ │ │ ├── transport │ │ │ │ │ │ │ │ ├── peer.go │ │ │ │ │ │ │ │ └── transport.go │ │ │ │ │ │ │ ├── util.go │ │ │ │ │ │ │ └── wait.go │ │ │ │ │ │ │ ├── store │ │ │ │ │ │ │ ├── apply.go │ │ │ │ │ │ │ ├── by.go │ │ │ │ │ │ │ ├── clusters.go │ │ │ │ │ │ │ ├── combinators.go │ │ │ │ │ │ │ ├── configs.go │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ ├── extensions.go │ │ │ │ │ │ │ ├── memory.go │ │ │ │ │ │ │ ├── networks.go │ │ │ │ │ │ │ ├── nodes.go │ │ │ │ │ │ │ ├── object.go │ │ │ │ │ │ │ ├── resources.go │ │ │ │ │ │ │ ├── secrets.go │ │ │ │ │ │ │ ├── services.go │ │ │ │ │ │ │ └── tasks.go │ │ │ │ │ │ │ └── watch.go │ │ │ │ │ │ ├── protobuf │ │ │ │ │ │ └── plugin │ │ │ │ │ │ │ ├── gen.go │ │ │ │ │ │ │ ├── helpers.go │ │ │ │ │ │ │ ├── plugin.pb.go │ │ │ │ │ │ │ └── plugin.proto │ │ │ │ │ │ ├── remotes │ │ │ │ │ │ └── remotes.go │ │ │ │ │ │ └── watch │ │ │ │ │ │ ├── queue │ │ │ │ │ │ └── queue.go │ │ │ │ │ │ ├── sinks.go │ │ │ │ │ │ └── watch.go │ │ │ │ ├── fluent │ │ │ │ │ └── fluent-logger-golang │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── fsnotify │ │ │ │ │ └── fsnotify │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── go-check │ │ │ │ │ └── check │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── go-ini │ │ │ │ │ └── ini │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── godbus │ │ │ │ │ └── dbus │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── gogo │ │ │ │ │ └── protobuf │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ ├── gogoproto │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── gogo.pb.go │ │ │ │ │ │ ├── gogo.proto │ │ │ │ │ │ └── helper.go │ │ │ │ │ │ ├── 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 │ │ │ │ │ │ ├── protoc-gen-gogo │ │ │ │ │ │ └── descriptor │ │ │ │ │ │ │ ├── descriptor.go │ │ │ │ │ │ │ ├── descriptor.pb.go │ │ │ │ │ │ │ ├── descriptor_gostring.gen.go │ │ │ │ │ │ │ └── helper.go │ │ │ │ │ │ ├── sortkeys │ │ │ │ │ │ └── sortkeys.go │ │ │ │ │ │ └── types │ │ │ │ │ │ ├── any.go │ │ │ │ │ │ ├── any.pb.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── duration.go │ │ │ │ │ │ ├── duration.pb.go │ │ │ │ │ │ ├── duration_gogo.go │ │ │ │ │ │ ├── empty.pb.go │ │ │ │ │ │ ├── field_mask.pb.go │ │ │ │ │ │ ├── struct.pb.go │ │ │ │ │ │ ├── timestamp.go │ │ │ │ │ │ ├── timestamp.pb.go │ │ │ │ │ │ ├── timestamp_gogo.go │ │ │ │ │ │ └── wrappers.pb.go │ │ │ │ ├── golang │ │ │ │ │ └── protobuf │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ ├── proto │ │ │ │ │ │ ├── clone.go │ │ │ │ │ │ ├── decode.go │ │ │ │ │ │ ├── encode.go │ │ │ │ │ │ ├── equal.go │ │ │ │ │ │ ├── extensions.go │ │ │ │ │ │ ├── lib.go │ │ │ │ │ │ ├── message_set.go │ │ │ │ │ │ ├── pointer_reflect.go │ │ │ │ │ │ ├── pointer_unsafe.go │ │ │ │ │ │ ├── properties.go │ │ │ │ │ │ ├── text.go │ │ │ │ │ │ └── text_parser.go │ │ │ │ │ │ └── ptypes │ │ │ │ │ │ └── any │ │ │ │ │ │ ├── any.pb.go │ │ │ │ │ │ └── any.proto │ │ │ │ ├── google │ │ │ │ │ └── certificate-transparency │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ └── go │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ ├── asn1 │ │ │ │ │ │ ├── asn1.go │ │ │ │ │ │ ├── common.go │ │ │ │ │ │ └── marshal.go │ │ │ │ │ │ ├── client │ │ │ │ │ │ ├── getentries.go │ │ │ │ │ │ └── logclient.go │ │ │ │ │ │ ├── serialization.go │ │ │ │ │ │ ├── signatures.go │ │ │ │ │ │ ├── types.go │ │ │ │ │ │ └── x509 │ │ │ │ │ │ ├── cert_pool.go │ │ │ │ │ │ ├── pem_decrypt.go │ │ │ │ │ │ ├── pkcs1.go │ │ │ │ │ │ ├── pkcs8.go │ │ │ │ │ │ ├── pkix │ │ │ │ │ │ └── pkix.go │ │ │ │ │ │ ├── root.go │ │ │ │ │ │ ├── root_darwin.go │ │ │ │ │ │ ├── root_plan9.go │ │ │ │ │ │ ├── root_stub.go │ │ │ │ │ │ ├── root_unix.go │ │ │ │ │ │ ├── root_windows.go │ │ │ │ │ │ ├── sec1.go │ │ │ │ │ │ ├── verify.go │ │ │ │ │ │ └── x509.go │ │ │ │ ├── googleapis │ │ │ │ │ └── gax-go │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── gorilla │ │ │ │ │ ├── context │ │ │ │ │ │ └── LICENSE │ │ │ │ │ └── mux │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── grpc-ecosystem │ │ │ │ │ └── go-grpc-prometheus │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ ├── client.go │ │ │ │ │ │ ├── client_reporter.go │ │ │ │ │ │ ├── server.go │ │ │ │ │ │ ├── server_reporter.go │ │ │ │ │ │ └── util.go │ │ │ │ ├── hashicorp │ │ │ │ │ ├── consul │ │ │ │ │ │ └── LICENSE │ │ │ │ │ ├── go-immutable-radix │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ ├── edges.go │ │ │ │ │ │ ├── iradix.go │ │ │ │ │ │ ├── iter.go │ │ │ │ │ │ └── node.go │ │ │ │ │ ├── go-memdb │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ ├── index.go │ │ │ │ │ │ ├── memdb.go │ │ │ │ │ │ ├── schema.go │ │ │ │ │ │ └── txn.go │ │ │ │ │ ├── go-msgpack │ │ │ │ │ │ └── LICENSE │ │ │ │ │ ├── go-multierror │ │ │ │ │ │ └── LICENSE │ │ │ │ │ ├── go-sockaddr │ │ │ │ │ │ └── LICENSE │ │ │ │ │ ├── golang-lru │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ └── simplelru │ │ │ │ │ │ │ └── lru.go │ │ │ │ │ ├── memberlist │ │ │ │ │ │ └── LICENSE │ │ │ │ │ └── serf │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── imdario │ │ │ │ │ └── mergo │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── inconshreveable │ │ │ │ │ └── mousetrap │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── jmespath │ │ │ │ │ └── go-jmespath │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── kr │ │ │ │ │ └── pty │ │ │ │ │ │ └── License │ │ │ │ ├── mattn │ │ │ │ │ └── go-shellwords │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── matttproud │ │ │ │ │ └── golang_protobuf_extensions │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ ├── NOTICE │ │ │ │ │ │ └── pbutil │ │ │ │ │ │ ├── decode.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ └── encode.go │ │ │ │ ├── miekg │ │ │ │ │ └── dns │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── mistifyio │ │ │ │ │ └── go-zfs │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── moby │ │ │ │ │ └── buildkit │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── 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 │ │ │ │ │ │ │ ├── setns_linux.go │ │ │ │ │ │ │ ├── syscall_linux_386.go │ │ │ │ │ │ │ ├── syscall_linux_64.go │ │ │ │ │ │ │ ├── syscall_linux_arm.go │ │ │ │ │ │ │ ├── sysconfig.go │ │ │ │ │ │ │ ├── sysconfig_notcgo.go │ │ │ │ │ │ │ ├── unsupported.go │ │ │ │ │ │ │ └── xattrs_linux.go │ │ │ │ │ │ │ └── user │ │ │ │ │ │ │ ├── lookup.go │ │ │ │ │ │ │ ├── lookup_unix.go │ │ │ │ │ │ │ ├── lookup_unsupported.go │ │ │ │ │ │ │ └── user.go │ │ │ │ │ ├── runtime-spec │ │ │ │ │ │ └── LICENSE │ │ │ │ │ └── selinux │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── pborman │ │ │ │ │ └── uuid │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── philhofer │ │ │ │ │ └── fwd │ │ │ │ │ │ └── LICENSE.md │ │ │ │ ├── pivotal-golang │ │ │ │ │ └── clock │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── pkg │ │ │ │ │ └── errors │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ ├── errors.go │ │ │ │ │ │ └── stack.go │ │ │ │ ├── pmezard │ │ │ │ │ └── go-difflib │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── prometheus │ │ │ │ │ ├── client_golang │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ ├── NOTICE │ │ │ │ │ │ └── prometheus │ │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ │ ├── collector.go │ │ │ │ │ │ │ ├── counter.go │ │ │ │ │ │ │ ├── desc.go │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ ├── expvar.go │ │ │ │ │ │ │ ├── fnv.go │ │ │ │ │ │ │ ├── gauge.go │ │ │ │ │ │ │ ├── go_collector.go │ │ │ │ │ │ │ ├── histogram.go │ │ │ │ │ │ │ ├── http.go │ │ │ │ │ │ │ ├── metric.go │ │ │ │ │ │ │ ├── process_collector.go │ │ │ │ │ │ │ ├── push.go │ │ │ │ │ │ │ ├── registry.go │ │ │ │ │ │ │ ├── summary.go │ │ │ │ │ │ │ ├── untyped.go │ │ │ │ │ │ │ ├── value.go │ │ │ │ │ │ │ └── vec.go │ │ │ │ │ ├── client_model │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ ├── NOTICE │ │ │ │ │ │ └── go │ │ │ │ │ │ │ └── metrics.pb.go │ │ │ │ │ ├── common │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ ├── NOTICE │ │ │ │ │ │ ├── expfmt │ │ │ │ │ │ │ ├── decode.go │ │ │ │ │ │ │ ├── encode.go │ │ │ │ │ │ │ ├── expfmt.go │ │ │ │ │ │ │ ├── fuzz.go │ │ │ │ │ │ │ ├── text_create.go │ │ │ │ │ │ │ └── text_parse.go │ │ │ │ │ │ ├── internal │ │ │ │ │ │ │ └── bitbucket.org │ │ │ │ │ │ │ │ └── ww │ │ │ │ │ │ │ │ └── goautoneg │ │ │ │ │ │ │ │ ├── README.txt │ │ │ │ │ │ │ │ └── autoneg.go │ │ │ │ │ │ └── model │ │ │ │ │ │ │ ├── alert.go │ │ │ │ │ │ │ ├── fingerprinting.go │ │ │ │ │ │ │ ├── fnv.go │ │ │ │ │ │ │ ├── labels.go │ │ │ │ │ │ │ ├── labelset.go │ │ │ │ │ │ │ ├── metric.go │ │ │ │ │ │ │ ├── model.go │ │ │ │ │ │ │ ├── signature.go │ │ │ │ │ │ │ ├── silence.go │ │ │ │ │ │ │ ├── time.go │ │ │ │ │ │ │ └── value.go │ │ │ │ │ └── procfs │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ ├── NOTICE │ │ │ │ │ │ ├── README.md │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── fs.go │ │ │ │ │ │ ├── ipvs.go │ │ │ │ │ │ ├── mdstat.go │ │ │ │ │ │ ├── proc.go │ │ │ │ │ │ ├── proc_io.go │ │ │ │ │ │ ├── proc_limits.go │ │ │ │ │ │ ├── proc_stat.go │ │ │ │ │ │ └── stat.go │ │ │ │ ├── samuel │ │ │ │ │ └── go-zookeeper │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── sean- │ │ │ │ │ └── seed │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── seccomp │ │ │ │ │ └── libseccomp-golang │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── 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_appengine.go │ │ │ │ │ │ ├── terminal_bsd.go │ │ │ │ │ │ ├── terminal_linux.go │ │ │ │ │ │ ├── terminal_notwindows.go │ │ │ │ │ │ ├── terminal_solaris.go │ │ │ │ │ │ ├── terminal_windows.go │ │ │ │ │ │ ├── text_formatter.go │ │ │ │ │ │ └── writer.go │ │ │ │ ├── spf13 │ │ │ │ │ ├── cobra │ │ │ │ │ │ └── LICENSE.txt │ │ │ │ │ └── pflag │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── stevvooe │ │ │ │ │ └── continuity │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── stretchr │ │ │ │ │ └── testify │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── syndtr │ │ │ │ │ └── gocapability │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── tchap │ │ │ │ │ └── go-patricia │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── tinylib │ │ │ │ │ └── msgp │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── tonistiigi │ │ │ │ │ ├── fifo │ │ │ │ │ │ └── LICENSE │ │ │ │ │ └── fsutil │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── ugorji │ │ │ │ │ └── go │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── vbatts │ │ │ │ │ └── tar-split │ │ │ │ │ │ └── LICENSE │ │ │ │ ├── vdemeester │ │ │ │ │ └── shakers │ │ │ │ │ │ └── LICENSE │ │ │ │ └── vishvananda │ │ │ │ │ ├── netlink │ │ │ │ │ └── LICENSE │ │ │ │ │ └── netns │ │ │ │ │ └── LICENSE │ │ │ │ ├── golang.org │ │ │ │ └── x │ │ │ │ │ ├── crypto │ │ │ │ │ ├── LICENSE │ │ │ │ │ ├── PATENTS │ │ │ │ │ └── pkcs12 │ │ │ │ │ │ ├── bmp-string.go │ │ │ │ │ │ ├── crypto.go │ │ │ │ │ │ ├── errors.go │ │ │ │ │ │ ├── internal │ │ │ │ │ │ └── rc2 │ │ │ │ │ │ │ └── rc2.go │ │ │ │ │ │ ├── mac.go │ │ │ │ │ │ ├── pbkdf.go │ │ │ │ │ │ ├── pkcs12.go │ │ │ │ │ │ └── safebags.go │ │ │ │ │ ├── net │ │ │ │ │ ├── LICENSE │ │ │ │ │ ├── PATENTS │ │ │ │ │ ├── context │ │ │ │ │ │ ├── context.go │ │ │ │ │ │ ├── ctxhttp │ │ │ │ │ │ │ ├── ctxhttp.go │ │ │ │ │ │ │ └── ctxhttp_pre17.go │ │ │ │ │ │ ├── go17.go │ │ │ │ │ │ └── pre_go17.go │ │ │ │ │ ├── http2 │ │ │ │ │ │ ├── README │ │ │ │ │ │ ├── ciphers.go │ │ │ │ │ │ ├── client_conn_pool.go │ │ │ │ │ │ ├── configure_transport.go │ │ │ │ │ │ ├── databuffer.go │ │ │ │ │ │ ├── errors.go │ │ │ │ │ │ ├── flow.go │ │ │ │ │ │ ├── frame.go │ │ │ │ │ │ ├── go16.go │ │ │ │ │ │ ├── go17.go │ │ │ │ │ │ ├── go17_not18.go │ │ │ │ │ │ ├── go18.go │ │ │ │ │ │ ├── go19.go │ │ │ │ │ │ ├── gotrack.go │ │ │ │ │ │ ├── headermap.go │ │ │ │ │ │ ├── hpack │ │ │ │ │ │ │ ├── encode.go │ │ │ │ │ │ │ ├── hpack.go │ │ │ │ │ │ │ ├── huffman.go │ │ │ │ │ │ │ └── tables.go │ │ │ │ │ │ ├── http2.go │ │ │ │ │ │ ├── not_go16.go │ │ │ │ │ │ ├── not_go17.go │ │ │ │ │ │ ├── not_go18.go │ │ │ │ │ │ ├── not_go19.go │ │ │ │ │ │ ├── pipe.go │ │ │ │ │ │ ├── server.go │ │ │ │ │ │ ├── transport.go │ │ │ │ │ │ ├── write.go │ │ │ │ │ │ ├── writesched.go │ │ │ │ │ │ ├── writesched_priority.go │ │ │ │ │ │ └── writesched_random.go │ │ │ │ │ ├── idna │ │ │ │ │ │ ├── idna.go │ │ │ │ │ │ ├── punycode.go │ │ │ │ │ │ ├── tables.go │ │ │ │ │ │ ├── trie.go │ │ │ │ │ │ └── trieval.go │ │ │ │ │ ├── internal │ │ │ │ │ │ └── timeseries │ │ │ │ │ │ │ └── timeseries.go │ │ │ │ │ ├── lex │ │ │ │ │ │ └── httplex │ │ │ │ │ │ │ └── httplex.go │ │ │ │ │ └── trace │ │ │ │ │ │ ├── events.go │ │ │ │ │ │ ├── histogram.go │ │ │ │ │ │ ├── trace.go │ │ │ │ │ │ ├── trace_go16.go │ │ │ │ │ │ └── trace_go17.go │ │ │ │ │ ├── oauth2 │ │ │ │ │ └── LICENSE │ │ │ │ │ ├── sync │ │ │ │ │ ├── LICENSE │ │ │ │ │ └── PATENTS │ │ │ │ │ ├── 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_solaris_amd64.s │ │ │ │ │ │ ├── bluetooth_linux.go │ │ │ │ │ │ ├── constants.go │ │ │ │ │ │ ├── dirent.go │ │ │ │ │ │ ├── endian_big.go │ │ │ │ │ │ ├── endian_little.go │ │ │ │ │ │ ├── env_unix.go │ │ │ │ │ │ ├── env_unset.go │ │ │ │ │ │ ├── flock.go │ │ │ │ │ │ ├── flock_linux_32bit.go │ │ │ │ │ │ ├── gccgo.go │ │ │ │ │ │ ├── gccgo_c.c │ │ │ │ │ │ ├── gccgo_linux_amd64.go │ │ │ │ │ │ ├── gccgo_linux_sparc64.go │ │ │ │ │ │ ├── openbsd_pledge.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_solaris.go │ │ │ │ │ │ ├── syscall_solaris_amd64.go │ │ │ │ │ │ ├── syscall_unix.go │ │ │ │ │ │ ├── syscall_unix_gc.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_solaris_amd64.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_solaris_amd64.go │ │ │ │ │ │ ├── zsysctl_openbsd.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_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_solaris_amd64.go │ │ │ │ │ ├── text │ │ │ │ │ ├── LICENSE │ │ │ │ │ ├── PATENTS │ │ │ │ │ ├── secure │ │ │ │ │ │ └── bidirule │ │ │ │ │ │ │ └── bidirule.go │ │ │ │ │ ├── transform │ │ │ │ │ │ └── transform.go │ │ │ │ │ └── unicode │ │ │ │ │ │ ├── bidi │ │ │ │ │ │ ├── bidi.go │ │ │ │ │ │ ├── bracket.go │ │ │ │ │ │ ├── core.go │ │ │ │ │ │ ├── prop.go │ │ │ │ │ │ ├── tables.go │ │ │ │ │ │ └── trieval.go │ │ │ │ │ │ └── norm │ │ │ │ │ │ ├── composition.go │ │ │ │ │ │ ├── forminfo.go │ │ │ │ │ │ ├── input.go │ │ │ │ │ │ ├── iter.go │ │ │ │ │ │ ├── normalize.go │ │ │ │ │ │ ├── readwriter.go │ │ │ │ │ │ ├── tables.go │ │ │ │ │ │ ├── transform.go │ │ │ │ │ │ └── trie.go │ │ │ │ │ └── time │ │ │ │ │ ├── LICENSE │ │ │ │ │ └── PATENTS │ │ │ │ └── google.golang.org │ │ │ │ ├── api │ │ │ │ └── LICENSE │ │ │ │ ├── genproto │ │ │ │ ├── LICENSE │ │ │ │ └── googleapis │ │ │ │ │ └── rpc │ │ │ │ │ └── status │ │ │ │ │ └── status.pb.go │ │ │ │ └── grpc │ │ │ │ ├── LICENSE │ │ │ │ ├── PATENTS │ │ │ │ ├── README.md │ │ │ │ ├── backoff.go │ │ │ │ ├── balancer.go │ │ │ │ ├── call.go │ │ │ │ ├── clientconn.go │ │ │ │ ├── codec.go │ │ │ │ ├── codes │ │ │ │ ├── code_string.go │ │ │ │ └── codes.go │ │ │ │ ├── credentials │ │ │ │ ├── credentials.go │ │ │ │ ├── credentials_util_go17.go │ │ │ │ ├── credentials_util_go18.go │ │ │ │ ├── credentials_util_pre_go17.go │ │ │ │ └── oauth │ │ │ │ │ └── oauth.go │ │ │ │ ├── doc.go │ │ │ │ ├── go16.go │ │ │ │ ├── go17.go │ │ │ │ ├── grpclb.go │ │ │ │ ├── grpclb │ │ │ │ └── grpc_lb_v1 │ │ │ │ │ ├── grpclb.pb.go │ │ │ │ │ └── grpclb.proto │ │ │ │ ├── grpclog │ │ │ │ └── logger.go │ │ │ │ ├── health │ │ │ │ ├── grpc_health_v1 │ │ │ │ │ ├── health.pb.go │ │ │ │ │ └── health.proto │ │ │ │ └── health.go │ │ │ │ ├── interceptor.go │ │ │ │ ├── internal │ │ │ │ └── internal.go │ │ │ │ ├── keepalive │ │ │ │ └── keepalive.go │ │ │ │ ├── metadata │ │ │ │ └── metadata.go │ │ │ │ ├── naming │ │ │ │ └── naming.go │ │ │ │ ├── peer │ │ │ │ └── peer.go │ │ │ │ ├── proxy.go │ │ │ │ ├── rpc_util.go │ │ │ │ ├── server.go │ │ │ │ ├── stats │ │ │ │ ├── handlers.go │ │ │ │ └── stats.go │ │ │ │ ├── status │ │ │ │ └── status.go │ │ │ │ ├── stream.go │ │ │ │ ├── tap │ │ │ │ └── tap.go │ │ │ │ ├── trace.go │ │ │ │ └── transport │ │ │ │ ├── control.go │ │ │ │ ├── go16.go │ │ │ │ ├── go17.go │ │ │ │ ├── handler_server.go │ │ │ │ ├── http2_client.go │ │ │ │ ├── http2_server.go │ │ │ │ ├── http_util.go │ │ │ │ └── transport.go │ │ └── go-units │ │ │ ├── CONTRIBUTING.md │ │ │ ├── LICENSE │ │ │ ├── MAINTAINERS │ │ │ ├── README.md │ │ │ ├── circle.yml │ │ │ ├── duration.go │ │ │ ├── size.go │ │ │ └── ulimit.go │ ├── fsouza │ │ └── go-dockerclient │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── AUTHORS │ │ │ ├── DOCKER-LICENSE │ │ │ ├── LICENSE │ │ │ ├── Makefile │ │ │ ├── README.markdown │ │ │ ├── appveyor.yml │ │ │ ├── auth.go │ │ │ ├── change.go │ │ │ ├── client.go │ │ │ ├── client_unix.go │ │ │ ├── client_windows.go │ │ │ ├── container.go │ │ │ ├── env.go │ │ │ ├── event.go │ │ │ ├── exec.go │ │ │ ├── image.go │ │ │ ├── misc.go │ │ │ ├── network.go │ │ │ ├── node.go │ │ │ ├── service.go │ │ │ ├── signal.go │ │ │ ├── swarm.go │ │ │ ├── tar.go │ │ │ ├── task.go │ │ │ ├── testing │ │ │ ├── data │ │ │ │ ├── .dockerignore │ │ │ │ ├── Dockerfile │ │ │ │ ├── barfile │ │ │ │ ├── ca.pem │ │ │ │ ├── cert.pem │ │ │ │ ├── container.tar │ │ │ │ ├── dockerfile.tar │ │ │ │ ├── foofile │ │ │ │ ├── key.pem │ │ │ │ ├── server.pem │ │ │ │ └── serverkey.pem │ │ │ ├── server.go │ │ │ └── swarm.go │ │ │ ├── tls.go │ │ │ ├── travis-scripts │ │ │ ├── install-docker.bash │ │ │ └── run-tests.bash │ │ │ └── volume.go │ ├── google │ │ └── go-cmp │ │ │ ├── LICENSE │ │ │ └── cmp │ │ │ ├── cmpopts │ │ │ ├── equate.go │ │ │ ├── ignore.go │ │ │ ├── sort.go │ │ │ ├── sort_go17.go │ │ │ ├── sort_go18.go │ │ │ └── struct_filter.go │ │ │ ├── compare.go │ │ │ ├── internal │ │ │ ├── diff │ │ │ │ ├── debug_disable.go │ │ │ │ ├── debug_enable.go │ │ │ │ └── diff.go │ │ │ ├── function │ │ │ │ └── func.go │ │ │ ├── testprotos │ │ │ │ └── protos.go │ │ │ ├── teststructs │ │ │ │ ├── project1.go │ │ │ │ ├── project2.go │ │ │ │ ├── project3.go │ │ │ │ ├── project4.go │ │ │ │ └── structs.go │ │ │ └── value │ │ │ │ ├── format.go │ │ │ │ └── sort.go │ │ │ ├── options.go │ │ │ ├── path.go │ │ │ ├── reporter.go │ │ │ ├── unsafe_panic.go │ │ │ └── unsafe_reflect.go │ └── op │ │ └── go-logging │ │ ├── .travis.yml │ │ ├── CHANGELOG.md │ │ ├── CONTRIBUTORS │ │ ├── LICENSE │ │ ├── README.md │ │ ├── backend.go │ │ ├── examples │ │ ├── example.go │ │ └── example.png │ │ ├── format.go │ │ ├── level.go │ │ ├── log_nix.go │ │ ├── log_windows.go │ │ ├── logger.go │ │ ├── memory.go │ │ ├── multi.go │ │ ├── syslog.go │ │ └── syslog_fallback.go │ └── golang.org │ └── x │ └── net │ ├── LICENSE │ ├── PATENTS │ └── context │ ├── context.go │ ├── ctxhttp │ ├── ctxhttp.go │ └── ctxhttp_pre17.go │ ├── go17.go │ ├── go19.go │ ├── pre_go17.go │ └── pre_go19.go ├── README.md ├── Vagrantfile ├── config.rb ├── dev-container └── Dockerfile ├── docker-logstash-forwarder.go ├── forwarder ├── config │ └── config.go └── forwarder.go ├── user-data └── utils └── utils.go /.gitignore: -------------------------------------------------------------------------------- 1 | .vagrant/ 2 | -------------------------------------------------------------------------------- /Dockerfile: -------------------------------------------------------------------------------- 1 | FROM digitalwonderland/base 2 | 3 | RUN curl -Lo /usr/local/bin/docker-logstash-forwarder https://github.com/digital-wonderland/docker-logstash-forwarder/releases/download/latest/linux_amd64_docker-logstash-forwarder \ 4 | && curl -Lo /usr/local/bin/logstash-forwarder https://github.com/digital-wonderland/docker-logstash-forwarder/releases/download/latest/linux_amd64_logstash-forwarder \ 5 | && chmod 0755 /usr/local/bin/{docker-logstash-forwarder,logstash-forwarder} 6 | 7 | ENTRYPOINT ["/usr/local/bin/docker-logstash-forwarder"] 8 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 container change response item 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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 container create created body 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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 container top o k body 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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 container update o k body 11 | // swagger:model ContainerUpdateOKBody 12 | type ContainerUpdateOKBody struct { 13 | 14 | // warnings 15 | // Required: true 16 | Warnings []string `json:"Warnings"` 17 | } 18 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/api/types/container/container_wait.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 | // ContainerWaitOKBody container wait o k body 11 | // swagger:model ContainerWaitOKBody 12 | type ContainerWaitOKBody struct { 13 | 14 | // Exit code of the container 15 | // Required: true 16 | StatusCode int64 `json:"StatusCode"` 17 | } 18 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/api/types/container/hostconfig_unix.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package container 4 | 5 | // IsValid indicates if an isolation technology is valid 6 | func (i Isolation) IsValid() bool { 7 | return i.IsDefault() 8 | } 9 | 10 | // NetworkName returns the name of the network stack. 11 | func (n NetworkMode) NetworkName() string { 12 | if n.IsBridge() { 13 | return "bridge" 14 | } else if n.IsHost() { 15 | return "host" 16 | } else if n.IsContainer() { 17 | return "container" 18 | } else if n.IsNone() { 19 | return "none" 20 | } else if n.IsDefault() { 21 | return "default" 22 | } else if n.IsUserDefined() { 23 | return n.UserDefined() 24 | } 25 | return "" 26 | } 27 | 28 | // IsBridge indicates whether container uses the bridge network stack 29 | func (n NetworkMode) IsBridge() bool { 30 | return n == "bridge" 31 | } 32 | 33 | // IsHost indicates whether container uses the host network stack. 34 | func (n NetworkMode) IsHost() bool { 35 | return n == "host" 36 | } 37 | 38 | // IsUserDefined indicates user-created network 39 | func (n NetworkMode) IsUserDefined() bool { 40 | return !n.IsDefault() && !n.IsBridge() && !n.IsHost() && !n.IsNone() && !n.IsContainer() 41 | } 42 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/api/types/container/waitcondition.go: -------------------------------------------------------------------------------- 1 | package container 2 | 3 | // WaitCondition is a type used to specify a container state for which 4 | // to wait. 5 | type WaitCondition string 6 | 7 | // Possible WaitCondition Values. 8 | // 9 | // WaitConditionNotRunning (default) is used to wait for any of the non-running 10 | // states: "created", "exited", "dead", "removing", or "removed". 11 | // 12 | // WaitConditionNextExit is used to wait for the next time the state changes 13 | // to a non-running state. If the state is currently "created" or "exited", 14 | // this would cause Wait() to block until either the container runs and exits 15 | // or is removed. 16 | // 17 | // WaitConditionRemoved is used to wait for the container to be removed. 18 | const ( 19 | WaitConditionNotRunning WaitCondition = "not-running" 20 | WaitConditionNextExit WaitCondition = "next-exit" 21 | WaitConditionRemoved WaitCondition = "removed" 22 | ) 23 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/api/types/image/image_history.go: -------------------------------------------------------------------------------- 1 | package image 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 | // HistoryResponseItem history response item 11 | // swagger:model HistoryResponseItem 12 | type HistoryResponseItem struct { 13 | 14 | // comment 15 | // Required: true 16 | Comment string `json:"Comment"` 17 | 18 | // created 19 | // Required: true 20 | Created int64 `json:"Created"` 21 | 22 | // created by 23 | // Required: true 24 | CreatedBy string `json:"CreatedBy"` 25 | 26 | // Id 27 | // Required: true 28 | ID string `json:"Id"` 29 | 30 | // size 31 | // Required: true 32 | Size int64 `json:"Size"` 33 | 34 | // tags 35 | // Required: true 36 | Tags []string `json:"Tags"` 37 | } 38 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/api/types/image_summary.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 | // ImageSummary image summary 7 | // swagger:model ImageSummary 8 | type ImageSummary struct { 9 | 10 | // containers 11 | // Required: true 12 | Containers int64 `json:"Containers"` 13 | 14 | // created 15 | // Required: true 16 | Created int64 `json:"Created"` 17 | 18 | // Id 19 | // Required: true 20 | ID string `json:"Id"` 21 | 22 | // labels 23 | // Required: true 24 | Labels map[string]string `json:"Labels"` 25 | 26 | // parent Id 27 | // Required: true 28 | ParentID string `json:"ParentId"` 29 | 30 | // repo digests 31 | // Required: true 32 | RepoDigests []string `json:"RepoDigests"` 33 | 34 | // repo tags 35 | // Required: true 36 | RepoTags []string `json:"RepoTags"` 37 | 38 | // shared size 39 | // Required: true 40 | SharedSize int64 `json:"SharedSize"` 41 | 42 | // size 43 | // Required: true 44 | Size int64 `json:"Size"` 45 | 46 | // virtual size 47 | // Required: true 48 | VirtualSize int64 `json:"VirtualSize"` 49 | } 50 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/api/types/plugin_mount.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 | // PluginMount plugin mount 7 | // swagger:model PluginMount 8 | type PluginMount struct { 9 | 10 | // description 11 | // Required: true 12 | Description string `json:"Description"` 13 | 14 | // destination 15 | // Required: true 16 | Destination string `json:"Destination"` 17 | 18 | // name 19 | // Required: true 20 | Name string `json:"Name"` 21 | 22 | // options 23 | // Required: true 24 | Options []string `json:"Options"` 25 | 26 | // settable 27 | // Required: true 28 | Settable []string `json:"Settable"` 29 | 30 | // source 31 | // Required: true 32 | Source *string `json:"Source"` 33 | 34 | // type 35 | // Required: true 36 | Type string `json:"Type"` 37 | } 38 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/api/types/plugins/logdriver/entry.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | message LogEntry { 4 | string source = 1; 5 | int64 time_nano = 2; 6 | bytes line = 3; 7 | bool partial = 4; 8 | } 9 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/api/types/plugins/logdriver/gen.go: -------------------------------------------------------------------------------- 1 | //go:generate protoc --gogofast_out=import_path=github.com/docker/docker/api/types/plugins/logdriver:. entry.proto 2 | 3 | package logdriver 4 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/api/types/strslice/strslice.go: -------------------------------------------------------------------------------- 1 | package strslice 2 | 3 | import "encoding/json" 4 | 5 | // StrSlice represents a string or an array of strings. 6 | // We need to override the json decoder to accept both options. 7 | type StrSlice []string 8 | 9 | // UnmarshalJSON decodes the byte slice whether it's a string or an array of 10 | // strings. This method is needed to implement json.Unmarshaler. 11 | func (e *StrSlice) UnmarshalJSON(b []byte) error { 12 | if len(b) == 0 { 13 | // With no input, we preserve the existing value by returning nil and 14 | // leaving the target alone. This allows defining default values for 15 | // the type. 16 | return nil 17 | } 18 | 19 | p := make([]string, 0, 1) 20 | if err := json.Unmarshal(b, &p); err != nil { 21 | var s string 22 | if err := json.Unmarshal(b, &s); err != nil { 23 | return err 24 | } 25 | p = append(p, s) 26 | } 27 | 28 | *e = p 29 | return nil 30 | } 31 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/api/types/swarm/runtime/plugin.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | // PluginSpec defines the base payload which clients can specify for creating 4 | // a service with the plugin runtime. 5 | message PluginSpec { 6 | string name = 1; 7 | string remote = 2; 8 | repeated PluginPrivilege privileges = 3; 9 | bool disabled = 4; 10 | } 11 | 12 | // PluginPrivilege describes a permission the user has to accept 13 | // upon installing a plugin. 14 | message PluginPrivilege { 15 | string name = 1; 16 | string description = 2; 17 | repeated string value = 3; 18 | } 19 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/api/types/swarm/secret.go: -------------------------------------------------------------------------------- 1 | package swarm 2 | 3 | import "os" 4 | 5 | // Secret represents a secret. 6 | type Secret struct { 7 | ID string 8 | Meta 9 | Spec SecretSpec 10 | } 11 | 12 | // SecretSpec represents a secret specification from a secret in swarm 13 | type SecretSpec struct { 14 | Annotations 15 | Data []byte `json:",omitempty"` 16 | Driver *Driver `json:",omitempty"` // name of the secrets driver used to fetch the secret's value from an external secret store 17 | } 18 | 19 | // SecretReferenceFileTarget is a file target in a secret reference 20 | type SecretReferenceFileTarget struct { 21 | Name string 22 | UID string 23 | GID string 24 | Mode os.FileMode 25 | } 26 | 27 | // SecretReference is a reference to a secret in swarm 28 | type SecretReference struct { 29 | File *SecretReferenceFileTarget 30 | SecretID string 31 | SecretName string 32 | } 33 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/api/types/time/duration_convert.go: -------------------------------------------------------------------------------- 1 | package time 2 | 3 | import ( 4 | "strconv" 5 | "time" 6 | ) 7 | 8 | // DurationToSecondsString converts the specified duration to the number 9 | // seconds it represents, formatted as a string. 10 | func DurationToSecondsString(duration time.Duration) string { 11 | return strconv.FormatFloat(duration.Seconds(), 'f', 0, 64) 12 | } 13 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/api/types/versions/v1p19/types.go: -------------------------------------------------------------------------------- 1 | // Package v1p19 provides specific API types for the API version 1, patch 19. 2 | package v1p19 3 | 4 | import ( 5 | "github.com/docker/docker/api/types" 6 | "github.com/docker/docker/api/types/container" 7 | "github.com/docker/docker/api/types/versions/v1p20" 8 | "github.com/docker/go-connections/nat" 9 | ) 10 | 11 | // ContainerJSON is a backcompatibility struct for APIs prior to 1.20. 12 | // Note this is not used by the Windows daemon. 13 | type ContainerJSON struct { 14 | *types.ContainerJSONBase 15 | Volumes map[string]string 16 | VolumesRW map[string]bool 17 | Config *ContainerConfig 18 | NetworkSettings *v1p20.NetworkSettings 19 | } 20 | 21 | // ContainerConfig is a backcompatibility struct for APIs prior to 1.20. 22 | type ContainerConfig struct { 23 | *container.Config 24 | 25 | MacAddress string 26 | NetworkDisabled bool 27 | ExposedPorts map[nat.Port]struct{} 28 | 29 | // backward compatibility, they now live in HostConfig 30 | VolumeDriver string 31 | Memory int64 32 | MemorySwap int64 33 | CPUShares int64 `json:"CpuShares"` 34 | CPUSet string `json:"Cpuset"` 35 | } 36 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/api/types/volume/volumes_create.go: -------------------------------------------------------------------------------- 1 | package volume 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 | // VolumesCreateBody volumes create body 11 | // swagger:model VolumesCreateBody 12 | type VolumesCreateBody struct { 13 | 14 | // Name of the volume driver to use. 15 | // Required: true 16 | Driver string `json:"Driver"` 17 | 18 | // A mapping of driver options and values. These options are passed directly to the driver and are driver specific. 19 | // Required: true 20 | DriverOpts map[string]string `json:"DriverOpts"` 21 | 22 | // User-defined key/value metadata. 23 | // Required: true 24 | Labels map[string]string `json:"Labels"` 25 | 26 | // The new volume's name. If not specified, Docker generates a name. 27 | // Required: true 28 | Name string `json:"Name"` 29 | } 30 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/api/types/volume/volumes_list.go: -------------------------------------------------------------------------------- 1 | package volume 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 | import "github.com/docker/docker/api/types" 11 | 12 | // VolumesListOKBody volumes list o k body 13 | // swagger:model VolumesListOKBody 14 | type VolumesListOKBody struct { 15 | 16 | // List of volumes 17 | // Required: true 18 | Volumes []*types.Volume `json:"Volumes"` 19 | 20 | // Warnings that occurred when fetching the list of volumes 21 | // Required: true 22 | Warnings []string `json:"Warnings"` 23 | } 24 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/opts/hosts_windows.go: -------------------------------------------------------------------------------- 1 | // +build windows 2 | 3 | package opts 4 | 5 | // DefaultHost constant defines the default host string used by docker on Windows 6 | var DefaultHost = "npipe://" + DefaultNamedPipe 7 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/opts/quotedstring.go: -------------------------------------------------------------------------------- 1 | package opts 2 | 3 | // QuotedString is a string that may have extra quotes around the value. The 4 | // quotes are stripped from the value. 5 | type QuotedString struct { 6 | value *string 7 | } 8 | 9 | // Set sets a new value 10 | func (s *QuotedString) Set(val string) error { 11 | *s.value = trimQuotes(val) 12 | return nil 13 | } 14 | 15 | // Type returns the type of the value 16 | func (s *QuotedString) Type() string { 17 | return "string" 18 | } 19 | 20 | func (s *QuotedString) String() string { 21 | return string(*s.value) 22 | } 23 | 24 | func trimQuotes(value string) string { 25 | lastIndex := len(value) - 1 26 | for _, char := range []byte{'\'', '"'} { 27 | if value[0] == char && value[lastIndex] == char { 28 | return value[1:lastIndex] 29 | } 30 | } 31 | return value 32 | } 33 | 34 | // NewQuotedString returns a new quoted string option 35 | func NewQuotedString(value *string) *QuotedString { 36 | return &QuotedString{value: value} 37 | } 38 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/archive/README.md: -------------------------------------------------------------------------------- 1 | This code provides helper functions for dealing with archive files. 2 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/archive/changes_unix.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package archive 4 | 5 | import ( 6 | "os" 7 | "syscall" 8 | 9 | "github.com/docker/docker/pkg/system" 10 | "golang.org/x/sys/unix" 11 | ) 12 | 13 | func statDifferent(oldStat *system.StatT, newStat *system.StatT) bool { 14 | // Don't look at size for dirs, its not a good measure of change 15 | if oldStat.Mode() != newStat.Mode() || 16 | oldStat.UID() != newStat.UID() || 17 | oldStat.GID() != newStat.GID() || 18 | oldStat.Rdev() != newStat.Rdev() || 19 | // Don't look at size for dirs, its not a good measure of change 20 | (oldStat.Mode()&unix.S_IFDIR != unix.S_IFDIR && 21 | (!sameFsTimeSpec(oldStat.Mtim(), newStat.Mtim()) || (oldStat.Size() != newStat.Size()))) { 22 | return true 23 | } 24 | return false 25 | } 26 | 27 | func (info *FileInfo) isDir() bool { 28 | return info.parent == nil || info.stat.Mode()&unix.S_IFDIR != 0 29 | } 30 | 31 | func getIno(fi os.FileInfo) uint64 { 32 | return uint64(fi.Sys().(*syscall.Stat_t).Ino) 33 | } 34 | 35 | func hasHardlinks(fi os.FileInfo) bool { 36 | return fi.Sys().(*syscall.Stat_t).Nlink > 1 37 | } 38 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/fileutils/fileutils_solaris.go: -------------------------------------------------------------------------------- 1 | package fileutils 2 | 3 | // GetTotalUsedFds Returns the number of used File Descriptors. 4 | // On Solaris these limits are per process and not systemwide 5 | func GetTotalUsedFds() int { 6 | return -1 7 | } 8 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/homedir/homedir_linux.go: -------------------------------------------------------------------------------- 1 | // +build linux 2 | 3 | package homedir 4 | 5 | import ( 6 | "os" 7 | 8 | "github.com/docker/docker/pkg/idtools" 9 | ) 10 | 11 | // GetStatic returns the home directory for the current user without calling 12 | // os/user.Current(). This is useful for static-linked binary on glibc-based 13 | // system, because a call to os/user.Current() in a static binary leads to 14 | // segfault due to a glibc issue that won't be fixed in a short term. 15 | // (#29344, golang/go#13470, https://sourceware.org/bugzilla/show_bug.cgi?id=19341) 16 | func GetStatic() (string, error) { 17 | uid := os.Getuid() 18 | usr, err := idtools.LookupUID(uid) 19 | if err != nil { 20 | return "", err 21 | } 22 | return usr.Home, nil 23 | } 24 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/homedir/homedir_unix.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package homedir 4 | 5 | import ( 6 | "os" 7 | 8 | "github.com/opencontainers/runc/libcontainer/user" 9 | ) 10 | 11 | // Key returns the env var name for the user's home dir based on 12 | // the platform being run on 13 | func Key() string { 14 | return "HOME" 15 | } 16 | 17 | // Get returns the home directory of the current user with the help of 18 | // environment variables depending on the target operating system. 19 | // Returned path should be used with "path/filepath" to form new paths. 20 | func Get() string { 21 | home := os.Getenv(Key()) 22 | if home == "" { 23 | if u, err := user.CurrentUser(); err == nil { 24 | return u.Home 25 | } 26 | } 27 | return home 28 | } 29 | 30 | // GetShortcutString returns the string that is shortcut to user's home directory 31 | // in the native shell of the platform running on. 32 | func GetShortcutString() string { 33 | return "~" 34 | } 35 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/idtools/idtools_windows.go: -------------------------------------------------------------------------------- 1 | // +build windows 2 | 3 | package idtools 4 | 5 | import ( 6 | "os" 7 | 8 | "github.com/docker/docker/pkg/system" 9 | ) 10 | 11 | // Platforms such as Windows do not support the UID/GID concept. So make this 12 | // just a wrapper around system.MkdirAll. 13 | func mkdirAs(path string, mode os.FileMode, ownerUID, ownerGID int, mkAll, chownExisting bool) error { 14 | if err := system.MkdirAll(path, mode, ""); err != nil && !os.IsExist(err) { 15 | return err 16 | } 17 | return nil 18 | } 19 | 20 | // CanAccess takes a valid (existing) directory and a uid, gid pair and determines 21 | // if that uid, gid pair has access (execute bit) to the directory 22 | // Windows does not require/support this function, so always return true 23 | func CanAccess(path string, pair IDPair) bool { 24 | return true 25 | } 26 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/idtools/utils_unix.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package idtools 4 | 5 | import ( 6 | "fmt" 7 | "os/exec" 8 | "path/filepath" 9 | "strings" 10 | ) 11 | 12 | func resolveBinary(binname string) (string, error) { 13 | binaryPath, err := exec.LookPath(binname) 14 | if err != nil { 15 | return "", err 16 | } 17 | resolvedPath, err := filepath.EvalSymlinks(binaryPath) 18 | if err != nil { 19 | return "", err 20 | } 21 | //only return no error if the final resolved binary basename 22 | //matches what was searched for 23 | if filepath.Base(resolvedPath) == binname { 24 | return resolvedPath, nil 25 | } 26 | return "", fmt.Errorf("Binary %q does not resolve to a binary of that name in $PATH (%q)", binname, resolvedPath) 27 | } 28 | 29 | func execCmd(cmd, args string) ([]byte, error) { 30 | execCmd := exec.Command(cmd, strings.Split(args, " ")...) 31 | return execCmd.CombinedOutput() 32 | } 33 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/ioutils/buffer.go: -------------------------------------------------------------------------------- 1 | package ioutils 2 | 3 | import ( 4 | "errors" 5 | "io" 6 | ) 7 | 8 | var errBufferFull = errors.New("buffer is full") 9 | 10 | type fixedBuffer struct { 11 | buf []byte 12 | pos int 13 | lastRead int 14 | } 15 | 16 | func (b *fixedBuffer) Write(p []byte) (int, error) { 17 | n := copy(b.buf[b.pos:cap(b.buf)], p) 18 | b.pos += n 19 | 20 | if n < len(p) { 21 | if b.pos == cap(b.buf) { 22 | return n, errBufferFull 23 | } 24 | return n, io.ErrShortWrite 25 | } 26 | return n, nil 27 | } 28 | 29 | func (b *fixedBuffer) Read(p []byte) (int, error) { 30 | n := copy(p, b.buf[b.lastRead:b.pos]) 31 | b.lastRead += n 32 | return n, nil 33 | } 34 | 35 | func (b *fixedBuffer) Len() int { 36 | return b.pos - b.lastRead 37 | } 38 | 39 | func (b *fixedBuffer) Cap() int { 40 | return cap(b.buf) 41 | } 42 | 43 | func (b *fixedBuffer) Reset() { 44 | b.pos = 0 45 | b.lastRead = 0 46 | b.buf = b.buf[:0] 47 | } 48 | 49 | func (b *fixedBuffer) String() string { 50 | return string(b.buf[b.lastRead:b.pos]) 51 | } 52 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/ioutils/temp_windows.go: -------------------------------------------------------------------------------- 1 | // +build windows 2 | 3 | package ioutils 4 | 5 | import ( 6 | "io/ioutil" 7 | 8 | "github.com/docker/docker/pkg/longpath" 9 | ) 10 | 11 | // TempDir is the equivalent of ioutil.TempDir, except that the result is in Windows longpath format. 12 | func TempDir(dir, prefix string) (string, error) { 13 | tempDir, err := ioutil.TempDir(dir, prefix) 14 | if err != nil { 15 | return "", err 16 | } 17 | return longpath.AddPrefix(tempDir), nil 18 | } 19 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/jsonlog/time_marshalling.go: -------------------------------------------------------------------------------- 1 | // Package jsonlog provides helper functions to parse and print time (time.Time) as JSON. 2 | package jsonlog 3 | 4 | import ( 5 | "errors" 6 | "time" 7 | ) 8 | 9 | const ( 10 | // RFC3339NanoFixed is our own version of RFC339Nano because we want one 11 | // that pads the nano seconds part with zeros to ensure 12 | // the timestamps are aligned in the logs. 13 | RFC3339NanoFixed = "2006-01-02T15:04:05.000000000Z07:00" 14 | // JSONFormat is the format used by FastMarshalJSON 15 | JSONFormat = `"` + time.RFC3339Nano + `"` 16 | ) 17 | 18 | // FastTimeMarshalJSON avoids one of the extra allocations that 19 | // time.MarshalJSON is making. 20 | func FastTimeMarshalJSON(t time.Time) (string, error) { 21 | if y := t.Year(); y < 0 || y >= 10000 { 22 | // RFC 3339 is clear that years are 4 digits exactly. 23 | // See golang.org/issue/4556#c15 for more discussion. 24 | return "", errors.New("time.MarshalJSON: year outside of range [0,9999]") 25 | } 26 | return t.Format(JSONFormat), nil 27 | } 28 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/mount/flags_unsupported.go: -------------------------------------------------------------------------------- 1 | // +build !linux,!freebsd freebsd,!cgo solaris,!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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/mount/mounter_solaris.go: -------------------------------------------------------------------------------- 1 | // +build solaris,cgo 2 | 3 | package mount 4 | 5 | import ( 6 | "golang.org/x/sys/unix" 7 | "unsafe" 8 | ) 9 | 10 | // #include 11 | // #include 12 | // #include 13 | // int Mount(const char *spec, const char *dir, int mflag, 14 | // char *fstype, char *dataptr, int datalen, char *optptr, int optlen) { 15 | // return mount(spec, dir, mflag, fstype, dataptr, datalen, optptr, optlen); 16 | // } 17 | import "C" 18 | 19 | func mount(device, target, mType string, flag uintptr, data string) error { 20 | spec := C.CString(device) 21 | dir := C.CString(target) 22 | fstype := C.CString(mType) 23 | _, err := C.Mount(spec, dir, C.int(flag), fstype, nil, 0, nil, 0) 24 | C.free(unsafe.Pointer(spec)) 25 | C.free(unsafe.Pointer(dir)) 26 | C.free(unsafe.Pointer(fstype)) 27 | return err 28 | } 29 | 30 | func unmount(target string, flag int) error { 31 | err := unix.Unmount(target, flag) 32 | return err 33 | } 34 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/mount/mounter_unsupported.go: -------------------------------------------------------------------------------- 1 | // +build !linux,!freebsd,!solaris freebsd,!cgo solaris,!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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/mount/mountinfo_freebsd.go: -------------------------------------------------------------------------------- 1 | package mount 2 | 3 | /* 4 | #include 5 | #include 6 | #include 7 | */ 8 | import "C" 9 | 10 | import ( 11 | "fmt" 12 | "reflect" 13 | "unsafe" 14 | ) 15 | 16 | // Parse /proc/self/mountinfo because comparing Dev and ino does not work from 17 | // bind mounts. 18 | func parseMountTable() ([]*Info, error) { 19 | var rawEntries *C.struct_statfs 20 | 21 | count := int(C.getmntinfo(&rawEntries, C.MNT_WAIT)) 22 | if count == 0 { 23 | return nil, fmt.Errorf("Failed to call getmntinfo") 24 | } 25 | 26 | var entries []C.struct_statfs 27 | header := (*reflect.SliceHeader)(unsafe.Pointer(&entries)) 28 | header.Cap = count 29 | header.Len = count 30 | header.Data = uintptr(unsafe.Pointer(rawEntries)) 31 | 32 | var out []*Info 33 | for _, entry := range entries { 34 | var mountinfo Info 35 | mountinfo.Mountpoint = C.GoString(&entry.f_mntonname[0]) 36 | mountinfo.Source = C.GoString(&entry.f_mntfromname[0]) 37 | mountinfo.Fstype = C.GoString(&entry.f_fstypename[0]) 38 | out = append(out, &mountinfo) 39 | } 40 | return out, nil 41 | } 42 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/mount/mountinfo_solaris.go: -------------------------------------------------------------------------------- 1 | // +build solaris,cgo 2 | 3 | package mount 4 | 5 | /* 6 | #include 7 | #include 8 | */ 9 | import "C" 10 | 11 | import ( 12 | "fmt" 13 | ) 14 | 15 | func parseMountTable() ([]*Info, error) { 16 | mnttab := C.fopen(C.CString(C.MNTTAB), C.CString("r")) 17 | if mnttab == nil { 18 | return nil, fmt.Errorf("Failed to open %s", C.MNTTAB) 19 | } 20 | 21 | var out []*Info 22 | var mp C.struct_mnttab 23 | 24 | ret := C.getmntent(mnttab, &mp) 25 | for ret == 0 { 26 | var mountinfo Info 27 | mountinfo.Mountpoint = C.GoString(mp.mnt_mountp) 28 | mountinfo.Source = C.GoString(mp.mnt_special) 29 | mountinfo.Fstype = C.GoString(mp.mnt_fstype) 30 | mountinfo.Opts = C.GoString(mp.mnt_mntopts) 31 | out = append(out, &mountinfo) 32 | ret = C.getmntent(mnttab, &mp) 33 | } 34 | 35 | C.fclose(mnttab) 36 | return out, nil 37 | } 38 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/mount/mountinfo_unsupported.go: -------------------------------------------------------------------------------- 1 | // +build !windows,!linux,!freebsd,!solaris freebsd,!cgo solaris,!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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/namesgenerator/cmd/names-generator/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | 6 | "github.com/docker/docker/pkg/namesgenerator" 7 | ) 8 | 9 | func main() { 10 | fmt.Println(namesgenerator.GetRandomName(0)) 11 | } 12 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/promise/promise.go: -------------------------------------------------------------------------------- 1 | package promise 2 | 3 | // Go is a basic promise implementation: it wraps calls a function in a goroutine, 4 | // and returns a channel which will later return the function's return value. 5 | func Go(f func() error) chan error { 6 | ch := make(chan error, 1) 7 | go func() { 8 | ch <- f() 9 | }() 10 | return ch 11 | } 12 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/system/chtimes.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | import ( 4 | "os" 5 | "time" 6 | ) 7 | 8 | // Chtimes changes the access time and modified time of a file at the given path 9 | func Chtimes(name string, atime time.Time, mtime time.Time) error { 10 | unixMinTime := time.Unix(0, 0) 11 | unixMaxTime := maxTime 12 | 13 | // If the modified time is prior to the Unix Epoch, or after the 14 | // end of Unix Time, os.Chtimes has undefined behavior 15 | // default to Unix Epoch in this case, just in case 16 | 17 | if atime.Before(unixMinTime) || atime.After(unixMaxTime) { 18 | atime = unixMinTime 19 | } 20 | 21 | if mtime.Before(unixMinTime) || mtime.After(unixMaxTime) { 22 | mtime = unixMinTime 23 | } 24 | 25 | if err := os.Chtimes(name, atime, mtime); err != nil { 26 | return err 27 | } 28 | 29 | // Take platform specific action for setting create time. 30 | if err := setCTime(name, mtime); err != nil { 31 | return err 32 | } 33 | 34 | return nil 35 | } 36 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/system/chtimes_windows.go: -------------------------------------------------------------------------------- 1 | // +build windows 2 | 3 | package system 4 | 5 | import ( 6 | "time" 7 | 8 | "golang.org/x/sys/windows" 9 | ) 10 | 11 | //setCTime will set the create time on a file. On Windows, this requires 12 | //calling SetFileTime and explicitly including the create time. 13 | func setCTime(path string, ctime time.Time) error { 14 | ctimespec := windows.NsecToTimespec(ctime.UnixNano()) 15 | pathp, e := windows.UTF16PtrFromString(path) 16 | if e != nil { 17 | return e 18 | } 19 | h, e := windows.CreateFile(pathp, 20 | windows.FILE_WRITE_ATTRIBUTES, windows.FILE_SHARE_WRITE, nil, 21 | windows.OPEN_EXISTING, windows.FILE_FLAG_BACKUP_SEMANTICS, 0) 22 | if e != nil { 23 | return e 24 | } 25 | defer windows.Close(h) 26 | c := windows.NsecToFiletime(windows.TimespecToNsec(ctimespec)) 27 | return windows.SetFileTime(h, &c, nil, nil) 28 | } 29 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | 21 | // ProcessExitCode process the specified error and returns the exit status code 22 | // if the error was of type exec.ExitError, returns nothing otherwise. 23 | func ProcessExitCode(err error) (exitCode int) { 24 | if err != nil { 25 | var exiterr error 26 | if exitCode, exiterr = GetExitCode(err); exiterr != nil { 27 | // TODO: Fix this so we check the error's text. 28 | // we've failed to retrieve exit code, so we set it to 127 29 | exitCode = 127 30 | } 31 | } 32 | return 33 | } 34 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | // Note: This feature is in development (06/17) and enabled through an 7 | // environment variable. At a future time, it will be enabled based 8 | // on build number. @jhowardmsft 9 | var lcowSupported = false 10 | 11 | func init() { 12 | // LCOW initialization 13 | if os.Getenv("LCOW_SUPPORTED") != "" { 14 | lcowSupported = true 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/system/meminfo_unsupported.go: -------------------------------------------------------------------------------- 1 | // +build !linux,!windows,!solaris 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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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(((minor & 0xfff00) << 12) | ((major & 0xfff) << 8) | (minor & 0xff)) 22 | } 23 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/system/mknod_windows.go: -------------------------------------------------------------------------------- 1 | // +build windows 2 | 3 | package system 4 | 5 | // Mknod is not implemented on Windows. 6 | func Mknod(path string, mode uint32, dev int) error { 7 | return ErrNotSupportedPlatform 8 | } 9 | 10 | // Mkdev is not implemented on Windows. 11 | func Mkdev(major int64, minor int64) uint32 { 12 | panic("Mkdev not implemented on Windows.") 13 | } 14 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/system/path.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | import "runtime" 4 | 5 | const defaultUnixPathEnv = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin" 6 | 7 | // DefaultPathEnv is unix style list of directories to search for 8 | // executables. Each directory is separated from the next by a colon 9 | // ':' character . 10 | func DefaultPathEnv(platform string) string { 11 | if runtime.GOOS == "windows" { 12 | if platform != runtime.GOOS && LCOWSupported() { 13 | return defaultUnixPathEnv 14 | } 15 | // Deliberately empty on Windows containers on Windows as the default path will be set by 16 | // the container. Docker has no context of what the default path should be. 17 | return "" 18 | } 19 | return defaultUnixPathEnv 20 | 21 | } 22 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/system/path_unix.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | 3 | package system 4 | 5 | // CheckSystemDriveAndRemoveDriveLetter verifies that a path, if it includes a drive letter, 6 | // is the system drive. This is a no-op on Linux. 7 | func CheckSystemDriveAndRemoveDriveLetter(path string) (string, error) { 8 | return path, nil 9 | } 10 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/system/process_unix.go: -------------------------------------------------------------------------------- 1 | // +build linux freebsd solaris 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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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: uint32(s.Mode), 9 | uid: s.Uid, 10 | gid: s.Gid, 11 | rdev: uint64(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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/system/umask_windows.go: -------------------------------------------------------------------------------- 1 | // +build windows 2 | 3 | package system 4 | 5 | // Umask is not supported on the windows platform. 6 | func Umask(newmask int) (oldmask int, err error) { 7 | // should not be called on cli code path 8 | return 0, ErrNotSupportedPlatform 9 | } 10 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/system/xattrs_linux.go: -------------------------------------------------------------------------------- 1 | package system 2 | 3 | import "golang.org/x/sys/unix" 4 | 5 | // Lgetxattr retrieves the value of the extended attribute identified by attr 6 | // and associated with the given path in the file system. 7 | // It will returns a nil slice and nil error if the xattr is not set. 8 | func Lgetxattr(path string, attr string) ([]byte, error) { 9 | dest := make([]byte, 128) 10 | sz, errno := unix.Lgetxattr(path, attr, dest) 11 | if errno == unix.ENODATA { 12 | return nil, nil 13 | } 14 | if errno == unix.ERANGE { 15 | dest = make([]byte, sz) 16 | sz, errno = unix.Lgetxattr(path, attr, dest) 17 | } 18 | if errno != nil { 19 | return nil, errno 20 | } 21 | 22 | return dest[:sz], nil 23 | } 24 | 25 | // Lsetxattr sets the value of the extended attribute identified by attr 26 | // and associated with the given path in the file system. 27 | func Lsetxattr(path string, attr string, data []byte, flags int) error { 28 | return unix.Lsetxattr(path, attr, data, flags) 29 | } 30 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/term/tc.go: -------------------------------------------------------------------------------- 1 | // +build !windows 2 | // +build !solaris !cgo 3 | 4 | package term 5 | 6 | import ( 7 | "syscall" 8 | "unsafe" 9 | 10 | "golang.org/x/sys/unix" 11 | ) 12 | 13 | func tcget(fd uintptr, p *Termios) syscall.Errno { 14 | _, _, err := unix.Syscall(unix.SYS_IOCTL, fd, uintptr(getTermios), uintptr(unsafe.Pointer(p))) 15 | return err 16 | } 17 | 18 | func tcset(fd uintptr, p *Termios) syscall.Errno { 19 | _, _, err := unix.Syscall(unix.SYS_IOCTL, fd, setTermios, uintptr(unsafe.Pointer(p))) 20 | return err 21 | } 22 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/term/windows/console.go: -------------------------------------------------------------------------------- 1 | // +build windows 2 | 3 | package windowsconsole 4 | 5 | import ( 6 | "os" 7 | 8 | "github.com/Azure/go-ansiterm/winterm" 9 | ) 10 | 11 | // GetHandleInfo returns file descriptor and bool indicating whether the file is a console. 12 | func GetHandleInfo(in interface{}) (uintptr, bool) { 13 | switch t := in.(type) { 14 | case *ansiReader: 15 | return t.Fd(), true 16 | case *ansiWriter: 17 | return t.Fd(), true 18 | } 19 | 20 | var inFd uintptr 21 | var isTerminal bool 22 | 23 | if file, ok := in.(*os.File); ok { 24 | inFd = file.Fd() 25 | isTerminal = IsConsole(inFd) 26 | } 27 | return inFd, isTerminal 28 | } 29 | 30 | // IsConsole returns true if the given file descriptor is a Windows Console. 31 | // The code assumes that GetConsoleMode will return an error for file descriptors that are not a console. 32 | func IsConsole(fd uintptr) bool { 33 | _, e := winterm.GetConsoleMode(fd) 34 | return e == nil 35 | } 36 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/term/windows/windows.go: -------------------------------------------------------------------------------- 1 | // These files implement ANSI-aware input and output streams for use by the Docker Windows client. 2 | // When asked for the set of standard streams (e.g., stdin, stdout, stderr), the code will create 3 | // and return pseudo-streams that convert ANSI sequences to / from Windows Console API calls. 4 | 5 | package windowsconsole 6 | 7 | import ( 8 | "io/ioutil" 9 | "os" 10 | "sync" 11 | 12 | ansiterm "github.com/Azure/go-ansiterm" 13 | "github.com/sirupsen/logrus" 14 | ) 15 | 16 | var logger *logrus.Logger 17 | var initOnce sync.Once 18 | 19 | func initLogger() { 20 | initOnce.Do(func() { 21 | logFile := ioutil.Discard 22 | 23 | if isDebugEnv := os.Getenv(ansiterm.LogEnv); isDebugEnv == "1" { 24 | logFile, _ = os.Create("ansiReaderWriter.log") 25 | } 26 | 27 | logger = &logrus.Logger{ 28 | Out: logFile, 29 | Formatter: new(logrus.TextFormatter), 30 | Level: logrus.DebugLevel, 31 | } 32 | }) 33 | } 34 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/term/winsize.go: -------------------------------------------------------------------------------- 1 | // +build !solaris,!windows 2 | 3 | package term 4 | 5 | import ( 6 | "unsafe" 7 | 8 | "golang.org/x/sys/unix" 9 | ) 10 | 11 | // GetWinsize returns the window size based on the specified file descriptor. 12 | func GetWinsize(fd uintptr) (*Winsize, error) { 13 | ws := &Winsize{} 14 | _, _, err := unix.Syscall(unix.SYS_IOCTL, fd, uintptr(unix.TIOCGWINSZ), uintptr(unsafe.Pointer(ws))) 15 | // Skipp errno = 0 16 | if err == 0 { 17 | return ws, nil 18 | } 19 | return ws, err 20 | } 21 | 22 | // SetWinsize tries to set the specified window size for the specified file descriptor. 23 | func SetWinsize(fd uintptr, ws *Winsize) error { 24 | _, _, err := unix.Syscall(unix.SYS_IOCTL, fd, uintptr(unix.TIOCSWINSZ), uintptr(unsafe.Pointer(ws))) 25 | // Skipp errno = 0 26 | if err == 0 { 27 | return nil 28 | } 29 | return err 30 | } 31 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/pkg/term/winsize_solaris_cgo.go: -------------------------------------------------------------------------------- 1 | // +build solaris,cgo 2 | 3 | package term 4 | 5 | import ( 6 | "unsafe" 7 | 8 | "golang.org/x/sys/unix" 9 | ) 10 | 11 | /* 12 | #include 13 | #include 14 | #include 15 | 16 | // Small wrapper to get rid of variadic args of ioctl() 17 | int my_ioctl(int fd, int cmd, struct winsize *ws) { 18 | return ioctl(fd, cmd, ws); 19 | } 20 | */ 21 | import "C" 22 | 23 | // GetWinsize returns the window size based on the specified file descriptor. 24 | func GetWinsize(fd uintptr) (*Winsize, error) { 25 | ws := &Winsize{} 26 | ret, err := C.my_ioctl(C.int(fd), C.int(unix.TIOCGWINSZ), (*C.struct_winsize)(unsafe.Pointer(ws))) 27 | // Skip retval = 0 28 | if ret == 0 { 29 | return ws, nil 30 | } 31 | return ws, err 32 | } 33 | 34 | // SetWinsize tries to set the specified window size for the specified file descriptor. 35 | func SetWinsize(fd uintptr, ws *Winsize) error { 36 | ret, err := C.my_ioctl(C.int(fd), C.int(unix.TIOCSWINSZ), (*C.struct_winsize)(unsafe.Pointer(ws))) 37 | // Skip retval = 0 38 | if ret == 0 { 39 | return nil 40 | } 41 | return err 42 | } 43 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/archive/tar/stat_atim.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build linux dragonfly openbsd solaris 6 | 7 | package tar 8 | 9 | import ( 10 | "syscall" 11 | "time" 12 | ) 13 | 14 | func statAtime(st *syscall.Stat_t) time.Time { 15 | return time.Unix(st.Atim.Unix()) 16 | } 17 | 18 | func statCtime(st *syscall.Stat_t) time.Time { 19 | return time.Unix(st.Ctim.Unix()) 20 | } 21 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/archive/tar/stat_atimespec.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 freebsd netbsd 6 | 7 | package tar 8 | 9 | import ( 10 | "syscall" 11 | "time" 12 | ) 13 | 14 | func statAtime(st *syscall.Stat_t) time.Time { 15 | return time.Unix(st.Atimespec.Unix()) 16 | } 17 | 18 | func statCtime(st *syscall.Stat_t) time.Time { 19 | return time.Unix(st.Ctimespec.Unix()) 20 | } 21 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/archive/tar/stat_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build linux darwin dragonfly freebsd openbsd netbsd solaris 6 | 7 | package tar 8 | 9 | import ( 10 | "os" 11 | "syscall" 12 | ) 13 | 14 | func init() { 15 | sysStat = statUnix 16 | } 17 | 18 | func statUnix(fi os.FileInfo, h *Header) error { 19 | sys, ok := fi.Sys().(*syscall.Stat_t) 20 | if !ok { 21 | return nil 22 | } 23 | h.Uid = int(sys.Uid) 24 | h.Gid = int(sys.Gid) 25 | // TODO(bradfitz): populate username & group. os/user 26 | // doesn't cache LookupId lookups, and lacks group 27 | // lookup functions. 28 | h.AccessTime = statAtime(sys) 29 | h.ChangeTime = statCtime(sys) 30 | // TODO(bradfitz): major/minor device numbers? 31 | return nil 32 | } 33 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/BurntSushi/toml/COPYING: -------------------------------------------------------------------------------- 1 | DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE 2 | Version 2, December 2004 3 | 4 | Copyright (C) 2004 Sam Hocevar 5 | 6 | Everyone is permitted to copy and distribute verbatim or modified 7 | copies of this license document, and changing it is allowed as long 8 | as the name is changed. 9 | 10 | DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE 11 | TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 12 | 13 | 0. You just DO WHAT THE FUCK YOU WANT TO. 14 | 15 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/Graylog2/go-gelf/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright 2012 SocialCode 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining 4 | a copy of this software and associated documentation files (the 5 | "Software"), to deal in the Software without restriction, including 6 | without limitation the rights to use, copy, modify, merge, publish, 7 | distribute, sublicense, and/or sell copies of the Software, and to 8 | permit persons to whom the Software is furnished to do so, subject to 9 | the following conditions: 10 | 11 | The above copyright notice and this permission notice shall be 12 | included in all copies or substantial portions of the Software. 13 | 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 17 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 18 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 19 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 20 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | 22 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/Microsoft/hcsshim/LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2015 Microsoft 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/Nvveen/Gotty/README: -------------------------------------------------------------------------------- 1 | Gotty is a library written in Go that determines and reads termcap database 2 | files to produce an interface for interacting with the capabilities of a 3 | terminal. 4 | See the godoc documentation or the source code for more information about 5 | function usage. 6 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/Nvveen/Gotty/types.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 Neal van Veen. All rights reserved. 2 | // Usage of this source code is governed by a BSD-style license that can be 3 | // found in the LICENSE file. 4 | 5 | package gotty 6 | 7 | type TermInfo struct { 8 | boolAttributes map[string]bool 9 | numAttributes map[string]int16 10 | strAttributes map[string]string 11 | // The various names of the TermInfo file. 12 | Names []string 13 | } 14 | 15 | type stacker interface { 16 | } 17 | type stack []stacker 18 | 19 | type parser struct { 20 | st stack 21 | parameters []stacker 22 | dynamicVar map[byte]stacker 23 | } 24 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/armon/go-metrics/LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2013 Armon Dadgar 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 6 | this software and associated documentation files (the "Software"), to deal in 7 | the Software without restriction, including without limitation the rights to 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 9 | the Software, and to permit persons to whom the Software is furnished to do so, 10 | subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/armon/go-radix/LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2014 Armon Dadgar 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 6 | this software and associated documentation files (the "Software"), to deal in 7 | the Software without restriction, including without limitation the rights to 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 9 | the Software, and to permit persons to whom the Software is furnished to do so, 10 | subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/aws/aws-sdk-go/NOTICE.txt: -------------------------------------------------------------------------------- 1 | AWS SDK for Go 2 | Copyright 2015 Amazon.com, Inc. or its affiliates. All Rights Reserved. 3 | Copyright 2014-2015 Stripe, Inc. 4 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/beorn7/perks/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (C) 2013 Blake Mizerany 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining 4 | a copy of this software and associated documentation files (the 5 | "Software"), to deal in the Software without restriction, including 6 | without limitation the rights to use, copy, modify, merge, publish, 7 | distribute, sublicense, and/or sell copies of the Software, and to 8 | permit persons to whom the Software is furnished to do so, subject to 9 | the following conditions: 10 | 11 | The above copyright notice and this permission notice shall be 12 | included in all copies or substantial portions of the Software. 13 | 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 17 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 18 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 19 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 20 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/boltdb/bolt/LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2013 Ben Johnson 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 6 | this software and associated documentation files (the "Software"), to deal in 7 | the Software without restriction, including without limitation the rights to 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 9 | the Software, and to permit persons to whom the Software is furnished to do so, 10 | subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/bsphere/le_go/LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2017 Gal Ben-Haim 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/cloudflare/cfssl/info/info.go: -------------------------------------------------------------------------------- 1 | // Package info contains the definitions for the info endpoint 2 | package info 3 | 4 | // Req is the request struct for an info API request. 5 | type Req struct { 6 | Label string `json:"label"` 7 | Profile string `json:"profile"` 8 | } 9 | 10 | // Resp is the response for an Info API request. 11 | type Resp struct { 12 | Certificate string `json:"certificate"` 13 | Usage []string `json:"usages"` 14 | ExpiryString string `json:"expiry"` 15 | } 16 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/cloudflare/cfssl/ocsp/config/config.go: -------------------------------------------------------------------------------- 1 | // Package config in the ocsp directory provides configuration data for an OCSP 2 | // signer. 3 | package config 4 | 5 | import "time" 6 | 7 | // Config contains configuration information required to set up an OCSP signer. 8 | type Config struct { 9 | CACertFile string 10 | ResponderCertFile string 11 | KeyFile string 12 | Interval time.Duration 13 | } 14 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/containerd/containerd/NOTICE: -------------------------------------------------------------------------------- 1 | Docker 2 | Copyright 2012-2015 Docker, Inc. 3 | 4 | This product includes software developed at Docker, Inc. (https://www.docker.com). 5 | 6 | The following is courtesy of our legal counsel: 7 | 8 | 9 | Use and transfer of Docker may be subject to certain restrictions by the 10 | United States and other governments. 11 | It is your responsibility to ensure that your use and/or transfer does not 12 | violate applicable laws. 13 | 14 | For more information, please see https://www.bis.doc.gov 15 | 16 | See also https://www.apache.org/dev/crypto.html and/or seek legal counsel. 17 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/coreos/etcd/NOTICE: -------------------------------------------------------------------------------- 1 | CoreOS Project 2 | Copyright 2014 CoreOS, Inc 3 | 4 | This product includes software developed at CoreOS, Inc. 5 | (http://www.coreos.com/). 6 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/coreos/pkg/NOTICE: -------------------------------------------------------------------------------- 1 | CoreOS Project 2 | Copyright 2014 CoreOS, Inc 3 | 4 | This product includes software developed at CoreOS, Inc. 5 | (http://www.coreos.com/). 6 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/davecgh/go-spew/LICENSE: -------------------------------------------------------------------------------- 1 | ISC License 2 | 3 | Copyright (c) 2012-2016 Dave Collins 4 | 5 | Permission to use, copy, modify, and distribute this software for any 6 | purpose with or without fee is hereby granted, provided that the above 7 | copyright notice and this permission notice appear in all copies. 8 | 9 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10 | WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11 | MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12 | ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 | OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/docker/go-events/errors.go: -------------------------------------------------------------------------------- 1 | package events 2 | 3 | import "fmt" 4 | 5 | var ( 6 | // ErrSinkClosed is returned if a write is issued to a sink that has been 7 | // closed. If encountered, the error should be considered terminal and 8 | // retries will not be successful. 9 | ErrSinkClosed = fmt.Errorf("events: sink closed") 10 | ) 11 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/docker/go-events/event.go: -------------------------------------------------------------------------------- 1 | package events 2 | 3 | // Event marks items that can be sent as events. 4 | type Event interface{} 5 | 6 | // Sink accepts and sends events. 7 | type Sink interface { 8 | // Write an event to the Sink. If no error is returned, the caller will 9 | // assume that all events have been committed to the sink. If an error is 10 | // received, the caller may retry sending the event. 11 | Write(event Event) error 12 | 13 | // Close the sink, possibly waiting for pending events to flush. 14 | Close() error 15 | } 16 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/docker/go-metrics/NOTICE: -------------------------------------------------------------------------------- 1 | Docker 2 | Copyright 2012-2015 Docker, Inc. 3 | 4 | This product includes software developed at Docker, Inc. (https://www.docker.com). 5 | 6 | The following is courtesy of our legal counsel: 7 | 8 | 9 | Use and transfer of Docker may be subject to certain restrictions by the 10 | United States and other governments. 11 | It is your responsibility to ensure that your use and/or transfer does not 12 | violate applicable laws. 13 | 14 | For more information, please see https://www.bis.doc.gov 15 | 16 | See also https://www.apache.org/dev/crypto.html and/or seek legal counsel. 17 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/docker/libkv/libkv.go: -------------------------------------------------------------------------------- 1 | package libkv 2 | 3 | import ( 4 | "fmt" 5 | "sort" 6 | "strings" 7 | 8 | "github.com/docker/libkv/store" 9 | ) 10 | 11 | // Initialize creates a new Store object, initializing the client 12 | type Initialize func(addrs []string, options *store.Config) (store.Store, error) 13 | 14 | var ( 15 | // Backend initializers 16 | initializers = make(map[store.Backend]Initialize) 17 | 18 | supportedBackend = func() string { 19 | keys := make([]string, 0, len(initializers)) 20 | for k := range initializers { 21 | keys = append(keys, string(k)) 22 | } 23 | sort.Strings(keys) 24 | return strings.Join(keys, ", ") 25 | }() 26 | ) 27 | 28 | // NewStore creates an instance of store 29 | func NewStore(backend store.Backend, addrs []string, options *store.Config) (store.Store, error) { 30 | if init, exists := initializers[backend]; exists { 31 | return init(addrs, options) 32 | } 33 | 34 | return nil, fmt.Errorf("%s %s", store.ErrBackendNotSupported.Error(), supportedBackend) 35 | } 36 | 37 | // AddStore adds a new store backend to libkv 38 | func AddStore(store store.Backend, init Initialize) { 39 | initializers[store] = init 40 | } 41 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/docker/swarmkit/api/README.md: -------------------------------------------------------------------------------- 1 | ### Notice 2 | 3 | Do not change .pb.go files directly. You need to change the corresponding .proto files and run the following command to regenerate the .pb.go files. 4 | ``` 5 | $ make generate 6 | ``` 7 | 8 | Click [here](https://github.com/google/protobuf) for more information about protobuf. 9 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/docker/swarmkit/api/gen.go: -------------------------------------------------------------------------------- 1 | package api 2 | 3 | //go:generate protoc -I.:../protobuf:../vendor:../vendor/github.com/gogo/protobuf --gogoswarm_out=plugins=grpc+deepcopy+storeobject+raftproxy+authenticatedwrapper,import_path=github.com/docker/swarmkit/api,Mgogoproto/gogo.proto=github.com/gogo/protobuf/gogoproto,Mgoogle/protobuf/descriptor.proto=github.com/gogo/protobuf/protoc-gen-gogo/descriptor,Mplugin/plugin.proto=github.com/docker/swarmkit/protobuf/plugin,Mgoogle/protobuf/duration.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/timestamp.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/any.proto=github.com/gogo/protobuf/types:. types.proto specs.proto objects.proto control.proto dispatcher.proto ca.proto snapshot.proto raft.proto health.proto resource.proto logbroker.proto watch.proto 4 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/docker/swarmkit/api/health.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | // See: https://github.com/grpc/grpc-go/blob/master/health/grpc_health_v1/health.proto 4 | // 5 | // We use the same health check service proto description defined in the gRPC documentation, 6 | // including the authorization check. This requires our own implementation of the health 7 | // package located in `manager/health`. 8 | // 9 | // For more infos, refer to: 10 | // https://github.com/grpc/grpc/blob/master/doc/health-checking.md 11 | 12 | package docker.swarmkit.v1; 13 | 14 | import "gogoproto/gogo.proto"; 15 | import "plugin/plugin.proto"; 16 | 17 | service Health { 18 | rpc Check(HealthCheckRequest) returns (HealthCheckResponse) { 19 | option (docker.protobuf.plugin.tls_authorization) = { roles: "swarm-manager" }; 20 | }; 21 | } 22 | 23 | message HealthCheckRequest { 24 | string service = 1; 25 | } 26 | 27 | message HealthCheckResponse { 28 | enum ServingStatus { 29 | UNKNOWN = 0; 30 | SERVING = 1; 31 | NOT_SERVING = 2; 32 | } 33 | ServingStatus status = 1; 34 | } 35 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/docker/swarmkit/api/resource.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package docker.swarmkit.v1; 4 | 5 | import "types.proto"; 6 | import "gogoproto/gogo.proto"; 7 | import "plugin/plugin.proto"; 8 | 9 | // Allocator is the API provided by a manager group for agents to control the allocation of certain entities. 10 | // 11 | // API methods on this service are used only by agent nodes. 12 | service ResourceAllocator { 13 | rpc AttachNetwork(AttachNetworkRequest) returns (AttachNetworkResponse) { 14 | option (docker.protobuf.plugin.tls_authorization) = { roles: "swarm-worker" roles: "swarm-manager" }; 15 | }; 16 | rpc DetachNetwork(DetachNetworkRequest) returns (DetachNetworkResponse) { 17 | option (docker.protobuf.plugin.tls_authorization) = { roles: "swarm-worker" roles: "swarm-manager" }; 18 | }; 19 | } 20 | 21 | message AttachNetworkRequest { 22 | NetworkAttachmentConfig config = 1; 23 | string container_id = 2; 24 | } 25 | 26 | message AttachNetworkResponse { 27 | string attachment_id = 1; 28 | } 29 | 30 | message DetachNetworkRequest { 31 | string attachment_id = 1; 32 | } 33 | 34 | message DetachNetworkResponse {} 35 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/docker/swarmkit/api/validation/secrets.go: -------------------------------------------------------------------------------- 1 | package validation 2 | 3 | import "fmt" 4 | 5 | // MaxSecretSize is the maximum byte length of the `Secret.Spec.Data` field. 6 | const MaxSecretSize = 500 * 1024 // 500KB 7 | 8 | // ValidateSecretPayload validates the secret payload size 9 | func ValidateSecretPayload(data []byte) error { 10 | if len(data) >= MaxSecretSize || len(data) < 1 { 11 | return fmt.Errorf("secret data must be larger than 0 and less than %d bytes", MaxSecretSize) 12 | } 13 | return nil 14 | } 15 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/docker/swarmkit/identity/doc.go: -------------------------------------------------------------------------------- 1 | // Package identity provides functionality for generating and managing 2 | // identifiers within a swarm. This includes entity identification, such as for 3 | // Services, Tasks and Networks but also cryptographically-secure Node identities. 4 | // 5 | // Random Identifiers 6 | // 7 | // Identifiers provided by this package are cryptographically-strong, random 8 | // 128 bit numbers encoded in Base36. This method is preferred over UUID4 since 9 | // it requires less storage and leverages the full 128 bits of entropy. 10 | // 11 | // Generating an identifier is simple. Simply call the `NewID` function: 12 | // 13 | // id := NewID() 14 | // 15 | // If an error occurs while generating the ID, it will panic. 16 | package identity 17 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/docker/swarmkit/ioutils/ioutils.go: -------------------------------------------------------------------------------- 1 | package ioutils 2 | 3 | import ( 4 | "io" 5 | "io/ioutil" 6 | "os" 7 | "path/filepath" 8 | ) 9 | 10 | // todo: split docker/pkg/ioutils into a separate repo 11 | 12 | // AtomicWriteFile atomically writes data to a file specified by filename. 13 | func AtomicWriteFile(filename string, data []byte, perm os.FileMode) error { 14 | f, err := ioutil.TempFile(filepath.Dir(filename), ".tmp-"+filepath.Base(filename)) 15 | if err != nil { 16 | return err 17 | } 18 | err = os.Chmod(f.Name(), perm) 19 | if err != nil { 20 | f.Close() 21 | return err 22 | } 23 | n, err := f.Write(data) 24 | if err == nil && n < len(data) { 25 | f.Close() 26 | return io.ErrShortWrite 27 | } 28 | if err != nil { 29 | f.Close() 30 | return err 31 | } 32 | if err := f.Sync(); err != nil { 33 | f.Close() 34 | return err 35 | } 36 | if err := f.Close(); err != nil { 37 | return err 38 | } 39 | return os.Rename(f.Name(), filename) 40 | } 41 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/docker/swarmkit/log/grpc.go: -------------------------------------------------------------------------------- 1 | package log 2 | 3 | import ( 4 | "golang.org/x/net/context" 5 | "google.golang.org/grpc/grpclog" 6 | ) 7 | 8 | func init() { 9 | ctx := WithModule(context.Background(), "grpc") 10 | 11 | // completely replace the grpc logger with the logrus logger. 12 | grpclog.SetLogger(G(ctx)) 13 | } 14 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/docker/swarmkit/manager/raftselector/raftselector.go: -------------------------------------------------------------------------------- 1 | package raftselector 2 | 3 | import ( 4 | "errors" 5 | 6 | "golang.org/x/net/context" 7 | 8 | "google.golang.org/grpc" 9 | ) 10 | 11 | // ConnProvider is basic interface for connecting API package(raft proxy in particular) 12 | // to manager/state/raft package without import cycles. It provides only one 13 | // method for obtaining connection to leader. 14 | type ConnProvider interface { 15 | LeaderConn(ctx context.Context) (*grpc.ClientConn, error) 16 | } 17 | 18 | // ErrIsLeader is returned from LeaderConn method when current machine is leader. 19 | // It's just shim between packages to avoid import cycles. 20 | var ErrIsLeader = errors.New("current node is leader") 21 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/docker/swarmkit/manager/state/store/combinators.go: -------------------------------------------------------------------------------- 1 | package store 2 | 3 | type orCombinator struct { 4 | bys []By 5 | } 6 | 7 | func (b orCombinator) isBy() { 8 | } 9 | 10 | // Or returns a combinator that applies OR logic on all the supplied By 11 | // arguments. 12 | func Or(bys ...By) By { 13 | return orCombinator{bys: bys} 14 | } 15 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/docker/swarmkit/protobuf/plugin/gen.go: -------------------------------------------------------------------------------- 1 | package plugin 2 | 3 | //go:generate protoc -I.:/usr/local --gogoswarm_out=import_path=github.com/docker/swarmkit/protobuf/plugin,Mgoogle/protobuf/descriptor.proto=github.com/gogo/protobuf/protoc-gen-gogo/descriptor:. plugin.proto 4 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/docker/swarmkit/protobuf/plugin/helpers.go: -------------------------------------------------------------------------------- 1 | package plugin 2 | 3 | import ( 4 | "github.com/gogo/protobuf/proto" 5 | google_protobuf "github.com/gogo/protobuf/protoc-gen-gogo/descriptor" 6 | ) 7 | 8 | // DeepcopyEnabled returns true if deepcopy is enabled for the descriptor. 9 | func DeepcopyEnabled(options *google_protobuf.MessageOptions) bool { 10 | return proto.GetBoolExtension(options, E_Deepcopy, true) 11 | } 12 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/google/certificate-transparency/go/README.md: -------------------------------------------------------------------------------- 1 | This is the really early beginnings of a certificate transparency log 2 | client written in Go, along with a log scanner tool. 3 | 4 | You'll need go v1.1 or higher to compile. 5 | 6 | # Installation 7 | 8 | This go code must be imported into your go workspace before you can 9 | use it, which can be done with: 10 | 11 | go get github.com/google/certificate-transparency/go/client 12 | go get github.com/google/certificate-transparency/go/scanner 13 | etc. 14 | 15 | # Building the binaries 16 | 17 | To compile the log scanner run: 18 | 19 | go build github.com/google/certificate-transparency/go/scanner/main/scanner.go 20 | 21 | # Contributing 22 | 23 | When sending pull requests, please ensure that everything's been run 24 | through ```gofmt``` beforehand so we can keep everything nice and 25 | tidy. 26 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/google/certificate-transparency/go/x509/root.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package x509 6 | 7 | import "sync" 8 | 9 | var ( 10 | once sync.Once 11 | systemRoots *CertPool 12 | ) 13 | 14 | func systemRootsPool() *CertPool { 15 | once.Do(initSystemRoots) 16 | return systemRoots 17 | } 18 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/google/certificate-transparency/go/x509/root_plan9.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build plan9 6 | 7 | package x509 8 | 9 | import "io/ioutil" 10 | 11 | // Possible certificate files; stop after finding one. 12 | var certFiles = []string{ 13 | "/sys/lib/tls/ca.pem", 14 | } 15 | 16 | func (c *Certificate) systemVerify(opts *VerifyOptions) (chains [][]*Certificate, err error) { 17 | return nil, nil 18 | } 19 | 20 | func initSystemRoots() { 21 | roots := NewCertPool() 22 | for _, file := range certFiles { 23 | data, err := ioutil.ReadFile(file) 24 | if err == nil { 25 | roots.AppendCertsFromPEM(data) 26 | systemRoots = roots 27 | return 28 | } 29 | } 30 | 31 | // All of the files failed to load. systemRoots will be nil which will 32 | // trigger a specific error at verification time. 33 | } 34 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/google/certificate-transparency/go/x509/root_stub.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 | // +build darwin,!cgo 6 | 7 | package x509 8 | 9 | func (c *Certificate) systemVerify(opts *VerifyOptions) (chains [][]*Certificate, err error) { 10 | return nil, nil 11 | } 12 | 13 | func initSystemRoots() { 14 | } 15 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/grpc-ecosystem/go-grpc-prometheus/util.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 Michal Witkowski. All Rights Reserved. 2 | // See LICENSE for licensing terms. 3 | 4 | package grpc_prometheus 5 | 6 | import ( 7 | "strings" 8 | 9 | "google.golang.org/grpc/codes" 10 | ) 11 | 12 | var ( 13 | allCodes = []codes.Code{ 14 | codes.OK, codes.Canceled, codes.Unknown, codes.InvalidArgument, codes.DeadlineExceeded, codes.NotFound, 15 | codes.AlreadyExists, codes.PermissionDenied, codes.Unauthenticated, codes.ResourceExhausted, 16 | codes.FailedPrecondition, codes.Aborted, codes.OutOfRange, codes.Unimplemented, codes.Internal, 17 | codes.Unavailable, codes.DataLoss, 18 | } 19 | ) 20 | 21 | func splitMethodName(fullMethodName string) (string, string) { 22 | fullMethodName = strings.TrimPrefix(fullMethodName, "/") // remove leading slash 23 | if i := strings.Index(fullMethodName, "/"); i >= 0 { 24 | return fullMethodName[:i], fullMethodName[i+1:] 25 | } 26 | return "unknown", "unknown" 27 | } 28 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/hashicorp/go-immutable-radix/edges.go: -------------------------------------------------------------------------------- 1 | package iradix 2 | 3 | import "sort" 4 | 5 | type edges []edge 6 | 7 | func (e edges) Len() int { 8 | return len(e) 9 | } 10 | 11 | func (e edges) Less(i, j int) bool { 12 | return e[i].label < e[j].label 13 | } 14 | 15 | func (e edges) Swap(i, j int) { 16 | e[i], e[j] = e[j], e[i] 17 | } 18 | 19 | func (e edges) Sort() { 20 | sort.Sort(e) 21 | } 22 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/inconshreveable/mousetrap/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright 2014 Alan Shreve 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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/kr/pty/License: -------------------------------------------------------------------------------- 1 | Copyright (c) 2011 Keith Rarick 2 | 3 | Permission is hereby granted, free of charge, to any person 4 | obtaining a copy of this software and associated 5 | documentation files (the "Software"), to deal in the 6 | Software without restriction, including without limitation 7 | the rights to use, copy, modify, merge, publish, distribute, 8 | sublicense, and/or sell copies of the Software, and to 9 | permit persons to whom the Software is furnished to do so, 10 | subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall 13 | be included in all copies or substantial portions of the 14 | Software. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY 17 | KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE 18 | WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 19 | PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS 20 | OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 21 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 22 | OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 23 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 24 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/matttproud/golang_protobuf_extensions/NOTICE: -------------------------------------------------------------------------------- 1 | Copyright 2012 Matt T. Proud (matt.proud@gmail.com) 2 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/matttproud/golang_protobuf_extensions/pbutil/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2013 Matt T. Proud 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | // Package pbutil provides record length-delimited Protocol Buffer streaming. 16 | package pbutil 17 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/opencontainers/image-spec/specs-go/v1/layout.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Linux Foundation 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | package v1 16 | 17 | const ( 18 | // ImageLayoutFile is the file name of oci image layout file 19 | ImageLayoutFile = "oci-layout" 20 | // ImageLayoutVersion is the version of ImageLayout 21 | ImageLayoutVersion = "1.0.0" 22 | ) 23 | 24 | // ImageLayout is the structure in the "oci-layout" file, found in the root 25 | // of an OCI Image-layout directory. 26 | type ImageLayout struct { 27 | Version string `json:"imageLayoutVersion"` 28 | } 29 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/opencontainers/image-spec/specs-go/versioned.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Linux Foundation 2 | // 3 | // Licensed under the Apache License, Version 2.0 (the "License"); 4 | // you may not use this file except in compliance with the License. 5 | // You may obtain a copy of the License at 6 | // 7 | // http://www.apache.org/licenses/LICENSE-2.0 8 | // 9 | // Unless required by applicable law or agreed to in writing, software 10 | // distributed under the License is distributed on an "AS IS" BASIS, 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | // See the License for the specific language governing permissions and 13 | // limitations under the License. 14 | 15 | package specs 16 | 17 | // Versioned provides a struct with the manifest schemaVersion and mediaType. 18 | // Incoming content with unknown schema version can be decoded against this 19 | // struct to check the version. 20 | type Versioned struct { 21 | // SchemaVersion is the image manifest schema that this image follows 22 | SchemaVersion int `json:"schemaVersion"` 23 | } 24 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/opencontainers/runc/libcontainer/system/syscall_linux_386.go: -------------------------------------------------------------------------------- 1 | // +build linux,386 2 | 3 | package system 4 | 5 | import ( 6 | "syscall" 7 | ) 8 | 9 | // Setuid sets the uid of the calling thread to the specified uid. 10 | func Setuid(uid int) (err error) { 11 | _, _, e1 := syscall.RawSyscall(syscall.SYS_SETUID32, uintptr(uid), 0, 0) 12 | if e1 != 0 { 13 | err = e1 14 | } 15 | return 16 | } 17 | 18 | // Setgid sets the gid of the calling thread to the specified gid. 19 | func Setgid(gid int) (err error) { 20 | _, _, e1 := syscall.RawSyscall(syscall.SYS_SETGID32, uintptr(gid), 0, 0) 21 | if e1 != 0 { 22 | err = e1 23 | } 24 | return 25 | } 26 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/opencontainers/runc/libcontainer/system/syscall_linux_64.go: -------------------------------------------------------------------------------- 1 | // +build linux,arm64 linux,amd64 linux,ppc linux,ppc64 linux,ppc64le linux,s390x 2 | 3 | package system 4 | 5 | import ( 6 | "syscall" 7 | ) 8 | 9 | // Setuid sets the uid of the calling thread to the specified uid. 10 | func Setuid(uid int) (err error) { 11 | _, _, e1 := syscall.RawSyscall(syscall.SYS_SETUID, uintptr(uid), 0, 0) 12 | if e1 != 0 { 13 | err = e1 14 | } 15 | return 16 | } 17 | 18 | // Setgid sets the gid of the calling thread to the specified gid. 19 | func Setgid(gid int) (err error) { 20 | _, _, e1 := syscall.RawSyscall(syscall.SYS_SETGID, uintptr(gid), 0, 0) 21 | if e1 != 0 { 22 | err = e1 23 | } 24 | return 25 | } 26 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/opencontainers/runc/libcontainer/system/syscall_linux_arm.go: -------------------------------------------------------------------------------- 1 | // +build linux,arm 2 | 3 | package system 4 | 5 | import ( 6 | "syscall" 7 | ) 8 | 9 | // Setuid sets the uid of the calling thread to the specified uid. 10 | func Setuid(uid int) (err error) { 11 | _, _, e1 := syscall.RawSyscall(syscall.SYS_SETUID32, uintptr(uid), 0, 0) 12 | if e1 != 0 { 13 | err = e1 14 | } 15 | return 16 | } 17 | 18 | // Setgid sets the gid of the calling thread to the specified gid. 19 | func Setgid(gid int) (err error) { 20 | _, _, e1 := syscall.RawSyscall(syscall.SYS_SETGID32, uintptr(gid), 0, 0) 21 | if e1 != 0 { 22 | err = e1 23 | } 24 | return 25 | } 26 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/opencontainers/runc/libcontainer/user/lookup_unix.go: -------------------------------------------------------------------------------- 1 | // +build darwin dragonfly freebsd linux netbsd openbsd solaris 2 | 3 | package user 4 | 5 | import ( 6 | "io" 7 | "os" 8 | ) 9 | 10 | // Unix-specific path to the passwd and group formatted files. 11 | const ( 12 | unixPasswdPath = "/etc/passwd" 13 | unixGroupPath = "/etc/group" 14 | ) 15 | 16 | func GetPasswdPath() (string, error) { 17 | return unixPasswdPath, nil 18 | } 19 | 20 | func GetPasswd() (io.ReadCloser, error) { 21 | return os.Open(unixPasswdPath) 22 | } 23 | 24 | func GetGroupPath() (string, error) { 25 | return unixGroupPath, nil 26 | } 27 | 28 | func GetGroup() (io.ReadCloser, error) { 29 | return os.Open(unixGroupPath) 30 | } 31 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/opencontainers/runc/libcontainer/user/lookup_unsupported.go: -------------------------------------------------------------------------------- 1 | // +build !darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd,!solaris 2 | 3 | package user 4 | 5 | import "io" 6 | 7 | func GetPasswdPath() (string, error) { 8 | return "", ErrUnsupported 9 | } 10 | 11 | func GetPasswd() (io.ReadCloser, error) { 12 | return nil, ErrUnsupported 13 | } 14 | 15 | func GetGroupPath() (string, error) { 16 | return "", ErrUnsupported 17 | } 18 | 19 | func GetGroup() (io.ReadCloser, error) { 20 | return nil, ErrUnsupported 21 | } 22 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/philhofer/fwd/LICENSE.md: -------------------------------------------------------------------------------- 1 | Copyright (c) 2014-2015, Philip Hofer 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: 4 | 5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. 6 | 7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/prometheus/client_golang/NOTICE: -------------------------------------------------------------------------------- 1 | Prometheus instrumentation library for Go applications 2 | Copyright 2012-2015 The Prometheus Authors 3 | 4 | This product includes software developed at 5 | SoundCloud Ltd. (http://soundcloud.com/). 6 | 7 | 8 | The following components are included in this product: 9 | 10 | goautoneg 11 | http://bitbucket.org/ww/goautoneg 12 | Copyright 2011, Open Knowledge Foundation Ltd. 13 | See README.txt for license details. 14 | 15 | perks - a fork of https://github.com/bmizerany/perks 16 | https://github.com/beorn7/perks 17 | Copyright 2013-2015 Blake Mizerany, Björn Rabenstein 18 | See https://github.com/beorn7/perks/blob/master/README.md for license details. 19 | 20 | Go support for Protocol Buffers - Google's data interchange format 21 | http://github.com/golang/protobuf/ 22 | Copyright 2010 The Go Authors 23 | See source code for license details. 24 | 25 | Support for streaming Protocol Buffer messages for the Go language (golang). 26 | https://github.com/matttproud/golang_protobuf_extensions 27 | Copyright 2013 Matt T. Proud 28 | Licensed under the Apache License, Version 2.0 29 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/prometheus/client_golang/prometheus/fnv.go: -------------------------------------------------------------------------------- 1 | package prometheus 2 | 3 | // Inline and byte-free variant of hash/fnv's fnv64a. 4 | 5 | const ( 6 | offset64 = 14695981039346656037 7 | prime64 = 1099511628211 8 | ) 9 | 10 | // hashNew initializies a new fnv64a hash value. 11 | func hashNew() uint64 { 12 | return offset64 13 | } 14 | 15 | // hashAdd adds a string to a fnv64a hash value, returning the updated hash. 16 | func hashAdd(h uint64, s string) uint64 { 17 | for i := 0; i < len(s); i++ { 18 | h ^= uint64(s[i]) 19 | h *= prime64 20 | } 21 | return h 22 | } 23 | 24 | // hashAddByte adds a byte to a fnv64a hash value, returning the updated hash. 25 | func hashAddByte(h uint64, b byte) uint64 { 26 | h ^= uint64(b) 27 | h *= prime64 28 | return h 29 | } 30 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/prometheus/client_model/NOTICE: -------------------------------------------------------------------------------- 1 | Data model artifacts for Prometheus. 2 | Copyright 2012-2015 The Prometheus Authors 3 | 4 | This product includes software developed at 5 | SoundCloud Ltd. (http://soundcloud.com/). 6 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/prometheus/common/NOTICE: -------------------------------------------------------------------------------- 1 | Common libraries shared by Prometheus Go components. 2 | Copyright 2015 The Prometheus Authors 3 | 4 | This product includes software developed at 5 | SoundCloud Ltd. (http://soundcloud.com/). 6 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/prometheus/common/model/model.go: -------------------------------------------------------------------------------- 1 | // Copyright 2013 The Prometheus Authors 2 | // Licensed under the Apache License, Version 2.0 (the "License"); 3 | // you may not use this file except in compliance with the License. 4 | // You may obtain a copy of the License at 5 | // 6 | // http://www.apache.org/licenses/LICENSE-2.0 7 | // 8 | // Unless required by applicable law or agreed to in writing, software 9 | // distributed under the License is distributed on an "AS IS" BASIS, 10 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | // See the License for the specific language governing permissions and 12 | // limitations under the License. 13 | 14 | // Package model contains common data structures that are shared across 15 | // Prometheus components and libraries. 16 | package model 17 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/prometheus/procfs/NOTICE: -------------------------------------------------------------------------------- 1 | procfs provides functions to retrieve system, kernel and process 2 | metrics from the pseudo-filesystem proc. 3 | 4 | Copyright 2014-2015 The Prometheus Authors 5 | 6 | This product includes software developed at 7 | SoundCloud Ltd. (http://soundcloud.com/). 8 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/prometheus/procfs/README.md: -------------------------------------------------------------------------------- 1 | # procfs 2 | 3 | This procfs package provides functions to retrieve system, kernel and process 4 | metrics from the pseudo-filesystem proc. 5 | 6 | *WARNING*: This package is a work in progress. Its API may still break in 7 | backwards-incompatible ways without warnings. Use it at your own risk. 8 | 9 | [![GoDoc](https://godoc.org/github.com/prometheus/procfs?status.png)](https://godoc.org/github.com/prometheus/procfs) 10 | [![Build Status](https://travis-ci.org/prometheus/procfs.svg?branch=master)](https://travis-ci.org/prometheus/procfs) 11 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/prometheus/procfs/fs.go: -------------------------------------------------------------------------------- 1 | package procfs 2 | 3 | import ( 4 | "fmt" 5 | "os" 6 | "path" 7 | ) 8 | 9 | // FS represents the pseudo-filesystem proc, which provides an interface to 10 | // kernel data structures. 11 | type FS string 12 | 13 | // DefaultMountPoint is the common mount point of the proc filesystem. 14 | const DefaultMountPoint = "/proc" 15 | 16 | // NewFS returns a new FS mounted under the given mountPoint. It will error 17 | // if the mount point can't be read. 18 | func NewFS(mountPoint string) (FS, error) { 19 | info, err := os.Stat(mountPoint) 20 | if err != nil { 21 | return "", fmt.Errorf("could not read %s: %s", mountPoint, err) 22 | } 23 | if !info.IsDir() { 24 | return "", fmt.Errorf("mount point %s is not a directory", mountPoint) 25 | } 26 | 27 | return FS(mountPoint), nil 28 | } 29 | 30 | // Path returns the path of the given subsystem relative to the procfs root. 31 | func (fs FS) Path(p ...string) string { 32 | return path.Join(append([]string{string(fs)}, p...)...) 33 | } 34 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/sirupsen/logrus/LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2014 Simon Eskildsen 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in 13 | all copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | THE SOFTWARE. 22 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/sirupsen/logrus/terminal_appengine.go: -------------------------------------------------------------------------------- 1 | // +build appengine 2 | 3 | package logrus 4 | 5 | import "io" 6 | 7 | // IsTerminal returns true if stderr's file descriptor is a terminal. 8 | func IsTerminal(f io.Writer) bool { 9 | return true 10 | } 11 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 "syscall" 7 | 8 | const ioctlReadTermios = syscall.TIOCGETA 9 | 10 | type Termios syscall.Termios 11 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 "syscall" 11 | 12 | const ioctlReadTermios = syscall.TCGETS 13 | 14 | type Termios syscall.Termios 15 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/sirupsen/logrus/terminal_notwindows.go: -------------------------------------------------------------------------------- 1 | // Based on ssh/terminal: 2 | // Copyright 2011 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 linux darwin freebsd openbsd netbsd dragonfly 7 | // +build !appengine 8 | 9 | package logrus 10 | 11 | import ( 12 | "io" 13 | "os" 14 | "syscall" 15 | "unsafe" 16 | ) 17 | 18 | // IsTerminal returns true if stderr's file descriptor is a terminal. 19 | func IsTerminal(f io.Writer) bool { 20 | var termios Termios 21 | switch v := f.(type) { 22 | case *os.File: 23 | _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(v.Fd()), ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0) 24 | return err == 0 25 | default: 26 | return false 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/sirupsen/logrus/terminal_solaris.go: -------------------------------------------------------------------------------- 1 | // +build solaris,!appengine 2 | 3 | package logrus 4 | 5 | import ( 6 | "io" 7 | "os" 8 | 9 | "golang.org/x/sys/unix" 10 | ) 11 | 12 | // IsTerminal returns true if the given file descriptor is a terminal. 13 | func IsTerminal(f io.Writer) bool { 14 | switch v := f.(type) { 15 | case *os.File: 16 | _, err := unix.IoctlGetTermios(int(v.Fd()), unix.TCGETA) 17 | return err == nil 18 | default: 19 | return false 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/tchap/go-patricia/LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2014 The AUTHORS 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 6 | this software and associated documentation files (the "Software"), to deal in 7 | the Software without restriction, including without limitation the rights to 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 9 | the Software, and to permit persons to whom the Software is furnished to do so, 10 | subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/tinylib/msgp/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2014 Philip Hofer 2 | Portions Copyright (c) 2009 The Go Authors (license at http://golang.org) where indicated 3 | 4 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: 5 | 6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. 7 | 8 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/github.com/tonistiigi/fifo/LICENSE: -------------------------------------------------------------------------------- 1 | MIT 2 | 3 | Copyright (C) 2016 Tõnis Tiigi 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in 13 | all copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | THE SOFTWARE. -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/golang.org/x/crypto/pkcs12/errors.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 pkcs12 6 | 7 | import "errors" 8 | 9 | var ( 10 | // ErrDecryption represents a failure to decrypt the input. 11 | ErrDecryption = errors.New("pkcs12: decryption error, incorrect padding") 12 | 13 | // ErrIncorrectPassword is returned when an incorrect password is detected. 14 | // Usually, P12/PFX data is signed to be able to verify the password. 15 | ErrIncorrectPassword = errors.New("pkcs12: decryption password incorrect") 16 | ) 17 | 18 | // NotImplementedError indicates that the input is not currently supported. 19 | type NotImplementedError string 20 | 21 | func (e NotImplementedError) Error() string { 22 | return "pkcs12: " + string(e) 23 | } 24 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/golang.org/x/net/trace/trace_go16.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build !go1.7 6 | 7 | package trace 8 | 9 | import "golang.org/x/net/context" 10 | 11 | // NewContext returns a copy of the parent context 12 | // and associates it with a Trace. 13 | func NewContext(ctx context.Context, tr Trace) context.Context { 14 | return context.WithValue(ctx, contextKey, tr) 15 | } 16 | 17 | // FromContext returns the Trace bound to the context, if any. 18 | func FromContext(ctx context.Context) (tr Trace, ok bool) { 19 | tr, ok = ctx.Value(contextKey).(Trace) 20 | return 21 | } 22 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/golang.org/x/net/trace/trace_go17.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build go1.7 6 | 7 | package trace 8 | 9 | import "context" 10 | 11 | // NewContext returns a copy of the parent context 12 | // and associates it with a Trace. 13 | func NewContext(ctx context.Context, tr Trace) context.Context { 14 | return context.WithValue(ctx, contextKey, tr) 15 | } 16 | 17 | // FromContext returns the Trace bound to the context, if any. 18 | func FromContext(ctx context.Context) (tr Trace, ok bool) { 19 | tr, ok = ctx.Value(contextKey).(Trace) 20 | return 21 | } 22 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/golang.org/x/sys/unix/asm_linux_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 calls for 386, 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 | JMP syscall·Syscall(SB) 18 | 19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40 20 | JMP syscall·Syscall6(SB) 21 | 22 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28 23 | JMP syscall·RawSyscall(SB) 24 | 25 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40 26 | JMP syscall·RawSyscall6(SB) 27 | 28 | TEXT ·socketcall(SB),NOSPLIT,$0-36 29 | JMP syscall·socketcall(SB) 30 | 31 | TEXT ·rawsocketcall(SB),NOSPLIT,$0-36 32 | JMP syscall·rawsocketcall(SB) 33 | 34 | TEXT ·seek(SB),NOSPLIT,$0-28 35 | JMP syscall·seek(SB) 36 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/golang.org/x/sys/unix/flock.go: -------------------------------------------------------------------------------- 1 | // +build linux darwin freebsd openbsd netbsd dragonfly 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 | // +build darwin dragonfly freebsd linux netbsd openbsd 8 | 9 | package unix 10 | 11 | import "unsafe" 12 | 13 | // fcntl64Syscall is usually SYS_FCNTL, but is overridden on 32-bit Linux 14 | // systems by flock_linux_32bit.go to be SYS_FCNTL64. 15 | var fcntl64Syscall uintptr = SYS_FCNTL 16 | 17 | // FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command. 18 | func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error { 19 | _, _, errno := Syscall(fcntl64Syscall, fd, uintptr(cmd), uintptr(unsafe.Pointer(lk))) 20 | if errno == 0 { 21 | return nil 22 | } 23 | return errno 24 | } 25 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/golang.org/x/sys/unix/gccgo_linux_sparc64.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,linux,sparc64 6 | 7 | package unix 8 | 9 | import "syscall" 10 | 11 | //extern sysconf 12 | func realSysconf(name int) int64 13 | 14 | func sysconf(name int) (n int64, err syscall.Errno) { 15 | r := realSysconf(name) 16 | if r < 0 { 17 | return 0, syscall.GetErrno() 18 | } 19 | return r, 0 20 | } 21 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/golang.org/x/sys/unix/openbsd_pledge.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 openbsd 6 | // +build 386 amd64 arm 7 | 8 | package unix 9 | 10 | import ( 11 | "syscall" 12 | "unsafe" 13 | ) 14 | 15 | const ( 16 | SYS_PLEDGE = 108 17 | ) 18 | 19 | // Pledge implements the pledge syscall. For more information see pledge(2). 20 | func Pledge(promises string, paths []string) error { 21 | promisesPtr, err := syscall.BytePtrFromString(promises) 22 | if err != nil { 23 | return err 24 | } 25 | promisesUnsafe, pathsUnsafe := unsafe.Pointer(promisesPtr), unsafe.Pointer(nil) 26 | if paths != nil { 27 | var pathsPtr []*byte 28 | if pathsPtr, err = syscall.SlicePtrFromStrings(paths); err != nil { 29 | return err 30 | } 31 | pathsUnsafe = unsafe.Pointer(&pathsPtr[0]) 32 | } 33 | _, _, e := syscall.Syscall(SYS_PLEDGE, uintptr(promisesUnsafe), uintptr(pathsUnsafe), 0) 34 | if e != 0 { 35 | return e 36 | } 37 | return nil 38 | } 39 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/golang.org/x/sys/unix/syscall_netbsd_386.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 386,netbsd 6 | 7 | package unix 8 | 9 | func Getpagesize() int { return 4096 } 10 | 11 | func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) } 12 | 13 | func NsecToTimespec(nsec int64) (ts Timespec) { 14 | ts.Sec = int64(nsec / 1e9) 15 | ts.Nsec = int32(nsec % 1e9) 16 | return 17 | } 18 | 19 | func NsecToTimeval(nsec int64) (tv Timeval) { 20 | nsec += 999 // round up to microsecond 21 | tv.Usec = int32(nsec % 1e9 / 1e3) 22 | tv.Sec = int64(nsec / 1e9) 23 | return 24 | } 25 | 26 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 27 | k.Ident = uint32(fd) 28 | k.Filter = uint32(mode) 29 | k.Flags = uint32(flags) 30 | } 31 | 32 | func (iov *Iovec) SetLen(length int) { 33 | iov.Len = uint32(length) 34 | } 35 | 36 | func (msghdr *Msghdr) SetControllen(length int) { 37 | msghdr.Controllen = uint32(length) 38 | } 39 | 40 | func (cmsg *Cmsghdr) SetLen(length int) { 41 | cmsg.Len = uint32(length) 42 | } 43 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/golang.org/x/sys/unix/syscall_netbsd_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,netbsd 6 | 7 | package unix 8 | 9 | func Getpagesize() int { return 4096 } 10 | 11 | func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) } 12 | 13 | func NsecToTimespec(nsec int64) (ts Timespec) { 14 | ts.Sec = int64(nsec / 1e9) 15 | ts.Nsec = int64(nsec % 1e9) 16 | return 17 | } 18 | 19 | func NsecToTimeval(nsec int64) (tv Timeval) { 20 | nsec += 999 // round up to microsecond 21 | tv.Usec = int32(nsec % 1e9 / 1e3) 22 | tv.Sec = int64(nsec / 1e9) 23 | return 24 | } 25 | 26 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 27 | k.Ident = uint64(fd) 28 | k.Filter = uint32(mode) 29 | k.Flags = uint32(flags) 30 | } 31 | 32 | func (iov *Iovec) SetLen(length int) { 33 | iov.Len = uint64(length) 34 | } 35 | 36 | func (msghdr *Msghdr) SetControllen(length int) { 37 | msghdr.Controllen = uint32(length) 38 | } 39 | 40 | func (cmsg *Cmsghdr) SetLen(length int) { 41 | cmsg.Len = uint32(length) 42 | } 43 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/golang.org/x/sys/unix/syscall_netbsd_arm.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 arm,netbsd 6 | 7 | package unix 8 | 9 | func Getpagesize() int { return 4096 } 10 | 11 | func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) } 12 | 13 | func NsecToTimespec(nsec int64) (ts Timespec) { 14 | ts.Sec = int64(nsec / 1e9) 15 | ts.Nsec = int32(nsec % 1e9) 16 | return 17 | } 18 | 19 | func NsecToTimeval(nsec int64) (tv Timeval) { 20 | nsec += 999 // round up to microsecond 21 | tv.Usec = int32(nsec % 1e9 / 1e3) 22 | tv.Sec = int64(nsec / 1e9) 23 | return 24 | } 25 | 26 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 27 | k.Ident = uint32(fd) 28 | k.Filter = uint32(mode) 29 | k.Flags = uint32(flags) 30 | } 31 | 32 | func (iov *Iovec) SetLen(length int) { 33 | iov.Len = uint32(length) 34 | } 35 | 36 | func (msghdr *Msghdr) SetControllen(length int) { 37 | msghdr.Controllen = uint32(length) 38 | } 39 | 40 | func (cmsg *Cmsghdr) SetLen(length int) { 41 | cmsg.Len = uint32(length) 42 | } 43 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/golang.org/x/sys/unix/syscall_openbsd_386.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 386,openbsd 6 | 7 | package unix 8 | 9 | func Getpagesize() int { return 4096 } 10 | 11 | func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) } 12 | 13 | func NsecToTimespec(nsec int64) (ts Timespec) { 14 | ts.Sec = int64(nsec / 1e9) 15 | ts.Nsec = int32(nsec % 1e9) 16 | return 17 | } 18 | 19 | func NsecToTimeval(nsec int64) (tv Timeval) { 20 | nsec += 999 // round up to microsecond 21 | tv.Usec = int32(nsec % 1e9 / 1e3) 22 | tv.Sec = int64(nsec / 1e9) 23 | return 24 | } 25 | 26 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 27 | k.Ident = uint32(fd) 28 | k.Filter = int16(mode) 29 | k.Flags = uint16(flags) 30 | } 31 | 32 | func (iov *Iovec) SetLen(length int) { 33 | iov.Len = uint32(length) 34 | } 35 | 36 | func (msghdr *Msghdr) SetControllen(length int) { 37 | msghdr.Controllen = uint32(length) 38 | } 39 | 40 | func (cmsg *Cmsghdr) SetLen(length int) { 41 | cmsg.Len = uint32(length) 42 | } 43 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/golang.org/x/sys/unix/syscall_openbsd_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,openbsd 6 | 7 | package unix 8 | 9 | func Getpagesize() int { return 4096 } 10 | 11 | func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) } 12 | 13 | func NsecToTimespec(nsec int64) (ts Timespec) { 14 | ts.Sec = nsec / 1e9 15 | ts.Nsec = nsec % 1e9 16 | return 17 | } 18 | 19 | func NsecToTimeval(nsec int64) (tv Timeval) { 20 | nsec += 999 // round up to microsecond 21 | tv.Usec = nsec % 1e9 / 1e3 22 | tv.Sec = nsec / 1e9 23 | return 24 | } 25 | 26 | func SetKevent(k *Kevent_t, fd, mode, flags int) { 27 | k.Ident = uint64(fd) 28 | k.Filter = int16(mode) 29 | k.Flags = uint16(flags) 30 | } 31 | 32 | func (iov *Iovec) SetLen(length int) { 33 | iov.Len = uint64(length) 34 | } 35 | 36 | func (msghdr *Msghdr) SetControllen(length int) { 37 | msghdr.Controllen = uint32(length) 38 | } 39 | 40 | func (cmsg *Cmsghdr) SetLen(length int) { 41 | cmsg.Len = uint32(length) 42 | } 43 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) } 10 | 11 | func NsecToTimespec(nsec int64) (ts Timespec) { 12 | ts.Sec = nsec / 1e9 13 | ts.Nsec = nsec % 1e9 14 | return 15 | } 16 | 17 | func NsecToTimeval(nsec int64) (tv Timeval) { 18 | nsec += 999 // round up to microsecond 19 | tv.Usec = nsec % 1e9 / 1e3 20 | tv.Sec = int64(nsec / 1e9) 21 | return 22 | } 23 | 24 | func (iov *Iovec) SetLen(length int) { 25 | iov.Len = uint64(length) 26 | } 27 | 28 | func (cmsg *Cmsghdr) SetLen(length int) { 29 | cmsg.Len = uint32(length) 30 | } 31 | 32 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { 33 | // TODO(aram): implement this, see issue 5847. 34 | panic("unimplemented") 35 | } 36 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/google.golang.org/grpc/codes/code_string.go: -------------------------------------------------------------------------------- 1 | // generated by stringer -type=Code; DO NOT EDIT 2 | 3 | package codes 4 | 5 | import "fmt" 6 | 7 | const _Code_name = "OKCanceledUnknownInvalidArgumentDeadlineExceededNotFoundAlreadyExistsPermissionDeniedResourceExhaustedFailedPreconditionAbortedOutOfRangeUnimplementedInternalUnavailableDataLossUnauthenticated" 8 | 9 | var _Code_index = [...]uint8{0, 2, 10, 17, 32, 48, 56, 69, 85, 102, 120, 127, 137, 150, 158, 169, 177, 192} 10 | 11 | func (i Code) String() string { 12 | if i+1 >= Code(len(_Code_index)) { 13 | return fmt.Sprintf("Code(%d)", i) 14 | } 15 | return _Code_name[_Code_index[i]:_Code_index[i+1]] 16 | } 17 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/google.golang.org/grpc/doc.go: -------------------------------------------------------------------------------- 1 | /* 2 | Package grpc implements an RPC system called gRPC. 3 | 4 | See www.grpc.io for more information about gRPC. 5 | */ 6 | package grpc 7 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/docker/vendor/google.golang.org/grpc/health/grpc_health_v1/health.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package grpc.health.v1; 4 | 5 | message HealthCheckRequest { 6 | string service = 1; 7 | } 8 | 9 | message HealthCheckResponse { 10 | enum ServingStatus { 11 | UNKNOWN = 0; 12 | SERVING = 1; 13 | NOT_SERVING = 2; 14 | } 15 | ServingStatus status = 1; 16 | } 17 | 18 | service Health{ 19 | rpc Check(HealthCheckRequest) returns (HealthCheckResponse); 20 | } 21 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/docker/go-units/MAINTAINERS: -------------------------------------------------------------------------------- 1 | # go-connections maintainers file 2 | # 3 | # This file describes who runs the docker/go-connections project and how. 4 | # This is a living document - if you see something out of date or missing, speak up! 5 | # 6 | # It is structured to be consumable by both humans and programs. 7 | # To extract its contents programmatically, use any TOML-compliant parser. 8 | # 9 | # This file is compiled into the MAINTAINERS file in docker/opensource. 10 | # 11 | [Org] 12 | [Org."Core maintainers"] 13 | people = [ 14 | "calavera", 15 | ] 16 | 17 | [people] 18 | 19 | # A reference list of all people associated with the project. 20 | # All other sections should refer to people by their canonical key 21 | # in the people section. 22 | 23 | # ADD YOURSELF HERE IN ALPHABETICAL ORDER 24 | [people.calavera] 25 | Name = "David Calavera" 26 | Email = "david.calavera@gmail.com" 27 | GitHub = "calavera" 28 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/fsouza/go-dockerclient/.gitignore: -------------------------------------------------------------------------------- 1 | # temporary symlink for testing 2 | testing/data/symlink 3 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/fsouza/go-dockerclient/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | sudo: required 3 | go: 4 | - 1.7.x 5 | - 1.8.x 6 | - 1.9rc2 7 | - tip 8 | os: 9 | - linux 10 | - osx 11 | env: 12 | matrix: 13 | - GOARCH=amd64 DOCKER_PKG_VERSION=17.06.0~ce-0~ubuntu 14 | - GOARCH=386 DOCKER_PKG_VERSION=17.06.0~ce-0~ubuntu 15 | - GOARCH=amd64 DOCKER_PKG_VERSION=17.05.0~ce-0~ubuntu-trusty 16 | - GOARCH=386 DOCKER_PKG_VERSION=17.05.0~ce-0~ubuntu-trusty 17 | global: 18 | - GO_TEST_FLAGS=-race 19 | - DOCKER_HOST=tcp://127.0.0.1:2375 20 | install: 21 | - make testdeps 22 | - travis_retry travis-scripts/install-docker.bash 23 | script: 24 | - travis-scripts/run-tests.bash 25 | services: 26 | - docker 27 | matrix: 28 | fast_finish: true 29 | exclude: 30 | - os: osx 31 | env: GOARCH=amd64 DOCKER_PKG_VERSION=17.05.0~ce-0~ubuntu-trusty 32 | - os: osx 33 | env: GOARCH=386 DOCKER_PKG_VERSION=17.05.0~ce-0~ubuntu-trusty 34 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/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.9rc2 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 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/fsouza/go-dockerclient/change.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 "fmt" 8 | 9 | // ChangeType is a type for constants indicating the type of change 10 | // in a container 11 | type ChangeType int 12 | 13 | const ( 14 | // ChangeModify is the ChangeType for container modifications 15 | ChangeModify ChangeType = iota 16 | 17 | // ChangeAdd is the ChangeType for additions to a container 18 | ChangeAdd 19 | 20 | // ChangeDelete is the ChangeType for deletions from a container 21 | ChangeDelete 22 | ) 23 | 24 | // Change represents a change in a container. 25 | // 26 | // See https://goo.gl/Wo0JJp for more details. 27 | type Change struct { 28 | Path string 29 | Kind ChangeType 30 | } 31 | 32 | func (change *Change) String() string { 33 | var kind string 34 | switch change.Kind { 35 | case ChangeModify: 36 | kind = "C" 37 | case ChangeAdd: 38 | kind = "A" 39 | case ChangeDelete: 40 | kind = "D" 41 | } 42 | return fmt.Sprintf("%s %s", kind, change.Path) 43 | } 44 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/fsouza/go-dockerclient/client_unix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 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 | // +build !windows 6 | 7 | package docker 8 | 9 | import ( 10 | "context" 11 | "net" 12 | "net/http" 13 | ) 14 | 15 | // initializeNativeClient initializes the native Unix domain socket client on 16 | // Unix-style operating systems 17 | func (c *Client) initializeNativeClient() { 18 | if c.endpointURL.Scheme != unixProtocol { 19 | return 20 | } 21 | socketPath := c.endpointURL.Path 22 | tr := defaultTransport() 23 | tr.Dial = func(network, addr string) (net.Conn, error) { 24 | return c.Dialer.Dial(unixProtocol, socketPath) 25 | } 26 | tr.DialContext = func(ctx context.Context, network, addr string) (net.Conn, error) { 27 | return c.Dialer.Dial(unixProtocol, socketPath) 28 | } 29 | c.nativeHTTPClient = &http.Client{Transport: tr} 30 | } 31 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/fsouza/go-dockerclient/testing/data/.dockerignore: -------------------------------------------------------------------------------- 1 | container.tar 2 | dockerfile.tar 3 | foofile 4 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/fsouza/go-dockerclient/testing/data/Dockerfile: -------------------------------------------------------------------------------- 1 | # this file describes how to build tsuru python image 2 | # to run it: 3 | # 1- install docker 4 | # 2- run: $ docker build -t tsuru/python https://raw.github.com/tsuru/basebuilder/master/python/Dockerfile 5 | 6 | from base:ubuntu-quantal 7 | run apt-get install wget -y --force-yes 8 | run wget http://github.com/tsuru/basebuilder/tarball/master -O basebuilder.tar.gz --no-check-certificate 9 | run mkdir /var/lib/tsuru 10 | run tar -xvf basebuilder.tar.gz -C /var/lib/tsuru --strip 1 11 | run cp /var/lib/tsuru/python/deploy /var/lib/tsuru 12 | run cp /var/lib/tsuru/base/restart /var/lib/tsuru 13 | run cp /var/lib/tsuru/base/start /var/lib/tsuru 14 | run /var/lib/tsuru/base/install 15 | run /var/lib/tsuru/base/setup 16 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/fsouza/go-dockerclient/testing/data/barfile: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/digital-wonderland/docker-logstash-forwarder/e0de1eb436e28014eb9c2e6b002ff73878715ab7/Godeps/_workspace/src/github.com/fsouza/go-dockerclient/testing/data/barfile -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/fsouza/go-dockerclient/testing/data/ca.pem: -------------------------------------------------------------------------------- 1 | -----BEGIN CERTIFICATE----- 2 | MIIC1TCCAb+gAwIBAgIQJ9MsNxrUxumNbAytGi3GEDALBgkqhkiG9w0BAQswFjEU 3 | MBIGA1UEChMLQm9vdDJEb2NrZXIwHhcNMTQxMDE2MjAyMTM4WhcNMTcwOTMwMjAy 4 | MTM4WjAWMRQwEgYDVQQKEwtCb290MkRvY2tlcjCCASIwDQYJKoZIhvcNAQEBBQAD 5 | ggEPADCCAQoCggEBALpFCSARjG+5yXoqr7UMzuE0df7RRZfeRZI06lJ02ZqV4Iii 6 | rgL7ML9yPxX50NbLnjiilSDTUhnyocYFItokzUzz8qpX/nlYhuN2Iqwh4d0aWS8z 7 | f5y248F+H1z+HY2W8NPl/6DVlVwYaNW1/k+RPMlHS0INLR6j+3Ievew7RNE0NnM2 8 | znELW6NetekDt3GUcz0Z95vDUDfdPnIk1eIFMmYvLxZh23xOca4Q37a3S8F3d+dN 9 | +OOpwjdgY9Qme0NQUaXpgp58jWuQfB8q7mZrdnLlLqRa8gx1HeDSotX7UmWtWPkb 10 | vd9EdlKLYw5PVpxMV1rkwf2t4TdgD5NfkpXlXkkCAwEAAaMjMCEwDgYDVR0PAQH/ 11 | BAQDAgCkMA8GA1UdEwEB/wQFMAMBAf8wCwYJKoZIhvcNAQELA4IBAQBxYjHVSKqE 12 | MJw7CW0GddesULtXXVWGJuZdWJLQlPvPMfIfjIvlcZyS4cdVNiQ3sREFIZz8TpII 13 | CT0/Pg3sgv/FcOQe1CN0xZYZcyiAZHK1z0fJQq2qVpdv7+tJcjI2vvU6NI24iQCo 14 | W1wz25trJz9QbdB2MRLMjyz7TSWuafztIvcfEzaIdQ0Whqund/cSuPGQx5IwF83F 15 | rvlkOyJSH2+VIEBTCIuykJeL0DLTt8cePBQR5L1ISXb4RUMK9ZtqRscBRv8sn7o2 16 | ixG3wtL0gYF4xLtsQWVxI3iFVrU3WzOH/3c5shVRkWBd+AQRSwCJI4mKH7penJCF 17 | i3/zzlkvOnjV 18 | -----END CERTIFICATE----- 19 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/fsouza/go-dockerclient/testing/data/cert.pem: -------------------------------------------------------------------------------- 1 | -----BEGIN CERTIFICATE----- 2 | MIIC6DCCAdKgAwIBAgIRANO6ymxQAjp66KmEka1G6b0wCwYJKoZIhvcNAQELMBYx 3 | FDASBgNVBAoTC0Jvb3QyRG9ja2VyMB4XDTE0MTAxNjIwMjE1MloXDTE3MDkzMDIw 4 | MjE1MlowFjEUMBIGA1UEChMLQm9vdDJEb2NrZXIwggEiMA0GCSqGSIb3DQEBAQUA 5 | A4IBDwAwggEKAoIBAQDGA1mAhSOpZspD1dpZ7qVEQrIJw4Xo8252jHaORnEdDiFm 6 | b6brEmr6jw8t4P3IGxbqBc/TqRV+SSXxwYEVvfpeQKH+SmqStoMNtD3Ura161az4 7 | V0BcxMtSlsUGpoz+//QCAq8qiaxMwgiyc5253mkQm88anj2cNt7xbewiu/KFWuf7 8 | BVpNK1+ltpJmlukfcj/G+I1bw7j1KxBjDrFqe5cyDuuZcDL2tmUXP/ZWDyXwSv+H 9 | AOckqn44z6aXlBkVvOXDBZJqY76d/vWVDNCuZeXRnqlhP3t1kH4V0RQXo+JD2tgt 10 | JgdU0unzyoFOSWNUBPm73tqmjUGGAmGHBmeegJr/AgMBAAGjNTAzMA4GA1UdDwEB 11 | /wQEAwIAgDATBgNVHSUEDDAKBggrBgEFBQcDAjAMBgNVHRMBAf8EAjAAMAsGCSqG 12 | SIb3DQEBCwOCAQEABVTWl5SmBP+j5He5bQsgnIXjviSKqe40/10V4LJAOmilycRF 13 | zLrzM+YMwfjg6PLIs8CldAMWHw9y9ktZY4MxkgCktaiaN/QmMTMwFWEcN4wy5IpM 14 | U5l93eAg7xsnY430h3QBBADujX4wdF3fs8rSL8zAAQFL0ihurwU124K3yXKsrwpb 15 | CiVUGfIN4sPwjy8Ws9oxHFDC9/P8lgjHZ1nBIf8KSHnMzlxDGj7isQfhtH+7mcCL 16 | cM1qO2NirS2v7uaEPPY+MJstAz+W7EJCW9dfMSmHna2SDC37Xkin7uEY9z+qaKFL 17 | 8d/XxOB/L8Ucy8VZhdsv0dsBq5KfJntITM0ksQ== 18 | -----END CERTIFICATE----- 19 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/fsouza/go-dockerclient/testing/data/foofile: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/digital-wonderland/docker-logstash-forwarder/e0de1eb436e28014eb9c2e6b002ff73878715ab7/Godeps/_workspace/src/github.com/fsouza/go-dockerclient/testing/data/foofile -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/fsouza/go-dockerclient/testing/data/server.pem: -------------------------------------------------------------------------------- 1 | -----BEGIN CERTIFICATE----- 2 | MIIC/DCCAeagAwIBAgIQMUILcXtvmSOK63zEBo0VXzALBgkqhkiG9w0BAQswFjEU 3 | MBIGA1UEChMLQm9vdDJEb2NrZXIwHhcNMTQxMDE2MjAyMTQ2WhcNMTcwOTMwMjAy 4 | MTQ2WjAWMRQwEgYDVQQKEwtCb290MkRvY2tlcjCCASIwDQYJKoZIhvcNAQEBBQAD 5 | ggEPADCCAQoCggEBANxUOUhNnqFnrTlLsBYzfFRZWQo268l+4K4lOJCVbfDonP3g 6 | Mz0vGi9fcyFqEWSA8Y+ShXna625HTnReCwFdsu0861qCIq7v95hFFCyOe0iIxpd0 7 | AKLnl90d+1vonE7andgFgoobbTiMly4UK4H6z8D148fFNIihoteOG3PIF89TFxP7 8 | CJ/3wXnx/IKpdlO8PAnub3tBPJHvGDj7KORLy4IBxRX5VBAdfGNybE66fcrehEva 9 | rLA4m9pgiaR/Nnr9FdKhPyqYdjflLNvzydxNvMIV4M0hFlhXmYvpMjA5/XsTnsyV 10 | t9JHJa5Upwqsbne08t7rsm7liZNxZlko8xPOTQcCAwEAAaNKMEgwDgYDVR0PAQH/ 11 | BAQDAgCgMAwGA1UdEwEB/wQCMAAwKAYDVR0RBCEwH4ILYm9vdDJkb2NrZXKHBH8A 12 | AAGHBAoAAg+HBMCoO2cwCwYJKoZIhvcNAQELA4IBAQAYoYcDkDWkl73FZ0WnPmAj 13 | LiF7HU95Qg3KyEpFsAJeShSLPPbQntmwhdekEzY4tQ3eKQB/+zHFjzsCr/lmDUmH 14 | Ea/ryQ17C+jyH+Ykg0IWW6L6veZhvRDg6Z9focVtPVBRxPTqC/Qhb54blWRASV+W 15 | UreMuXQ5+1dQptAM7ixOeLVHjBi/bd9TL3jvwBVCr9QedteMjjK4TCF9Tbcou+MF 16 | 2w3OJJZMDhcD+YwoK9uJDqlKmcTm/vVMbSsp/pTMcnQ7jxCeR8/XyX+VwTZwaHAa 17 | o92Q/eg3THAiWhvyT/SzyH9dHHBAyXynUwGCggKawHktfvW4QXRPuLxLrJ7iB5cy 18 | -----END CERTIFICATE----- 19 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/fsouza/go-dockerclient/travis-scripts/install-docker.bash: -------------------------------------------------------------------------------- 1 | #!/bin/bash -x 2 | 3 | # Copyright 2016 go-dockerclient 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 | if [[ $TRAVIS_OS_NAME == "linux" ]]; then 8 | sudo stop docker || true 9 | sudo rm -rf /var/lib/docker 10 | sudo rm -f `which docker` 11 | 12 | set -e 13 | curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - 14 | sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) edge" 15 | sudo apt-get update 16 | sudo apt-get install docker-ce=${DOCKER_PKG_VERSION} -y --force-yes -o Dpkg::Options::="--force-confdef" -o Dpkg::Options::="--force-confold" 17 | sudo start docker || true 18 | fi 19 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/fsouza/go-dockerclient/travis-scripts/run-tests.bash: -------------------------------------------------------------------------------- 1 | #!/bin/bash -ex 2 | 3 | # Copyright 2016 go-dockerclient 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 | make test 8 | 9 | if [[ $TRAVIS_OS_NAME == "linux" ]]; then 10 | make integration 11 | fi 12 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/google/go-cmp/cmp/cmpopts/sort_go18.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.md file. 4 | 5 | // +build go1.8 6 | 7 | package cmpopts 8 | 9 | import ( 10 | "reflect" 11 | "sort" 12 | ) 13 | 14 | const hasReflectStructOf = true 15 | 16 | func mapEntryType(t reflect.Type) reflect.Type { 17 | return reflect.StructOf([]reflect.StructField{ 18 | {Name: "K", Type: t.Key()}, 19 | {Name: "V", Type: t.Elem()}, 20 | }) 21 | } 22 | 23 | func sliceIsSorted(slice interface{}, less func(i, j int) bool) bool { 24 | return sort.SliceIsSorted(slice, less) 25 | } 26 | func sortSlice(slice interface{}, less func(i, j int) bool) { 27 | sort.Slice(slice, less) 28 | } 29 | func sortSliceStable(slice interface{}, less func(i, j int) bool) { 30 | sort.SliceStable(slice, less) 31 | } 32 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/google/go-cmp/cmp/internal/diff/debug_disable.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017, The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE.md file. 4 | 5 | // +build !debug 6 | 7 | package diff 8 | 9 | var debug debugger 10 | 11 | type debugger struct{} 12 | 13 | func (debugger) Begin(_, _ int, f EqualFunc, _, _ *EditScript) EqualFunc { 14 | return f 15 | } 16 | func (debugger) Update() {} 17 | func (debugger) Finish() {} 18 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/google/go-cmp/cmp/unsafe_panic.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017, The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE.md file. 4 | 5 | // +build appengine js 6 | 7 | package cmp 8 | 9 | import "reflect" 10 | 11 | const supportAllowUnexported = false 12 | 13 | func unsafeRetrieveField(reflect.Value, reflect.StructField) reflect.Value { 14 | panic("unsafeRetrieveField is not implemented") 15 | } 16 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/google/go-cmp/cmp/unsafe_reflect.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.md file. 4 | 5 | // +build !appengine,!js 6 | 7 | package cmp 8 | 9 | import ( 10 | "reflect" 11 | "unsafe" 12 | ) 13 | 14 | const supportAllowUnexported = true 15 | 16 | // unsafeRetrieveField uses unsafe to forcibly retrieve any field from a struct 17 | // such that the value has read-write permissions. 18 | // 19 | // The parent struct, v, must be addressable, while f must be a StructField 20 | // describing the field to retrieve. 21 | func unsafeRetrieveField(v reflect.Value, f reflect.StructField) reflect.Value { 22 | return reflect.NewAt(f.Type, unsafe.Pointer(v.UnsafeAddr()+f.Offset)).Elem() 23 | } 24 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/op/go-logging/.travis.yml: -------------------------------------------------------------------------------- 1 | language: go 2 | 3 | go: 4 | - 1.0 5 | - 1.1 6 | - tip 7 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/op/go-logging/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # Changelog 2 | 3 | ## 2.0.0-rc1 (2016-02-11) 4 | 5 | Time flies and it has been three years since this package was first released. 6 | There have been a couple of API changes I have wanted to do for some time but 7 | I've tried to maintain backwards compatibility. Some inconsistencies in the 8 | API have started to show, proper vendor support in Go out of the box and 9 | the fact that `go vet` will give warnings -- I have decided to bump the major 10 | version. 11 | 12 | * Make eg. `Info` and `Infof` do different things. You want to change all calls 13 | to `Info` with a string format go to `Infof` etc. In many cases, `go vet` will 14 | guide you. 15 | * `Id` in `Record` is now called `ID` 16 | 17 | ## 1.0.0 (2013-02-21) 18 | 19 | Initial release 20 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/op/go-logging/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | Alec Thomas 2 | Guilhem Lettron 3 | Ivan Daniluk 4 | Nimi Wariboko Jr 5 | Róbert Selvek 6 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/op/go-logging/examples/example.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/digital-wonderland/docker-logstash-forwarder/e0de1eb436e28014eb9c2e6b002ff73878715ab7/Godeps/_workspace/src/github.com/op/go-logging/examples/example.png -------------------------------------------------------------------------------- /Godeps/_workspace/src/github.com/op/go-logging/syslog_fallback.go: -------------------------------------------------------------------------------- 1 | // Copyright 2013, Örjan Persson. All rights reserved. 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 plan9 6 | 7 | package logging 8 | 9 | import ( 10 | "fmt" 11 | ) 12 | 13 | type Priority int 14 | 15 | type SyslogBackend struct { 16 | } 17 | 18 | func NewSyslogBackend(prefix string) (b *SyslogBackend, err error) { 19 | return nil, fmt.Errorf("Platform does not support syslog") 20 | } 21 | 22 | func NewSyslogBackendPriority(prefix string, priority Priority) (b *SyslogBackend, err error) { 23 | return nil, fmt.Errorf("Platform does not support syslog") 24 | } 25 | 26 | func (b *SyslogBackend) Log(level Level, calldepth int, rec *Record) error { 27 | return fmt.Errorf("Platform does not support syslog") 28 | } 29 | -------------------------------------------------------------------------------- /Godeps/_workspace/src/golang.org/x/net/context/go19.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build go1.9 6 | 7 | package context 8 | 9 | import "context" // standard library's context, as of Go 1.7 10 | 11 | // A Context carries a deadline, a cancelation signal, and other values across 12 | // API boundaries. 13 | // 14 | // Context's methods may be called by multiple goroutines simultaneously. 15 | type Context = context.Context 16 | 17 | // A CancelFunc tells an operation to abandon its work. 18 | // A CancelFunc does not wait for the work to stop. 19 | // After the first call, subsequent calls to a CancelFunc do nothing. 20 | type CancelFunc = context.CancelFunc 21 | -------------------------------------------------------------------------------- /dev-container/Dockerfile: -------------------------------------------------------------------------------- 1 | FROM digitalwonderland/base 2 | 3 | ENV GOPATH /var/lib/golang 4 | ENV PATH $GOPATH/bin:$PATH 5 | 6 | RUN mkdir $GOPATH 7 | 8 | RUN yum install -y epel-release \ 9 | && yum install -y hg git golang && yum clean all 10 | 11 | RUN go get github.com/elasticsearch/logstash-forwarder \ 12 | && go get github.com/tools/godep \ 13 | && godep get github.com/digital-wonderland/docker-logstash-forwarder 14 | 15 | ENTRYPOINT ["/var/lib/golang/bin/docker-logstash-forwarder"] 16 | --------------------------------------------------------------------------------