func main() { runtime.GOMAXPROCS(1) log.SetLevel(log.DebugLevel) fmt.Println("Starting Riak Executor") signals := make(chan os.Signal, 1) signal.Notify(signals, syscall.SIGUSR1, syscall.SIGUSR2) executor := newExecutor() dconfig := exec.DriverConfig{ Executor: executor, } driver, err := exec.NewMesosExecutorDriver(dconfig) if err != nil { fmt.Println("Unable to create a ExecutorDriver ", err.Error()) } _, err = driver.Start() if err != nil { fmt.Println("Got error:", err) return } go signalWatcher(signals, executor) executor.Driver = driver fmt.Println("Executor process has started and running.") driver.Join() }
func main() { launchTimeout := flag.Uint("launch-timeout", 240, "Seconds to retry launching an etcd instance for before giving up. "+ "This should be long enough for a port occupied by a killed process "+ "to be vacated.") flag.Parse() log.Infoln("Starting etcd Executor") dconfig := executor.DriverConfig{ Executor: etcdexecutor.New( time.Duration(*launchTimeout) * time.Second, ), } driver, err := executor.NewMesosExecutorDriver(dconfig) if err != nil { log.Infoln("Unable to create an ExecutorDriver ", err.Error()) } _, err = driver.Start() if err != nil { log.Infoln("Got error:", err) return } log.Infoln("Executor process has started and running.") driver.Join() }
func main() { flag.Parse() err := syscol.InitLogging(*logLevel) if err != nil { fmt.Println(err) os.Exit(1) } driverConfig := executor.DriverConfig{ Executor: new(syscol.Executor), } driver, err := executor.NewMesosExecutorDriver(driverConfig) if err != nil { syscol.Logger.Error(err) os.Exit(1) } _, err = driver.Start() if err != nil { syscol.Logger.Error(err) os.Exit(1) } driver.Join() }
func main() { flag.Parse() err := statsd.InitLogging(*logLevel) if err != nil { fmt.Println(err) os.Exit(1) } driverConfig := executor.DriverConfig{ Executor: &statsd.Executor{Host: *host}, } driver, err := executor.NewMesosExecutorDriver(driverConfig) if err != nil { statsd.Logger.Error(err) os.Exit(1) } _, err = driver.Start() if err != nil { statsd.Logger.Error(err) os.Exit(1) } driver.Join() }
func main() { fmt.Println(os.Args) fmt.Println("Parsing") flag.Parse() fmt.Println("Init") exec := NewNebulaExecutor() config := mesos_exec.DriverConfig{ Executor: exec, } fmt.Println("Create") driver, err := mesos_exec.NewMesosExecutorDriver(config) if err != nil { fmt.Println("Unable to create a ExecutorDriver ", err.Error()) } _, err = driver.Start() if err != nil { fmt.Println("Got error:", err) return } fmt.Println("Executor process has started and running.") _, err = driver.Join() if err != nil { fmt.Println("driver failed:", err) } fmt.Println("executor terminating") }
func ghsNodeMain() { fmt.Println("Starting GHSVIS Executor") dconfig := exec.DriverConfig{ Executor: newVISGHSExecutor(), } driver, err := exec.NewMesosExecutorDriver(dconfig) if err != nil { fmt.Println("Unable to create a ExecutorDriver ", err.Error()) } _, err = driver.Start() if err != nil { fmt.Println("Got error:", err) return } fmt.Println("Executor process has started and running.") _, err = driver.Join() if err != nil { fmt.Println("driver failed:", err) } fmt.Println("executor terminating") }
func start(c *cli.Context) { workDir := c.String("work_dir") if workDir == "" { log.Fatal("work_dir is not specified") } err := utils.PerformPreChecksAndPrepareHost(workDir) if err != nil { log.WithFields(log.Fields{ "err": err, }).Fatal("Environment error, cannot run rancher-mesos-executor") } log.Info("Setup of env complete. Starting executor driver") driver, err := executor.NewMesosExecutorDriver( executor.DriverConfig{ Executor: rancher_mesos.NewRancherExecutor( filepath.Join(workDir, "rancheros.iso"), c.String("bridge_iface"), c.String("bridge_cidr"), filepath.Join(workDir, "base-img.img")), }, ) if err != nil { log.WithFields(log.Fields{ "err": err, }).Fatal("Error starting executor") } _, err = driver.Run() if err != nil { log.WithFields(log.Fields{ "err": err, }).Fatal("Error starting executor") } }
func (s *KubeletExecutorServer) runExecutor( nodeInfos chan<- executor.NodeInfo, kubeletFinished <-chan struct{}, staticPodsConfigPath string, apiclient *clientset.Clientset, registry executor.Registry, ) (<-chan struct{}, error) { staticPodFilters := podutil.Filters{ // annotate the pod with BindingHostKey so that the scheduler will ignore the pod // once it appears in the pod registry. the stock kubelet sets the pod host in order // to accomplish the same; we do this because the k8sm scheduler works differently. podutil.Annotator(map[string]string{ meta.BindingHostKey: s.HostnameOverride, }), } if s.containerID != "" { // tag all pod containers with the containerID so that they can be properly GC'd by Mesos staticPodFilters = append(staticPodFilters, podutil.Environment([]api.EnvVar{ {Name: envContainerID, Value: s.containerID}, })) } exec := executor.New(executor.Config{ Registry: registry, APIClient: apiclient, Docker: dockertools.ConnectToDockerOrDie(s.DockerEndpoint), SuicideTimeout: s.SuicideTimeout, KubeletFinished: kubeletFinished, ExitFunc: os.Exit, NodeInfos: nodeInfos, Options: []executor.Option{ executor.StaticPods(staticPodsConfigPath, staticPodFilters), }, }) // initialize driver and initialize the executor with it dconfig := bindings.DriverConfig{ Executor: exec, HostnameOverride: s.HostnameOverride, BindingAddress: net.ParseIP(s.Address), } driver, err := bindings.NewMesosExecutorDriver(dconfig) if err != nil { return nil, fmt.Errorf("failed to create executor driver: %v", err) } log.V(2).Infof("Initialize executor driver...") exec.Init(driver) // start the driver go func() { if _, err := driver.Run(); err != nil { log.Fatalf("executor driver failed: %v", err) } log.Info("executor Run completed") }() return exec.Done(), nil }
func runExecutor(app *stockpile.App) { taskExecutor := stockpile.NewExecutor(app) driverConfig := executor.DriverConfig{ Executor: taskExecutor, } driver, err := executor.NewMesosExecutorDriver(driverConfig) if err != nil { stockpile.Logger.Error(err) panic(err) } _, err = driver.Start() if err != nil { stockpile.Logger.Error(err) panic(err) } driver.Run() }
func main() { fmt.Println("Starting Task Runner (APT-MESOS)") driverConfig := executor.DriverConfig{ Executor: NewTaskRunner(), } driver, err := executor.NewMesosExecutorDriver(driverConfig) if err != nil { fmt.Println("Unable to create a ExecutorDriver ", err.Error()) } _, err = driver.Start() if err != nil { fmt.Println("Got error:", err) return } fmt.Println("Executor process has started and running.") driver.Join() }
func main() { fmt.Println("Starting Example Executor (Go)") dconfig := exec.DriverConfig{ Executor: newExampleExecutor(), } driver, err := exec.NewMesosExecutorDriver(dconfig) if err != nil { fmt.Println("Unable to create a ExecutorDriver ", err.Error()) } _, err = driver.Start() if err != nil { fmt.Println("Got error:", err) return } fmt.Println("Executor process has started and running.") driver.Join() }
func (s *KubeletExecutorServer) runExecutor( nodeInfos chan<- executor.NodeInfo, kubeletFinished <-chan struct{}, staticPodsConfigPath string, apiclient *clientset.Clientset, registry executor.Registry, ) (<-chan struct{}, error) { exec := executor.New(executor.Config{ Registry: registry, APIClient: apiclient, Docker: dockertools.ConnectToDockerOrDie(s.DockerEndpoint), SuicideTimeout: s.SuicideTimeout, KubeletFinished: kubeletFinished, ExitFunc: os.Exit, StaticPodsConfigPath: staticPodsConfigPath, NodeInfos: nodeInfos, }) // initialize driver and initialize the executor with it dconfig := bindings.DriverConfig{ Executor: exec, HostnameOverride: s.HostnameOverride, BindingAddress: net.ParseIP(s.Address), } driver, err := bindings.NewMesosExecutorDriver(dconfig) if err != nil { return nil, fmt.Errorf("failed to create executor driver: %v", err) } log.V(2).Infof("Initialize executor driver...") exec.Init(driver) // start the driver go func() { if _, err := driver.Run(); err != nil { log.Fatalf("executor driver failed: %v", err) } log.Info("executor Run completed") }() return exec.Done(), nil }
func main() { log.Infoln("START executor") config := exec.DriverConfig{ Executor: forbin.NewDatabaseExecutor(), } driver, err := exec.NewMesosExecutorDriver(config) if err != nil { log.Infoln("Unable to create a ExecutorDriver ", err.Error()) } _, err = driver.Start() if err != nil { log.Infoln("Got error:", err) return } log.Infoln("Executor process has started and running.") driver.Join() }
func main() { flag.Parse() fmt.Println("Starting Elodina Executor") httpMirrorExecutor := framework.NewHttpMirrorExecutor(*apiKey, *apiUser, *certFile, *keyFile, *caFile, *targetUrl, *insecure) driverConfig := executor.DriverConfig{ Executor: httpMirrorExecutor, } driver, err := executor.NewMesosExecutorDriver(driverConfig) server := &ExecutorHTTPServer{httpMirrorExecutor} go server.Start() if err != nil { fmt.Println("Unable to create a ExecutorDriver ", err.Error()) } _, err = driver.Start() if err != nil { fmt.Println("Got error:", err) return } fmt.Println("Executor process has started and running.") driver.Join() }
func main() { flag.Parse() err := framework.InitLogging(*logLevel) if err != nil { fmt.Println(err) os.Exit(1) } var taskExecutor executor.Executor switch *executorType { case framework.TaskTypeMirrorMaker: taskExecutor = framework.NewMirrorMakerExecutor() default: { framework.Logger.Errorf("Unknown executor type %s", *executorType) os.Exit(1) } } driverConfig := executor.DriverConfig{ Executor: taskExecutor, } driver, err := executor.NewMesosExecutorDriver(driverConfig) if err != nil { framework.Logger.Error(err) os.Exit(1) } _, err = driver.Start() if err != nil { framework.Logger.Error(err) os.Exit(1) } driver.Join() }
func (ks *KubeletExecutorServer) createAndInitKubelet( kc *app.KubeletConfig, hks hyperkube.Interface, clientConfig *client.Config, ) (app.KubeletBootstrap, *kconfig.PodConfig, error) { // TODO(k8s): block until all sources have delivered at least one update to the channel, or break the sync loop // up into "per source" synchronizations // TODO(k8s): KubeletConfig.KubeClient should be a client interface, but client interface misses certain methods // used by kubelet. Since NewMainKubelet expects a client interface, we need to make sure we are not passing // a nil pointer to it when what we really want is a nil interface. var kubeClient client.Interface if kc.KubeClient == nil { kubeClient = nil } else { kubeClient = kc.KubeClient } gcPolicy := kubelet.ContainerGCPolicy{ MinAge: kc.MinimumGCAge, MaxPerPodContainer: kc.MaxPerPodContainerCount, MaxContainers: kc.MaxContainerCount, } pc := kconfig.NewPodConfig(kconfig.PodConfigNotificationIncremental, kc.Recorder) updates := pc.Channel(MESOS_CFG_SOURCE) klet, err := kubelet.NewMainKubelet( kc.Hostname, kc.NodeName, kc.DockerClient, kubeClient, kc.RootDirectory, kc.PodInfraContainerImage, kc.SyncFrequency, float32(kc.RegistryPullQPS), kc.RegistryBurst, kc.EventRecordQPS, kc.EventBurst, gcPolicy, pc.SeenAllSources, kc.RegisterNode, kc.StandaloneMode, kc.ClusterDomain, net.IP(kc.ClusterDNS), kc.MasterServiceNamespace, kc.VolumePlugins, kc.NetworkPlugins, kc.NetworkPluginName, kc.StreamingConnectionIdleTimeout, kc.Recorder, kc.CAdvisorInterface, kc.ImageGCPolicy, kc.DiskSpacePolicy, kc.Cloud, kc.NodeStatusUpdateFrequency, kc.ResourceContainer, kc.OSInterface, kc.CgroupRoot, kc.ContainerRuntime, kc.RktPath, kc.RktStage1Image, kc.Mounter, kc.Writer, kc.DockerDaemonContainer, kc.SystemContainer, kc.ConfigureCBR0, kc.PodCIDR, kc.MaxPods, kc.DockerExecHandler, kc.ResolverConfig, kc.CPUCFSQuota, &api.NodeDaemonEndpoints{ KubeletEndpoint: api.DaemonEndpoint{Port: int(kc.Port)}, }, kc.OOMAdjuster, ) if err != nil { return nil, nil, err } //TODO(jdef) either configure Watch here with something useful, or else // get rid of it from executor.Config kubeletFinished := make(chan struct{}) staticPodsConfigPath := filepath.Join(kc.RootDirectory, "static-pods") exec := executor.New(executor.Config{ Kubelet: klet, Updates: updates, SourceName: MESOS_CFG_SOURCE, APIClient: kc.KubeClient, Docker: kc.DockerClient, SuicideTimeout: ks.SuicideTimeout, LaunchGracePeriod: ks.LaunchGracePeriod, KubeletFinished: kubeletFinished, ExitFunc: os.Exit, PodStatusFunc: func(_ executor.KubeletInterface, pod *api.Pod) (*api.PodStatus, error) { return klet.GetRuntime().GetPodStatus(pod) }, StaticPodsConfigPath: staticPodsConfigPath, PodLW: cache.NewListWatchFromClient(kc.KubeClient, "pods", api.NamespaceAll, fields.OneTermEqualSelector(client.PodHost, kc.NodeName)), }) go exec.InitializeStaticPodsSource(func() { // Create file source only when we are called back. Otherwise, it is never marked unseen. fileSourceUpdates := pc.Channel(kubelet.FileSource) kconfig.NewSourceFile(staticPodsConfigPath, kc.Hostname, kc.FileCheckFrequency, fileSourceUpdates) }) k := &kubeletExecutor{ Kubelet: klet, address: ks.Address, dockerClient: kc.DockerClient, hks: hks, kubeletFinished: kubeletFinished, executorDone: exec.Done(), clientConfig: clientConfig, } dconfig := bindings.DriverConfig{ Executor: exec, HostnameOverride: ks.HostnameOverride, BindingAddress: ks.Address, } if driver, err := bindings.NewMesosExecutorDriver(dconfig); err != nil { log.Fatalf("failed to create executor driver: %v", err) } else { k.driver = driver } log.V(2).Infof("Initialize executor driver...") k.BirthCry() exec.Init(k.driver) k.StartGarbageCollection() return k, pc, nil }
func (s *KubeletExecutorServer) runExecutor(execUpdates chan<- kubetypes.PodUpdate, nodeInfos chan<- executor.NodeInfo, kubeletFinished <-chan struct{}, staticPodsConfigPath string, apiclient *client.Client) error { exec := executor.New(executor.Config{ Updates: execUpdates, APIClient: apiclient, Docker: dockertools.ConnectToDockerOrDie(s.DockerEndpoint), SuicideTimeout: s.SuicideTimeout, KubeletFinished: kubeletFinished, ExitFunc: os.Exit, PodStatusFunc: func(pod *api.Pod) (*api.PodStatus, error) { s.kletLock.Lock() defer s.kletLock.Unlock() if s.klet == nil { return nil, fmt.Errorf("PodStatucFunc called before kubelet is initialized") } status, err := s.klet.GetRuntime().GetPodStatus(pod) if err != nil { return nil, err } status.Phase = kubelet.GetPhase(&pod.Spec, status.ContainerStatuses) hostIP, err := s.klet.GetHostIP() if err != nil { log.Errorf("Cannot get host IP: %v", err) } else { status.HostIP = hostIP.String() } return status, nil }, StaticPodsConfigPath: staticPodsConfigPath, PodLW: cache.NewListWatchFromClient(apiclient, "pods", api.NamespaceAll, fields.OneTermEqualSelector(client.PodHost, s.HostnameOverride), ), NodeInfos: nodeInfos, }) // initialize driver and initialize the executor with it dconfig := bindings.DriverConfig{ Executor: exec, HostnameOverride: s.HostnameOverride, BindingAddress: s.Address, } driver, err := bindings.NewMesosExecutorDriver(dconfig) if err != nil { return fmt.Errorf("failed to create executor driver: %v", err) } log.V(2).Infof("Initialize executor driver...") exec.Init(driver) // start the driver go func() { if _, err := driver.Run(); err != nil { log.Fatalf("executor driver failed: %v", err) } log.Info("executor Run completed") }() return nil }
func (ks *QingletExecutorServer) createAndInitQinglet( kc *app.QingletConfig, hks hyperqing.Interface, clientConfig *client.Config, shutdownCloser io.Closer, ) (app.QingletBootstrap, *kconfig.PodConfig, error) { // TODO(k8s): block until all sources have delivered at least one update to the channel, or break the sync loop // up into "per source" synchronizations // TODO(k8s): QingletConfig.QingClient should be a client interface, but client interface misses certain methods // used by qinglet. Since NewMainQinglet expects a client interface, we need to make sure we are not passing // a nil pointer to it when what we really want is a nil interface. var qingClient client.Interface if kc.QingClient == nil { qingClient = nil } else { qingClient = kc.QingClient } gcPolicy := qinglet.ContainerGCPolicy{ MinAge: kc.MinimumGCAge, MaxPerPodContainer: kc.MaxPerPodContainerCount, MaxContainers: kc.MaxContainerCount, } pc := kconfig.NewPodConfig(kconfig.PodConfigNotificationSnapshotAndUpdates, kc.Recorder) updates := pc.Channel(MESOS_CFG_SOURCE) klet, err := qinglet.NewMainQinglet( kc.Hostname, kc.NodeName, kc.DockerClient, qingClient, kc.RootDirectory, kc.PodInfraContainerImage, kc.SyncFrequency, float32(kc.RegistryPullQPS), kc.RegistryBurst, gcPolicy, pc.SeenAllSources, kc.RegisterNode, kc.StandaloneMode, kc.ClusterDomain, net.IP(kc.ClusterDNS), kc.MasterServiceNamespace, kc.VolumePlugins, kc.NetworkPlugins, kc.NetworkPluginName, kc.StreamingConnectionIdleTimeout, kc.Recorder, kc.CadvisorInterface, kc.ImageGCPolicy, kc.DiskSpacePolicy, kc.Cloud, kc.NodeStatusUpdateFrequency, kc.ResourceContainer, kc.OSInterface, kc.CgroupRoot, kc.ContainerRuntime, kc.Mounter, kc.DockerDaemonContainer, kc.SystemContainer, kc.ConfigureCBR0, kc.PodCIDR, kc.MaxPods, kc.DockerExecHandler, ) if err != nil { return nil, nil, err } //TODO(jdef) either configure Watch here with something useful, or else // get rid of it from executor.Config qingletFinished := make(chan struct{}) staticPodsConfigPath := filepath.Join(kc.RootDirectory, "static-pods") exec := executor.New(executor.Config{ Qinglet: klet, Updates: updates, SourceName: MESOS_CFG_SOURCE, APIClient: kc.QingClient, Docker: kc.DockerClient, SuicideTimeout: ks.SuicideTimeout, QingletFinished: qingletFinished, ShutdownAlert: func() { if shutdownCloser != nil { if e := shutdownCloser.Close(); e != nil { log.Warningf("failed to signal shutdown to external watcher: %v", e) } } }, ExitFunc: os.Exit, PodStatusFunc: func(_ executor.QingletInterface, pod *api.Pod) (*api.PodStatus, error) { return klet.GetRuntime().GetPodStatus(pod) }, StaticPodsConfigPath: staticPodsConfigPath, }) go exec.InitializeStaticPodsSource(func() { // Create file source only when we are called back. Otherwise, it is never marked unseen. fileSourceUpdates := pc.Channel(qinglet.FileSource) kconfig.NewSourceFile(staticPodsConfigPath, kc.Hostname, kc.FileCheckFrequency, fileSourceUpdates) }) k := &qingletExecutor{ Qinglet: klet, runProxy: ks.RunProxy, proxyLogV: ks.ProxyLogV, proxyExec: ks.ProxyExec, proxyLogfile: ks.ProxyLogfile, proxyBindall: ks.ProxyBindall, address: ks.Address, dockerClient: kc.DockerClient, hks: hks, qingletFinished: qingletFinished, executorDone: exec.Done(), clientConfig: clientConfig, } dconfig := bindings.DriverConfig{ Executor: exec, HostnameOverride: ks.HostnameOverride, BindingAddress: net.IP(ks.Address), } if driver, err := bindings.NewMesosExecutorDriver(dconfig); err != nil { log.Fatalf("failed to create executor driver: %v", err) } else { k.driver = driver } log.V(2).Infof("Initialize executor driver...") k.BirthCry() exec.Init(k.driver) k.StartGarbageCollection() return k, pc, nil }