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
}