int main(int argc, char** argv)
{
GOOGLE_PROTOBUF_VERIFY_VERSION;
Flags flags;
Try<flags::Warnings> load = flags.load(None(), argc, argv);
if (load.isError()) {
cerr << flags.usage(load.error()) << endl;
return EXIT_FAILURE;
}
if (flags.help) {
cout << flags.usage() << endl;
return EXIT_SUCCESS;
}
// Log any flag warnings.
foreach (const flags::Warning& warning, load->warnings) {
LOG(WARNING) << warning.message;
}
if (flags.pid.isNone()) {
cerr << flags.usage("Missing required option --pid") << endl;
return EXIT_FAILURE;
}
Try<ResourceStatistics> statistics = mesos::internal::usage(flags.pid.get());
if (statistics.isError()) {
cerr << "Failed to get usage: " << statistics.error() << endl;
return EXIT_FAILURE;
}
if (flags.recordio) {
Try<Nothing> write = protobuf::write(STDOUT_FILENO, statistics.get());
if (write.isError()) {
cerr << "Failed to write record: " << write.error() << endl;
return EXIT_FAILURE;
}
} else {
cout << stringify(JSON::protobuf(statistics.get())) << endl;
}
return EXIT_SUCCESS;
}
int main(int argc, char** argv)
{
Flags flags;
// Load and validate flags from the environment and command line.
Try<flags::Warnings> load = flags.load(None(), &argc, &argv);
if (load.isError()) {
EXIT(EXIT_FAILURE) << flags.usage(load.error());
}
// Log any flag warnings.
foreach (const flags::Warning& warning, load->warnings) {
LOG(WARNING) << warning.message;
}
// Make sure this process is running in its own session.
// This ensures that, if the parent process (presumably the Mesos agent)
// terminates, this logger process will continue to run.
if (::setsid() == -1) {
EXIT(EXIT_FAILURE)
<< ErrnoError("Failed to put child in a new session").message;
}
// Asynchronously control the flow and size of logs.
LogrotateLoggerProcess process(flags);
spawn(&process);
// Wait for the logging process to finish.
Future<Nothing> status = dispatch(process, &LogrotateLoggerProcess::run);
status.await();
terminate(process);
wait(process);
return status.isReady() ? EXIT_SUCCESS : EXIT_FAILURE;
}
int main(int argc, char** argv)
{
GOOGLE_PROTOBUF_VERIFY_VERSION;
Flags flags;
Try<flags::Warnings> load = flags.load(None(), argc, argv);
if (load.isError()) {
cerr << flags.usage(load.error()) << endl;
return EXIT_FAILURE;
}
if (flags.help) {
cout << flags.usage() << endl;
return EXIT_SUCCESS;
}
// Log any flag warnings.
foreach (const flags::Warning& warning, load->warnings) {
LOG(WARNING) << warning.message;
}
if (flags.health_check_json.isNone()) {
cerr << flags.usage("Expected JSON with health check description") << endl;
return EXIT_FAILURE;
}
Try<JSON::Object> parse =
JSON::parse<JSON::Object>(flags.health_check_json.get());
if (parse.isError()) {
cerr << flags.usage("Failed to parse --health_check_json: " + parse.error())
<< endl;
return EXIT_FAILURE;
}
Try<HealthCheck> check = protobuf::parse<HealthCheck>(parse.get());
if (check.isError()) {
cerr << flags.usage("Failed to parse --health_check_json: " + check.error())
<< endl;
return EXIT_SUCCESS;
}
if (flags.executor.isNone()) {
cerr << flags.usage("Missing required option --executor") << endl;
return EXIT_FAILURE;
}
if (check.get().has_http() && check.get().has_command()) {
cerr << flags.usage("Both 'http' and 'command' health check requested")
<< endl;
return EXIT_FAILURE;
}
if (!check.get().has_http() && !check.get().has_command()) {
cerr << flags.usage("Expecting one of 'http' or 'command' health check")
<< endl;
return EXIT_FAILURE;
}
if (flags.task_id.isNone()) {
cerr << flags.usage("Missing required option --task_id") << endl;
return EXIT_FAILURE;
}
TaskID taskID;
taskID.set_value(flags.task_id.get());
mesos::internal::HealthCheckerProcess process(
check.get(),
flags.executor.get(),
taskID);
process::spawn(&process);
process::Future<Nothing> checking =
process::dispatch(
process, &mesos::internal::HealthCheckerProcess::healthCheck);
checking.await();
process::terminate(process);
process::wait(process);
if (checking.isFailed()) {
LOG(WARNING) << "Health check failed " << checking.failure();
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int main(int argc, char** argv)
{
Flags flags;
Try<flags::Warnings> load = flags.load("MESOS_EXAMPLE_", argc, argv);
if (load.isError()) {
std::cerr << flags.usage(load.error()) << std::endl;
return EXIT_FAILURE;
}
if (flags.help) {
std::cout << flags.usage() << std::endl;
return EXIT_SUCCESS;
}
mesos::internal::logging::initialize(argv[0], false);
// Log any flag warnings (after logging is initialized).
foreach (const flags::Warning& warning, load->warnings) {
LOG(WARNING) << warning.message;
}
if (flags.qps <= 0.0) {
EXIT(EXIT_FAILURE) << "Flag '--qps' needs to be greater than zero";
}
LoadGeneratorScheduler scheduler(flags.qps, flags.duration);
FrameworkInfo framework;
framework.set_user(""); // Have Mesos fill in the current user.
framework.set_principal(flags.principal);
framework.set_name(FRAMEWORK_NAME);
framework.set_checkpoint(flags.checkpoint);
framework.add_roles(flags.role);
framework.add_capabilities()->set_type(
FrameworkInfo::Capability::RESERVATION_REFINEMENT);
framework.set_checkpoint(flags.checkpoint);
if (flags.master == "local") {
// Configure master.
os::setenv("MESOS_ROLES", flags.role);
os::setenv("MESOS_AUTHENTICATE_FRAMEWORKS", stringify(flags.authenticate));
ACLs acls;
ACL::RegisterFramework* acl = acls.add_register_frameworks();
acl->mutable_principals()->set_type(ACL::Entity::ANY);
acl->mutable_roles()->add_values("*");
os::setenv("MESOS_ACLS", stringify(JSON::protobuf(acls)));
}
MesosSchedulerDriver* driver;
if (flags.authenticate) {
LOG(INFO) << "Enabling authentication for the framework";
Credential credential;
credential.set_principal(flags.principal);
if (flags.secret.isSome()) {
credential.set_secret(flags.secret.get());
}
driver = new MesosSchedulerDriver(
&scheduler,
framework,
flags.master,
credential);
} else {
driver = new MesosSchedulerDriver(
&scheduler,
framework,
flags.master);
}
int status = driver->run() == DRIVER_STOPPED ? EXIT_SUCCESS : EXIT_FAILURE;
// Ensure that the driver process terminates.
driver->stop();
delete driver;
return status;
}
int main(int argc, char** argv)
{
Flags flags;
Try<Nothing> load = flags.load("MESOS_", argc, argv);
if (load.isError()) {
cerr << flags.usage(load.error()) << endl;
return EXIT_FAILURE;
}
if (flags.help) {
cout << flags.usage() << endl;
return EXIT_SUCCESS;
}
if (flags.master.isNone()) {
cerr << flags.usage( "Missing required option --master") << endl;
return EXIT_FAILURE;
}
if (flags.qps.isNone()) {
cerr << flags.usage("Missing required option --qps") << endl;
return EXIT_FAILURE;
}
if (flags.qps.get() <= 0) {
cerr << flags.usage("--qps needs to be greater than zero") << endl;
return EXIT_FAILURE;
}
// We want the logger to catch failure signals.
mesos::internal::logging::initialize(argv[0], flags, true);
LoadGeneratorScheduler scheduler(flags.qps.get(), flags.duration);
FrameworkInfo framework;
framework.set_user(""); // Have Mesos fill in the current user.
framework.set_name("Load Generator Framework (C++)");
const Option<string> checkpoint = os::getenv("MESOS_CHECKPOINT");
if (checkpoint.isSome()) {
framework.set_checkpoint(
numify<bool>(checkpoint.get()).get());
}
MesosSchedulerDriver* driver;
if (flags.authenticate) {
cout << "Enabling authentication for the framework" << endl;
if (flags.secret.isNone()) {
cerr << "Expecting --secret when --authenticate is set" << endl;
return EXIT_FAILURE;
}
string secret = flags.secret.get();
Credential credential;
credential.set_principal(flags.principal);
credential.set_secret(strings::trim(secret));
framework.set_principal(flags.principal);
driver = new MesosSchedulerDriver(
&scheduler, framework, flags.master.get(), credential);
} else {
framework.set_principal(flags.principal);
driver = new MesosSchedulerDriver(
&scheduler, framework, flags.master.get());
}
int status = driver->run() == DRIVER_STOPPED ? EXIT_SUCCESS : EXIT_SUCCESS;
// Ensure that the driver process terminates.
driver->stop();
delete driver;
return status;
}
int main(int argc, char** argv)
{
Flags flags;
flags.setUsageMessage("Usage: " + Path(argv[0]).basename() + " <master>");
// Load flags from environment and command line, and remove
// them from argv.
Try<flags::Warnings> load = flags.load(None(), &argc, &argv);
if (flags.help) {
cout << flags.usage() << endl;
return EXIT_SUCCESS;
}
if (load.isError()) {
cerr << flags.usage(load.error()) << endl;
return EXIT_FAILURE;
}
// Log any flag warnings.
foreach (const flags::Warning& warning, load->warnings) {
cerr << warning.message << endl;
}
// 'master' argument must be the only argument left after parsing.
if (argc != 2) {
cerr << flags.usage("There must be only one argument: <master>") << endl;
return EXIT_FAILURE;
}
string master = argv[1];
Try<mesos::master::detector::MasterDetector*> detector =
mesos::master::detector::MasterDetector::create(master);
if (detector.isError()) {
cerr << "Failed to create a master detector: " << detector.error() << endl;
return EXIT_FAILURE;
}
Future<Option<MasterInfo>> masterInfo = detector.get()->detect();
if (!masterInfo.await(flags.timeout)) {
cerr << "Failed to detect master from '" << master
<< "' within " << flags.timeout << endl;
return -1;
} else {
CHECK(!masterInfo.isDiscarded());
if (masterInfo.isFailed()) {
cerr << "Failed to detect master from '" << master
<< "': " << masterInfo.failure() << endl;
return EXIT_FAILURE;
}
}
// The future is not satisfied unless the result is Some.
CHECK_SOME(masterInfo.get());
cout << strings::remove(masterInfo.get().get().pid(), "master@") << endl;
return EXIT_SUCCESS;
}