func NewTracer(serviceName string, rate int, producer *producer.KafkaProducer, ip string, port int16, topic string) *Tracer { log.Infof("[Zipkin] Creating new tracer for service %s with rate 1:%d, topic %s, ip %s, port %d", serviceName, rate, topic, ip, port) collector := &KafkaCollector{producer: producer, topic: topic} convertedIp, err := convertIp(ip) if err != nil { log.Warningf("Given ip %s is not a valid ipv4 ip address, going with localhost ip") convertedIp = &localhost } tracer := &Tracer{ip: *convertedIp, port: port, collector: collector, rate: rate, serviceName: serviceName} return tracer }
func (sc *ServerCommand) connectMarathon(url string, retries int, backoff time.Duration) (marathon.Marathon, error) { var err error var marathonClient marathon.Marathon for i := 0; i < retries; i++ { log.Infof("Trying to connect to Marathon: attempt %d", i) marathonClient, err = sc.newMarathonClient(url) if err == nil { return marathonClient, nil } log.Debugf("Error: %s", err) time.Sleep(backoff) } return nil, err }
func (ctx *RunOnceApplicationContext) StatusUpdate(driver scheduler.SchedulerDriver, status *mesos.TaskStatus) bool { ctx.lock.Lock() defer ctx.lock.Unlock() hostname := hostnameFromTaskID(status.GetTaskId().GetValue()) ctx.updateTaskState(status) switch status.GetState() { case mesos.TaskState_TASK_RUNNING: log.Infof("Task %s received status update in state %s", status.GetTaskId().GetValue(), status.GetState().String()) case mesos.TaskState_TASK_LOST, mesos.TaskState_TASK_FAILED, mesos.TaskState_TASK_ERROR: //TODO also kill all other running tasks sometime? ctx.StatusChan <- framework.NewApplicationRunStatus(ctx.Application, fmt.Errorf("Application %s failed to run on host %s with status %s: %s", ctx.Application.ID, hostname, status.GetState().String(), status.GetMessage())) return true case mesos.TaskState_TASK_FINISHED, mesos.TaskState_TASK_KILLED: if ctx.allTasksFinished() { ctx.StatusChan <- framework.NewApplicationRunStatus(ctx.Application, nil) return true } default: log.Warningf("Got unexpected task state %s", pretty.Status(status)) } return false }
func (sc *ServerCommand) Run(args []string) int { schedulerConfig := framework.NewSchedulerConfig() var ( flags = flag.NewFlagSet("server", flag.ExitOnError) marathonURL = flags.String("marathon", "http://127.0.0.1:8080", "Marathon address <ip:port>.") persistentStorage = flags.String("storage", "", "Storage to store stack-deploy runtime information to recover from failovers. Required.") api = flags.String("api", "0.0.0.0:4200", "Stack-deploy server binding address") bootstrap = flags.String("bootstrap", "", "Stack file to bootstrap with.") cassandra = flags.String("cassandra", "127.0.0.1", "Cassandra cluster IPs, comma-separated") keyspace = flags.String("keyspace", "stack_deploy", "Cassandra keyspace") proto = flags.Int("proto", 3, "Cassandra protocol version") connectRetries = flags.Int("connect.retries", 10, "Number of retries to connect to either Marathon or Cassandra") connectBackoff = flags.Duration("connect.backoff", 10*time.Second, "Backoff between connection attempts to either Marathon or Cassandra") debug = flags.Bool("debug", false, "Flag for debug mode") dev = flags.Bool("dev", false, "Flag for developer mode") variables = make(vars) ) flags.StringVar(&schedulerConfig.Master, "master", "127.0.0.1:5050", "Mesos Master address <ip:port>.") flags.StringVar(&schedulerConfig.User, "framework.user", "", "Mesos user. Defaults to current system user.") flags.StringVar(&schedulerConfig.FrameworkName, "framework.name", "stack-deploy", "Mesos framework name. Defaults to stack-deploy.") flags.StringVar(&schedulerConfig.FrameworkRole, "framework.role", "*", "Mesos framework role. Defaults to *.") flags.DurationVar(&schedulerConfig.FailoverTimeout, "failover.timeout", 168*time.Hour, "Mesos framework failover timeout. Defaults to 1 week.") flags.Var(variables, "var", "Global variables to add to every stack context run by stack-deploy server. Multiple occurrences of this flag allowed.") flags.Parse(args) if *debug { framework.Logger = plog.NewConsoleLogger(plog.DebugLevel, plog.DefaultLogFormat) } ctrlc := make(chan os.Signal, 1) signal.Notify(ctrlc, os.Interrupt) framework.TaskRunners = sc.runners framework.MesosTaskRunners = sc.mesosRunners marathonClient, err := sc.connectMarathon(*marathonURL, *connectRetries, *connectBackoff) if err != nil { log.Fatal(err) return 1 } if *persistentStorage == "" { if !*dev { log.Fatal("--storage flag is required. Examples: 'file:stack-deploy.json', 'zk:zookeeper.service:2181/stack-deploy'") return 1 } else { *persistentStorage = "file:stack-deploy.json" } } frameworkStorage, err := framework.NewFrameworkStorage(*persistentStorage) if err != nil { log.Fatal(err) return 1 } schedulerConfig.Storage = frameworkStorage frameworkStorage.Load() scheduler := framework.NewScheduler(schedulerConfig) err = scheduler.GetMesosState().Update() if err != nil { log.Fatal(err) return 1 } if *bootstrap != "" { var context *framework.Variables if frameworkStorage.BootstrapContext != nil && len(frameworkStorage.BootstrapContext.All()) > 0 { log.Info("Restored bootstrap context from persistent storage") context = frameworkStorage.BootstrapContext } else { log.Info("No existing bootstrap context found in persistent storage, bootstrapping") var err error context, err = sc.Bootstrap(*bootstrap, marathonClient, scheduler, *connectRetries, *connectBackoff) if err != nil { log.Fatal(err) return 1 } } log.Infof("Bootstrap context: %s", context) log.Infof("Cassandra connect before resolving: %s", *cassandra) for k, v := range context.All() { *cassandra = strings.Replace(*cassandra, fmt.Sprintf("{%s}", fmt.Sprint(k)), fmt.Sprint(v), -1) } log.Infof("Cassandra connect after resolving: %s", *cassandra) frameworkStorage.BootstrapContext = context frameworkStorage.Save() } var storage framework.Storage var userStorage framework.UserStorage var stateStorage framework.StateStorage var key string if !*dev { var connection *gocql.Session var err error storage, connection, err = framework.NewCassandraStorageRetryBackoff(strings.Split(*cassandra, ","), *keyspace, *connectRetries, *connectBackoff, *proto) if err != nil { panic(err) } userStorage, key, err = framework.NewCassandraUserStorage(connection, *keyspace) if err != nil { panic(err) } stateStorage, err = framework.NewCassandraStateStorage(connection, *keyspace) if err != nil { panic(err) } } else { log.Warning("Starting in developer mode. DO NOT use this in production!") schedulerConfig.FailoverTimeout = time.Duration(0) storage = framework.NewInMemoryStorage() userStorage = new(framework.NoopUserStorage) stateStorage = framework.NewInMemoryStateStorage() } apiServer := framework.NewApiServer(*api, marathonClient, variables, storage, userStorage, stateStorage, scheduler) if key != "" { fmt.Printf("***\nAdmin user key: %s\n***\n", key) } go apiServer.Start() <-ctrlc return 0 }