func init() { factory := func(ctx context.Context) transportFactoryFunc { return transportFactoryFunc(func() messenger.Messenger { parent := auth.ParentUPID(ctx) if parent == nil { log.Fatal("expected to have a parent UPID in context") } process := process.New("sasl_authenticatee") tpid := upid.UPID{ ID: process.Label(), Host: parent.Host, } return messenger.NewHttpWithBindingAddress(tpid, BindingAddressFrom(ctx)) }) } delegate := auth.AuthenticateeFunc(func(ctx context.Context, handler callback.Handler) error { if impl, err := makeAuthenticatee(handler, factory(ctx)); err != nil { return err } else { return impl.Authenticate(ctx, handler) } }) if err := auth.RegisterAuthenticateeProvider(ProviderName, delegate); err != nil { log.Error(err) } }
// NewMesosExecutorDriver creates a new mesos executor driver. func NewMesosExecutorDriver(config DriverConfig) (*MesosExecutorDriver, error) { if config.Executor == nil { msg := "Executor callback interface cannot be nil." log.Errorln(msg) return nil, fmt.Errorf(msg) } hostname := mesosutil.GetHostname(config.HostnameOverride) newMessenger := config.NewMessenger if newMessenger == nil { newMessenger = func() (messenger.Messenger, error) { process := process.New("executor") return messenger.ForHostname(process, hostname, config.BindingAddress, config.BindingPort, config.PublishedAddress) } } driver := &MesosExecutorDriver{ status: mesosproto.Status_DRIVER_NOT_STARTED, stopCh: make(chan struct{}), updates: make(map[string]*mesosproto.StatusUpdate), tasks: make(map[string]*mesosproto.TaskInfo), workDir: ".", started: make(chan struct{}), } driver.cond = sync.NewCond(&driver.lock) // decouple serialized executor callback execution from goroutines of this driver var execLock sync.Mutex driver.withExecutor = func(f func(e Executor)) { go func() { execLock.Lock() defer execLock.Unlock() f(config.Executor) }() } var err error if driver.messenger, err = newMessenger(); err != nil { return nil, err } if err = driver.init(); err != nil { log.Errorf("failed to initialize the driver: %v", err) return nil, err } return driver, nil }
// Create a new mesos scheduler driver with the given // scheduler, framework info, // master address, and credential(optional) func NewMesosSchedulerDriver(config DriverConfig) (initializedDriver *MesosSchedulerDriver, err error) { if config.Scheduler == nil { err = fmt.Errorf("Scheduler callbacks required.") } else if config.Master == "" { err = fmt.Errorf("Missing master location URL.") } else if config.Framework == nil { err = fmt.Errorf("FrameworkInfo must be provided.") } else if config.Credential != nil && config.WithAuthContext == nil { err = fmt.Errorf("WithAuthContext must be provided when Credential != nil") } if err != nil { return } framework := proto.Clone(config.Framework).(*mesos.FrameworkInfo) // set default userid if framework.GetUser() == "" { user, err := user.Current() if err != nil || user == nil { if err != nil { log.Warningf("Failed to obtain username: %v\n", err) } else { log.Warningln("Failed to obtain username.") } framework.User = proto.String("") } else { framework.User = proto.String(user.Username) } } // default hostname hostname := util.GetHostname(config.HostnameOverride) if framework.GetHostname() == "" { framework.Hostname = proto.String(hostname) } driver := &MesosSchedulerDriver{ frameworkInfo: framework, stopCh: make(chan struct{}), status: mesos.Status_DRIVER_NOT_STARTED, cache: newSchedCache(), credential: config.Credential, failover: framework.Id != nil && len(framework.Id.GetValue()) > 0, withAuthContext: config.WithAuthContext, started: make(chan struct{}), done: make(chan struct{}), } driver.withScheduler = driver.makeWithScheduler(config.Scheduler) if framework.FailoverTimeout != nil && *framework.FailoverTimeout > 0 { driver.failoverTimeout = *framework.FailoverTimeout * float64(time.Second) log.V(1).Infof("found failover_timeout = %v", time.Duration(driver.failoverTimeout)) } newDetector := config.NewDetector if newDetector == nil { newDetector = func() (detector.Master, error) { return detector.New(config.Master) } } newMessenger := config.NewMessenger if newMessenger == nil { newMessenger = func() (messenger.Messenger, error) { process := process.New("scheduler") return messenger.ForHostname(process, hostname, config.BindingAddress, config.BindingPort, config.PublishedAddress) } } // initialize new detector. if driver.masterDetector, err = newDetector(); err != nil { return } else if driver.messenger, err = newMessenger(); err != nil { return } else if err = driver.init(); err != nil { return } else { initializedDriver = driver } return }