コード例 #1
0
ファイル: envflag.go プロジェクト: NirmataOSS/go-envflag
// UInt creates a new entry in the flag set with UInt value.
// The environment value used as a default, if it exists
func UInt(flagName, envName string, value uint, usage string) *uint {
	verifyNames(flagName, envName)
	envValStr := lookupEnv(envName)
	if envValStr != "" {
		ui64, _ := strconv.ParseUint(envValStr, 10, 64)
		value = uint(ui64)
	}

	flag.Uint(flagName, value, usage)
	return pflag.Uint(flagName, value, usage)
}
コード例 #2
0
ファイル: daemon.go プロジェクト: roboll/contrib
	"k8s.io/contrib/kubelet-to-gcm/monitor/controller"
	"k8s.io/contrib/kubelet-to-gcm/monitor/kubelet"
)

const (
	scope = "https://www.googleapis.com/auth/monitoring.write"
	//testPath = "https://test-monitoring.sandbox.googleapis.com"
)

var (
	// Flags to identify the Kubelet.
	zone        = pflag.String("zone", "use-gce", "The zone where this kubelet lives.")
	project     = pflag.String("project", "use-gce", "The project where this kubelet's host lives.")
	cluster     = pflag.String("cluster", "use-gce", "The cluster where this kubelet holds membership.")
	kubeletHost = pflag.String("kubelet-host", "use-gce", "The kubelet's host name.")
	kubeletPort = pflag.Uint("kubelet-port", 10255, "The kubelet's port.")
	ctrlPort    = pflag.Uint("controller-manager-port", 10252, "The kube-controller's port.")
	// Flags to control runtime behavior.
	res         = pflag.Uint("resolution", 10, "The time, in seconds, to poll the Kubelet.")
	gcmEndpoint = pflag.String("gcm-endpoint", "", "The GCM endpoint to hit. Defaults to the default endpoint.")
)

func main() {
	// First log our starting config, and then set up.
	flag.Set("logtostderr", "true") // This spoofs glog into teeing logs to stderr.
	defer log.Flush()
	pflag.Parse()
	log.Infof("Invoked by %v", os.Args)

	resolution := time.Second * time.Duration(*res)
コード例 #3
0
	"github.com/kismatic/kubernetes-ldap/auth"
	"net/http"
	"net/http/httputil"
	"net/url"
	"os"
	"time"

	flag "github.com/spf13/pflag"
)

const (
	usage            = "kubernetes-ldap <options>"
	ReadWriteTimeout = time.Minute * 60
)

var flPort = flag.Uint("port", 4000, "Local port this proxy server will run on")

var flInsecure = flag.Bool("ldap-insecure", false, "Disable LDAP TLS")
var flLdapHost = flag.String("ldap-host", "", "Host or IP of the LDAP server")
var flLdapPort = flag.Uint("ldap-port", 389, "LDAP server port")
var flBaseDN = flag.String("ldap-base-dn", "", "LDAP user base DN in the form 'dc=example,dc=com'")
var flUserLoginAttribute = flag.String("ldap-user-attribute", "uid", "LDAP Username attribute for login")
var flSearchUserDN = flag.String("ldap-search-user-dn", "", "Search user DN for this app to find users (e.g.: cn=admin,dc=example,dc=com).")
var flSearchUserPassword = flag.String("ldap-search-user-password", "", "Search user password")

var flTLSCertFile = flag.String("tls-cert-file", "",
	"File containing x509 Certificate for HTTPS.  (CA cert, if any, concatenated after server cert).")
var flTLSPrivateKeyFile = flag.String("tls-private-key-file", "", "File containing x509 private key matching --tls-cert-file.")
var flCertDirectory = flag.String("cert-dir", "", "The directory where the TLS certs are located (by default /var/run/kubernetes). "+
	"If --tls-cert-file and --tls-private-key-file are provided, this flag will be ignored.")
コード例 #4
0
ファイル: daemon.go プロジェクト: saad-ali/contrib
)

const (
	gceMDEndpoint = "http://169.254.169.254"
	gceMDPrefix   = "/computeMetadata/v1"
	scope         = "https://www.googleapis.com/auth/monitoring.write"
	//testPath = "https://test-monitoring.sandbox.googleapis.com"
)

var (
	// Flags to identify the Kubelet.
	zoneArg        = pflag.String("zone", "use-gce", "The zone where this kubelet lives.")
	projectArg     = pflag.String("project", "use-gce", "The project where this kubelet's host lives.")
	clusterArg     = pflag.String("cluster", "use-gce", "The cluster where this kubelet holds membership.")
	kubeletHostArg = pflag.String("kubelet-host", "use-gce", "The kubelet's host name.")
	port           = pflag.Uint("kubelet-port", 10255, "The kubelet's port.")
	// Flags to control runtime behavior.
	resolutionArg = pflag.Uint("resolution", 10, "The time, in seconds, to poll the Kubelet.")
	gcmEndpoint   = pflag.String("gcm-endpoint", "", "The GCM endpoint to hit. Defaults to the default endpoint.")
)

