func main() { client.BindClientConfigFlags(flag.CommandLine, clientConfig) flag.Set("logtostderr", "true") flag.Parse() cmd := exec.Command("haproxy", "-f", configPath, "-p", "/var/run/haproxy.pid") cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr err := cmd.Run() if err != nil { if o, err := cmd.CombinedOutput(); err != nil { glog.Error(string(o)) } glog.Fatalf("haproxy process died, : %v", err) } glog.Info("started haproxy") clientConfig.TLSClientConfig = loadTLSConfigOrDie() //clientConfig.Version = "v1beta3" clientConfig.Version = "v1" kubeClient, err := client.New(clientConfig) if err != nil { glog.Fatalf("Invalid API configuration: %v", err) } cu := configUpdater{ make([]api.Endpoints, 0), make([]api.Service, 0), make(chan []api.Endpoints), make(chan []api.Service), template.Must(template.ParseFiles(templatePath)), make(chan struct{}, 1), } endpointsConfig := config.NewEndpointsConfig() serviceConfig := config.NewServiceConfig() endpointsConfig.RegisterHandler(cu.eu) serviceConfig.RegisterHandler(cu.su) config.NewSourceAPI( kubeClient.Services(api.NamespaceAll), kubeClient.Endpoints(api.NamespaceAll), 30*time.Second, serviceConfig.Channel("api"), endpointsConfig.Channel("api"), ) glog.Info("started watch") go util.Forever(cu.reloadLoop, 1*time.Second) util.Forever(cu.syncLoop, 1*time.Second) }
// AddFlags adds flags for a specific CMServer to the specified FlagSet func (s *CMServer) AddFlags(fs *pflag.FlagSet) { fs.IntVar(&s.Port, "port", s.Port, "The port that the controller-manager's http service runs on") fs.Var(&s.Address, "address", "The IP address to serve on (set to 0.0.0.0 for all interfaces)") client.BindClientConfigFlags(fs, &s.ClientConfig) fs.StringVar(&s.CloudProvider, "cloud_provider", s.CloudProvider, "The provider for cloud services. Empty string for no provider.") fs.StringVar(&s.CloudConfigFile, "cloud_config", s.CloudConfigFile, "The path to the cloud provider configuration file. Empty string for no configuration file.") fs.StringVar(&s.MinionRegexp, "minion_regexp", s.MinionRegexp, "If non empty, and --cloud_provider is specified, a regular expression for matching minion VMs.") fs.DurationVar(&s.NodeSyncPeriod, "node_sync_period", s.NodeSyncPeriod, ""+ "The period for syncing nodes from cloudprovider. Longer periods will result in "+ "fewer calls to cloud provider, but may delay addition of new nodes to cluster.") fs.DurationVar(&s.ResourceQuotaSyncPeriod, "resource_quota_sync_period", s.ResourceQuotaSyncPeriod, "The period for syncing quota usage status in the system") fs.DurationVar(&s.PodEvictionTimeout, "pod_eviction_timeout", s.PodEvictionTimeout, "The grace peroid for deleting pods on failed nodes.") fs.IntVar(&s.RegisterRetryCount, "register_retry_count", s.RegisterRetryCount, ""+ "The number of retries for initial node registration. Retry interval equals node_sync_period.") fs.Var(&s.MachineList, "machines", "List of machines to schedule onto, comma separated.") fs.BoolVar(&s.SyncNodeList, "sync_nodes", s.SyncNodeList, "If true, and --cloud_provider is specified, sync nodes from the cloud provider. Default true.") fs.BoolVar(&s.SyncNodeStatus, "sync_node_status", s.SyncNodeStatus, "Should node controler send probes to kubelets and update NodeStatus.") // TODO: Discover these by pinging the host machines, and rip out these flags. // TODO: in the meantime, use resource.QuantityFlag() instead of these fs.Int64Var(&s.NodeMilliCPU, "node_milli_cpu", s.NodeMilliCPU, "The amount of MilliCPU provisioned on each node") fs.Var(resource.NewQuantityFlagValue(&s.NodeMemory), "node_memory", "The amount of memory (in bytes) provisioned on each node") client.BindKubeletClientConfigFlags(fs, &s.KubeletConfig) fs.BoolVar(&s.EnableProfiling, "profiling", false, "Enable profiling via web interface host:port/debug/pprof/") }
func init() { client.BindClientConfigFlags(flag.CommandLine, clientConfig) flag.Var(&etcdServerList, "etcd_servers", "List of etcd servers to watch (http://ip:port), comma separated (optional). Mutually exclusive with -etcd_config") flag.Var(&bindAddress, "bind_address", "The IP address for the proxy server to serve on (set to 0.0.0.0 for all interfaces)") }
// AddFlags adds flags for a specific ProxyServer to the specified FlagSet func (s *ProxyServer) AddFlags(fs *pflag.FlagSet) { fs.Var(&s.BindAddress, "bind_address", "The IP address for the proxy server to serve on (set to 0.0.0.0 for all interfaces)") client.BindClientConfigFlags(fs, &s.ClientConfig) fs.IntVar(&s.HealthzPort, "healthz_port", s.HealthzPort, "The port to bind the health check server. Use 0 to disable.") fs.IntVar(&s.OOMScoreAdj, "oom_score_adj", s.OOMScoreAdj, "The oom_score_adj value for kube-proxy process. Values must be within the range [-1000, 1000]") }
func init() { flag.Var(&address, "address", "The IP address to serve on (set to 0.0.0.0 for all interfaces)") client.BindClientConfigFlags(flag.CommandLine, clientConfig) }
func init() { flag.Var(&address, "address", "The IP address to serve on (set to 0.0.0.0 for all interfaces)") flag.Var(&machineList, "machines", "List of machines to schedule onto, comma separated.") client.BindClientConfigFlags(flag.CommandLine, clientConfig) }
func init() { client.BindClientConfigFlags(flag.CommandLine, clientConfig) }
func init() { client.BindClientConfigFlags(&FlagSet{}, clientConfig) }