// Ensures that the driver can handle the SUBSCRIBED event.
TEST_F(SchedulerDriverEventTest, Subscribed)
{
Try<Owned<cluster::Master>> master = StartMaster();
ASSERT_SOME(master);
FrameworkInfo frameworkInfo = DEFAULT_FRAMEWORK_INFO;
frameworkInfo.set_failover_timeout(Weeks(2).secs());
// Make sure the initial registration calls 'registered'.
MockScheduler sched;
MesosSchedulerDriver driver(
&sched, frameworkInfo, master.get()->pid, DEFAULT_CREDENTIAL);
// Intercept the registration message, send a SUBSCRIBED instead.
Future<Message> frameworkRegisteredMessage =
DROP_MESSAGE(Eq(FrameworkRegisteredMessage().GetTypeName()), _, _);
// Ensure that there will be no (re-)registration retries
// from the scheduler driver.
Clock::pause();
driver.start();
AWAIT_READY(frameworkRegisteredMessage);
UPID frameworkPid = frameworkRegisteredMessage.get().to;
FrameworkRegisteredMessage message;
ASSERT_TRUE(message.ParseFromString(frameworkRegisteredMessage.get().body));
FrameworkID frameworkId = message.framework_id();
frameworkInfo.mutable_id()->CopyFrom(frameworkId);
Event event;
event.set_type(Event::SUBSCRIBED);
event.mutable_subscribed()->mutable_framework_id()->CopyFrom(frameworkId);
Future<Nothing> registered;
EXPECT_CALL(sched, registered(&driver, frameworkId, _))
.WillOnce(FutureSatisfy(®istered));
process::post(master.get()->pid, frameworkPid, event);
AWAIT_READY(registered);
driver.stop();
driver.join();
}
// Ensures that the driver can handle the SUBSCRIBED event
// after a master failover.
TEST_F(SchedulerDriverEventTest, SubscribedMasterFailover)
{
Try<PID<Master>> master = StartMaster();
ASSERT_SOME(master);
FrameworkInfo frameworkInfo = DEFAULT_FRAMEWORK_INFO;
frameworkInfo.set_failover_timeout(Weeks(2).secs());
// Make sure the initial registration calls 'registered'.
MockScheduler sched;
StandaloneMasterDetector detector(master.get());
TestingMesosSchedulerDriver driver(&sched, &detector, frameworkInfo);
// Intercept the registration message, send a SUBSCRIBED instead.
Future<Message> frameworkRegisteredMessage =
DROP_MESSAGE(Eq(FrameworkRegisteredMessage().GetTypeName()), _, _);
// Ensure that there will be no (re-)registration retries
// from the scheduler driver.
Clock::pause();
driver.start();
AWAIT_READY(frameworkRegisteredMessage);
UPID frameworkPid = frameworkRegisteredMessage.get().to;
FrameworkRegisteredMessage message;
ASSERT_TRUE(message.ParseFromString(frameworkRegisteredMessage.get().body));
FrameworkID frameworkId = message.framework_id();
frameworkInfo.mutable_id()->CopyFrom(frameworkId);
Event event;
event.set_type(Event::SUBSCRIBED);
event.mutable_subscribed()->mutable_framework_id()->CopyFrom(frameworkId);
Future<Nothing> registered;
EXPECT_CALL(sched, registered(&driver, frameworkId, _))
.WillOnce(FutureSatisfy(®istered));
process::post(master.get(), frameworkPid, event);
AWAIT_READY(registered);
// Fail over the master and expect a 'reregistered' call.
// Note that the master sends a registered message for
// this case (see MESOS-786).
Stop(master.get());
master = StartMaster();
ASSERT_SOME(master);
EXPECT_CALL(sched, disconnected(&driver));
frameworkRegisteredMessage =
DROP_MESSAGE(Eq(FrameworkRegisteredMessage().GetTypeName()), _, _);
detector.appoint(master.get());
AWAIT_READY(frameworkRegisteredMessage);
Future<Nothing> reregistered;
EXPECT_CALL(sched, reregistered(&driver, _))
.WillOnce(FutureSatisfy(&reregistered));
process::post(master.get(), frameworkPid, event);
AWAIT_READY(reregistered);
}
int main(int argc, char** argv)
{
string master = MASTER;
string k3binary;
string paramfile;
int total_peers;
YAML::Node k3vars;
// Parse Command Line options
string path = os::realpath(dirname(argv[0])).get();
namespace po = boost::program_options;
vector <string> optionalVars;
po::options_description desc("K3 Run options");
desc.add_options()
("program", po::value<string>(&k3binary)->required(), "K3 executable program filename")
("numpeers", po::value<int>(&total_peers)->required(), "# of K3 Peers to launch")
("help,h", "Print help message")
("param,p", po::value<string>(¶mfile)->required(), "YAML Formatted input file");
po::positional_options_description positionalOptions;
positionalOptions.add("program", 1);
positionalOptions.add("numpeers", 1);
po::variables_map vm;
try {
po::store(po::command_line_parser(argc, argv).options(desc)
.positional(positionalOptions).run(), vm);
if (vm.count("help") || vm.empty()) {
cout << "K3 Distributed program framework backed by Mesos cluser" << endl;
cout << desc << endl;
return 0;
}
po::notify(vm);
k3vars = YAML::LoadFile(paramfile);
}
catch (boost::program_options::required_option& e) {
cerr << " ERROR: " << e.what() << endl << endl;
cout << desc << endl;
return 1;
}
catch (boost::program_options::error& e) {
cerr << " ERROR: " << e.what() << endl << endl;
cout << desc << endl;
return 1;
}
KDScheduler scheduler(k3binary, total_peers, k3vars, path);
FrameworkInfo framework;
framework.set_user(""); // Have Mesos fill in the current user.
framework.set_name(k3binary + "-" + stringify(total_peers));
framework.mutable_id()->set_value(k3binary);
if (os::hasenv("MESOS_CHECKPOINT")) {
cout << "Enabling checkpoint for the framework" << endl;
framework.set_checkpoint(true);
}
MesosSchedulerDriver* driver;
if (os::hasenv("MESOS_AUTHENTICATE")) {
cout << "Enabling authentication for the framework" << endl;
if (!os::hasenv("DEFAULT_PRINCIPAL")) {
EXIT(1) << "Expecting authentication principal in the environment";
}
if (!os::hasenv("DEFAULT_SECRET")) {
EXIT(1) << "Expecting authentication secret in the environment";
}
Credential credential;
credential.set_principal(getenv("DEFAULT_PRINCIPAL"));
credential.set_secret(getenv("DEFAULT_SECRET"));
framework.set_principal(getenv("DEFAULT_PRINCIPAL"));
driver = new MesosSchedulerDriver(
&scheduler, framework, master, credential);
} else {
framework.set_principal("k3-docker-no-executor-framework-cpp");
driver = new MesosSchedulerDriver(&scheduler, framework, master);
}
int status = driver->run() == DRIVER_STOPPED ? 0 : 1;
// Ensure that the driver process terminates.
driver->stop();
delete driver;
return status;
}