// metadataURI returns the full URI for the desired resource
func metadataURI(resource string) string {
	return gceMDEndpoint + gceMDPrefix + resource
}

// getGCEMetaData hits the instance's MD server.
func getGCEMetaData(uri string) ([]byte, error) {
	client := &http.Client{}
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
コード例 #5
0
	"github.com/golang/glog"
	flag "github.com/spf13/pflag"
)

const defaultRootDir = "/var/lib/kubelet"

var (
	config                  = flag.String("config", "", "Path to the config file or directory of files")
	syncFrequency           = flag.Duration("sync_frequency", 10*time.Second, "Max period between synchronizing running containers and config")
	fileCheckFrequency      = flag.Duration("file_check_frequency", 20*time.Second, "Duration between checking config files for new data")
	httpCheckFrequency      = flag.Duration("http_check_frequency", 20*time.Second, "Duration between checking http for new data")
	manifestURL             = flag.String("manifest_url", "", "URL for accessing the container manifest")
	enableServer            = flag.Bool("enable_server", true, "Enable the info server")
	address                 = util.IP(net.ParseIP("127.0.0.1"))
	port                    = flag.Uint("port", ports.KubeletPort, "The port for the info server to serve on")
	hostnameOverride        = flag.String("hostname_override", "", "If non-empty, will use this string as identification instead of the actual hostname.")
	networkContainerImage   = flag.String("network_container_image", kubelet.NetworkContainerImage, "The image that network containers in each pod will use.")
	dockerEndpoint          = flag.String("docker_endpoint", "", "If non-empty, use this for the docker endpoint to communicate with")
	etcdServerList          util.StringList
	etcdConfigFile          = flag.String("etcd_config", "", "The config file for the etcd client. Mutually exclusive with -etcd_servers")
	rootDirectory           = flag.String("root_dir", defaultRootDir, "Directory path for managing kubelet files (volume mounts,etc).")
	allowPrivileged         = flag.Bool("allow_privileged", false, "If true, allow containers to request privileged mode. [default=false]")
	registryPullQPS         = flag.Float64("registry_qps", 0.0, "If > 0, limit registry pull QPS to this value.  If 0, unlimited. [default=0.0]")
	registryBurst           = flag.Int("registry_burst", 10, "Maximum size of a bursty pulls, temporarily allows pulls to burst to this number, while still not exceeding registry_qps.  Only used if --registry_qps > 0")
	runonce                 = flag.Bool("runonce", false, "If true, exit after spawning pods from local manifests or remote urls. Exclusive with --etcd_servers, --api_servers, and --enable-server")
	enableDebuggingHandlers = flag.Bool("enable_debugging_handlers", true, "Enables server endpoints for log collection and local running of containers and commands")
	minimumGCAge            = flag.Duration("minimum_container_ttl_duration", 1*time.Minute, "Minimum age for a finished container before it is garbage collected.  Examples: '300ms', '10s' or '2h45m'")
	maxContainerCount       = flag.Int("maximum_dead_containers_per_container", 5, "Maximum number of old instances of a container to retain per container.  Each container takes up some disk space.  Default: 5.")
	authPath                = flag.String("auth_path", "", "Path to .kubernetes_auth file, specifying how to authenticate to API server.")
	cAdvisorPort            = flag.Uint("cadvisor_port", 4194, "The port of the localhost cAdvisor endpoint")
コード例 #6
0
ファイル: daemon.go プロジェクト: upmc-enterprises/contrib
	v3 "google.golang.org/api/monitoring/v3"
	"k8s.io/contrib/kubelet-to-gcm/monitor"
)

const (
	scope = "https://www.googleapis.com/auth/monitoring.write"
	//testPath = "https://test-monitoring.sandbox.googleapis.com"
)

var (
	// Flags to identify the Kubelet.
	zoneArg    = pflag.String("zone", "", "The zone where this kubelet lives.")
	projectArg = pflag.String("project", "", "The project where this kubelet's host lives.")
	cluster    = pflag.String("cluster", "unknown", "The cluster where this kubelet holds membership.")
	host       = pflag.String("host", "localhost", "The kubelet's host name.")
	port       = pflag.Uint("port", 10255, "The kubelet's port.")
	// Flags to control runtime behavior.
	resolution  = time.Second * time.Duration(*pflag.Uint("resolution", 10, "The time, in seconds, to poll the Kubelet."))
	gcmEndpoint = pflag.String("gcm-endpoint", "", "The GCM endpoint to hit. Defaults to the default endpoint.")
)

// getGCEMetaData hits the instance's MD server.
func getGCEMetaData(uri string) ([]byte, error) {
	client := &http.Client{}
	req, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		return nil, fmt.Errorf("Failed to create request %q for GCE metadata: %v", uri, err)
	}
	req.Header.Add("Metadata-Flavor", "Google")
	resp, err := client.Do(req)
	if err != nil {