func (suite *SchedulerTestSuite) TestSchdulerDriverStop_WithoutFailover() {
// Set expections and return values.
messenger := &msgTracker{Messenger: mockedMessenger()}
driver := newTestDriver(suite.T(), driverConfigMessenger(mock_scheduler.New(), suite.framework, suite.master, nil, messenger))
suite.False(driver.Running())
ch := make(chan struct{})
go func() {
defer close(ch)
stat, err := driver.Run()
suite.NoError(err)
suite.Equal(mesos.Status_DRIVER_STOPPED, stat)
}()
<-driver.Started()
suite.True(driver.Running())
suite.Equal(mesos.Status_DRIVER_RUNNING, driver.Status())
driver.SetConnected(true) // pretend that we're already registered
driver.Stop(false)
msg := messenger.lastMessage
suite.NotNil(msg)
_, isUnregMsg := msg.(proto.Message)
suite.True(isUnregMsg, "expected UnregisterFrameworkMessage instead of %+v", msg)
suite.False(driver.Running())
suite.Equal(mesos.Status_DRIVER_STOPPED, driver.Status())
<-ch
}
func (suite *SchedulerTestSuite) TestSchdulerDriverStop_WithFailover() {
// Set expections and return values.
mess := &msgTracker{Messenger: mockedMessenger()}
d := DriverConfig{
Scheduler: mock_scheduler.New(),
Framework: suite.framework,
Master: suite.master,
NewMessenger: func() (messenger.Messenger, error) { return mess, nil },
NewDetector: func() (detector.Master, error) { return nil, nil },
}
driver := newTestDriver(suite.T(), d)
suite.False(driver.Running())
ch := make(chan struct{})
go func() {
defer close(ch)
stat, err := driver.Run()
suite.NoError(err)
suite.Equal(mesos.Status_DRIVER_STOPPED, stat)
}()
<-driver.Started()
driver.SetConnected(true) // simulated
suite.True(driver.Running())
driver.Stop(true) // true = scheduler failover
msg := mess.lastMessage
// we're expecting that lastMessage is nil because when failing over there's no
// 'unregister' message sent by the scheduler.
suite.Nil(msg)
suite.False(driver.Running())
suite.Equal(mesos.Status_DRIVER_STOPPED, driver.Status())
<-ch
}
func (suite *SchedulerTestSuite) TestSchedulerDriverStartWithRegistrationFailure() {
sched := mock_scheduler.New()
sched.On("Error").Return()
// Set expections and return values.
messenger := mock_messenger.NewMessenger()
messenger.On("Start").Return(nil)
messenger.On("UPID").Return(upid.UPID{})
messenger.On("Stop").Return(nil)
messenger.On("Install").Return(nil)
driver := newTestDriver(suite.T(), driverConfigMessenger(sched, suite.framework, suite.master, nil, messenger))
// reliable registration loops until the driver is stopped, connected, etc..
stat, err := driver.Start()
suite.NoError(err)
suite.Equal(mesos.Status_DRIVER_RUNNING, stat)
time.Sleep(5 * time.Second) // wait a bit, registration should be looping...
suite.True(driver.Running())
suite.Equal(mesos.Status_DRIVER_RUNNING, driver.Status())
// stop the driver, should not panic!
driver.Stop(false) // intentionally not failing over
suite.False(driver.Running())
suite.Equal(mesos.Status_DRIVER_STOPPED, driver.Status())
messenger.AssertExpectations(suite.T())
}
func (suite *SchedulerTestSuite) TestSchdulerDriverLaunchTasks() {
driver := newTestDriver(suite.T(), driverConfigMessenger(mock_scheduler.New(), suite.framework, suite.master, nil, mockedMessenger()))
go func() {
driver.Run()
}()
<-driver.Started()
driver.SetConnected(true) // simulated
suite.True(driver.Running())
task := util.NewTaskInfo(
"simple-task",
util.NewTaskID("simpe-task-1"),
util.NewSlaveID("slave-1"),
[]*mesos.Resource{util.NewScalarResource("mem", 400)},
)
task.Command = util.NewCommandInfo("pwd")
tasks := []*mesos.TaskInfo{task}
stat, err := driver.LaunchTasks(
[]*mesos.OfferID{{}},
tasks,
&mesos.Filters{},
)
suite.NoError(err)
suite.Equal(mesos.Status_DRIVER_RUNNING, stat)
}
func (suite *SchedulerTestSuite) TestSchedulerDriverAbort() {
driver := newTestDriver(suite.T(), driverConfigMessenger(mock_scheduler.New(), suite.framework, suite.master, nil, mockedMessenger()))
suite.False(driver.Running())
ch := make(chan struct{})
go func() {
defer close(ch)
stat, err := driver.Run()
suite.NoError(err)
suite.Equal(mesos.Status_DRIVER_ABORTED, stat)
}()
<-driver.Started()
driver.SetConnected(true) // simulated
suite.True(driver.Running())
suite.Equal(mesos.Status_DRIVER_RUNNING, driver.Status())
stat, err := driver.Abort()
suite.NoError(err)
<-driver.Stopped()
suite.False(driver.Running())
suite.Equal(mesos.Status_DRIVER_ABORTED, stat)
suite.Equal(mesos.Status_DRIVER_ABORTED, driver.Status())
log.Info("waiting for driver to stop")
<-ch
}
func TestSchedulerDriverNew(t *testing.T) {
masterAddr := "localhost:5050"
driver := newTestDriver(t, driverConfig(mock_scheduler.New(), &mesos.FrameworkInfo{}, masterAddr, nil))
user, _ := user.Current()
assert.Equal(t, user.Username, driver.Framework().GetUser())
host := util.GetHostname("")
assert.Equal(t, host, driver.Framework().GetHostname())
}
func TestSchedulerDriverNew_WithPid(t *testing.T) {
masterAddr := "[email protected]:5050"
mUpid, err := upid.Parse(masterAddr)
assert.NoError(t, err)
driver := newTestDriver(t, driverConfig(mock_scheduler.New(), &mesos.FrameworkInfo{}, masterAddr, nil))
driver.HandleMasterChanged(context.TODO(), driver.UPID(), &mesos.InternalMasterChangeDetected{Master: &mesos.MasterInfo{Pid: proto.String(mUpid.String())}})
assert.True(t, driver.MasterPID().Equal(mUpid), fmt.Sprintf("expected upid %+v instead of %+v", mUpid, driver.MasterPID()))
assert.NoError(t, err)
}
func (suite *SchedulerTestSuite) TestSchedulerDriverStopUnstarted() {
driver := newTestDriver(suite.T(), driverConfig(mock_scheduler.New(), suite.framework, suite.master, nil))
suite.False(driver.Running())
stat, err := driver.Stop(true)
suite.NotNil(err)
suite.False(driver.Running())
suite.Equal(mesos.Status_DRIVER_NOT_STARTED, stat)
}
func (suite *SchedulerTestSuite) TestSchdulerDriverReviveOffers() {
driver := newTestDriver(suite.T(), driverConfigMessenger(mock_scheduler.New(), suite.framework, suite.master, nil, mockedMessenger()))
driver.Start()
driver.SetConnected(true) // simulated
suite.Equal(mesos.Status_DRIVER_RUNNING, driver.Status())
stat, err := driver.ReviveOffers()
suite.NoError(err)
suite.Equal(mesos.Status_DRIVER_RUNNING, stat)
}
func (suite *SchedulerTestSuite) TestSchedulerDriverStartOK() {
sched := mock_scheduler.New()
driver := newTestDriver(suite.T(), driverConfigMessenger(sched, suite.framework, suite.master, nil, mockedMessenger()))
suite.False(driver.Running())
stat, err := driver.Start()
suite.NoError(err)
suite.Equal(mesos.Status_DRIVER_RUNNING, stat)
suite.True(driver.Running())
driver.Stop(true)
}
func (suite *SchedulerTestSuite) TestSchdulerDriverAcceptOffersWithError() {
sched := mock_scheduler.New()
sched.On("StatusUpdate").Return(nil)
sched.On("Error").Return()
msgr := mockedMessenger()
driver := newTestDriver(suite.T(), driverConfigMessenger(sched, suite.framework, suite.master, nil, msgr))
driver.OnDispatch(func(_ context.Context, _ *upid.UPID, _ proto.Message) error {
return fmt.Errorf("Unable to send message")
})
go func() {
driver.Run()
}()
<-driver.Started()
driver.SetConnected(true) // simulated
suite.True(driver.Running())
// setup an offer
offer := util.NewOffer(
util.NewOfferID("test-offer-001"),
suite.framework.Id,
util.NewSlaveID("test-slave-001"),
"test-slave(1)@localhost:5050",
)
pid, err := upid.Parse("test-slave(1)@localhost:5050")
suite.NoError(err)
driver.CacheOffer(offer, pid)
// launch task
task := util.NewTaskInfo(
"simple-task",
util.NewTaskID("simpe-task-1"),
util.NewSlaveID("test-slave-001"),
[]*mesos.Resource{util.NewScalarResourceWithReservation("mem", 400, "principal", "role")},
)
task.Command = util.NewCommandInfo("pwd")
task.Executor = util.NewExecutorInfo(util.NewExecutorID("test-exec"), task.Command)
tasks := []*mesos.TaskInfo{task}
operations := []*mesos.Offer_Operation{util.NewLaunchOperation(tasks)}
stat, err := driver.AcceptOffers(
[]*mesos.OfferID{offer.Id},
operations,
&mesos.Filters{},
)
suite.Equal(mesos.Status_DRIVER_RUNNING, stat)
suite.Error(err)
}
func (suite *SchedulerTestSuite) TestSchdulerDriverKillTask() {
driver := newTestDriver(suite.T(), driverConfigMessenger(mock_scheduler.New(), suite.framework, suite.master, nil, mockedMessenger()))
go func() {
driver.Run()
}()
<-driver.Started()
driver.SetConnected(true) // simulated
suite.True(driver.Running())
stat, err := driver.KillTask(util.NewTaskID("test-task-1"))
suite.NoError(err)
suite.Equal(mesos.Status_DRIVER_RUNNING, stat)
}
func (suite *SchedulerTestSuite) TestSchdulerDriverReconcileTasks() {
driver := newTestDriver(suite.T(), driverConfigMessenger(mock_scheduler.New(), suite.framework, suite.master, nil, mockedMessenger()))
driver.Start()
driver.SetConnected(true) // simulated
suite.Equal(mesos.Status_DRIVER_RUNNING, driver.Status())
stat, err := driver.ReconcileTasks(
[]*mesos.TaskStatus{
util.NewTaskStatus(util.NewTaskID("test-task-001"), mesos.TaskState_TASK_FINISHED),
},
)
suite.NoError(err)
suite.Equal(mesos.Status_DRIVER_RUNNING, stat)
}
func (suite *SchedulerTestSuite) TestSchdulerDriverSendFrameworkMessage() {
driver := newTestDriver(suite.T(), driverConfigMessenger(mock_scheduler.New(), suite.framework, suite.master, nil, mockedMessenger()))
driver.Start()
driver.SetConnected(true) // simulated
suite.Equal(mesos.Status_DRIVER_RUNNING, driver.Status())
stat, err := driver.SendFrameworkMessage(
util.NewExecutorID("test-exec-001"),
util.NewSlaveID("test-slave-001"),
"Hello!",
)
suite.NoError(err)
suite.Equal(mesos.Status_DRIVER_RUNNING, stat)
}
func (suite *SchedulerTestSuite) TestSchedulerDriverErrorBeforeConnected() {
sched := mock_scheduler.New()
errorTracker := &fakeErrorScheduler{Scheduler: sched, called: make(chan struct{})}
driver := newTestDriver(suite.T(), driverConfigMessenger(errorTracker, suite.framework, suite.master, nil, mockedMessenger()))
const msg = "some random error message"
suite.False(driver.Running())
driver.Fatal(context.TODO(), msg) // this is the callback that's eventually invoked when receiving an error from the master
<-errorTracker.called
suite.Equal(msg, errorTracker.msg)
<-driver.Stopped()
suite.False(driver.Running())
suite.Equal(mesos.Status_DRIVER_ABORTED, driver.Status())
}
func (suite *SchedulerTestSuite) TestSchedulerDriverJoinOK() {
// Set expections and return values.
driver := newTestDriver(suite.T(), driverConfigMessenger(mock_scheduler.New(), suite.framework, suite.master, nil, mockedMessenger()))
suite.False(driver.Running())
stat, err := driver.Start()
suite.NoError(err)
suite.Equal(mesos.Status_DRIVER_RUNNING, stat)
suite.True(driver.Running())
testCh := make(chan mesos.Status)
go func() {
stat, _ := driver.Join()
testCh <- stat
}()
driver.Stop(true)
}
func (suite *SchedulerTestSuite) TestSchdulerDriverLaunchTasksUnstarted() {
sched := mock_scheduler.New()
sched.On("Error").Return()
// Set expections and return values.
messenger := mock_messenger.NewMessenger()
messenger.On("Route").Return(nil)
messenger.On("Install").Return(nil)
driver := newTestDriver(suite.T(), driverConfigMessenger(sched, suite.framework, suite.master, nil, messenger))
stat, err := driver.LaunchTasks(
[]*mesos.OfferID{{}},
[]*mesos.TaskInfo{},
&mesos.Filters{},
)
suite.Error(err)
suite.Equal(mesos.Status_DRIVER_NOT_STARTED, stat)
}
func (suite *SchedulerTestSuite) TestSchedulerDriverStartWithMessengerFailure() {
sched := mock_scheduler.New()
sched.On("Error").Return()
messenger := mock_messenger.NewMessenger()
messenger.On("Start").Return(fmt.Errorf("Failed to start messenger"))
messenger.On("Stop").Return(nil)
messenger.On("Install").Return(nil)
driver := newTestDriver(suite.T(), driverConfigMessenger(sched, suite.framework, suite.master, nil, messenger))
suite.False(driver.Running())
stat, err := driver.Start()
suite.Error(err)
suite.False(driver.Running())
suite.False(driver.Connected())
suite.Equal(mesos.Status_DRIVER_NOT_STARTED, driver.Status())
suite.Equal(mesos.Status_DRIVER_NOT_STARTED, stat)
}
func (suite *SchedulerTestSuite) TestSchdulerDriverRequestResources() {
driver := newTestDriver(suite.T(), driverConfigMessenger(mock_scheduler.New(), suite.framework, suite.master, nil, mockedMessenger()))
driver.Start()
driver.SetConnected(true) // simulated
suite.Equal(mesos.Status_DRIVER_RUNNING, driver.Status())
stat, err := driver.RequestResources(
[]*mesos.Request{
{
SlaveId: util.NewSlaveID("test-slave-001"),
Resources: []*mesos.Resource{
util.NewScalarResource("test-res-001", 33.00),
},
},
},
)
suite.NoError(err)
suite.Equal(mesos.Status_DRIVER_RUNNING, stat)
}
func (suite *SchedulerTestSuite) TestSchedulerDriverRun() {
// Set expections and return values.
driver := newTestDriver(suite.T(), driverConfigMessenger(mock_scheduler.New(), suite.framework, suite.master, nil, mockedMessenger()))
suite.False(driver.Running())
ch := make(chan struct{})
go func() {
defer close(ch)
stat, err := driver.Run()
suite.NoError(err)
suite.Equal(mesos.Status_DRIVER_STOPPED, stat)
}()
<-driver.Started()
suite.True(driver.Running())
suite.Equal(mesos.Status_DRIVER_RUNNING, driver.Status())
// close it all.
driver.Stop(true)
<-ch
}
func (suite *SchedulerTestSuite) TestSchdulerDriverAcceptOffers() {
driver := newTestDriver(suite.T(), driverConfigMessenger(mock_scheduler.New(), suite.framework, suite.master, nil, mockedMessenger()))
go func() {
driver.Run()
}()
<-driver.Started()
driver.SetConnected(true) // simulated
suite.True(driver.Running())
volumes := []*mesos.Resource{util.NewVolumeResourceWithReservation(400, "containerPath", "persistenceId", mesos.Volume_RW.Enum(), "principal", "role")}
operations := []*mesos.Offer_Operation{util.NewCreateOperation(volumes)}
stat, err := driver.AcceptOffers(
[]*mesos.OfferID{{}},
operations,
&mesos.Filters{},
)
suite.NoError(err)
suite.Equal(mesos.Status_DRIVER_RUNNING, stat)
}
func (suite *SchedulerTestSuite) TestSchedulerDriverNew_WithFrameworkInfo_Override() {
suite.framework.Hostname = proto.String("local-host")
driver := newTestDriver(suite.T(), driverConfig(mock_scheduler.New(), suite.framework, "127.0.0.1:5050", nil))
suite.Equal(driver.Framework().GetUser(), "test-user")
suite.Equal("local-host", driver.Framework().GetHostname())
}