ACTION_P2(InvokeRecoverResourcesWithFilters, allocator, timeout) { Filters filters; filters.set_refuse_seconds(timeout); allocator->real->recoverResources(arg0, arg1, arg2, filters); }
void MainWindow::on_showImageCustomFilterButton_clicked() { if(ui->spinBox_51->value() != 0) { int ** conversionMatrix; conversionMatrix = new int * [5]; for(int i = 0; i<5 ; i++) { conversionMatrix [i] = new int[5]; } conversionMatrix[0][0] = (int)ui->spinBox->value(); conversionMatrix[0][1] = (int)ui->spinBox_2->value(); conversionMatrix[0][2] = (int)ui->spinBox_3->value(); conversionMatrix[0][3] = (int)ui->spinBox_4->value(); conversionMatrix[0][4] = (int)ui->spinBox_5->value(); conversionMatrix[1][0] = (int)ui->spinBox_6->value(); conversionMatrix[1][1] = (int)ui->spinBox_7->value(); conversionMatrix[1][2] = (int)ui->spinBox_8->value(); conversionMatrix[1][3] = (int)ui->spinBox_9->value(); conversionMatrix[1][4] = (int)ui->spinBox_10->value(); conversionMatrix[2][0] = (int)ui->spinBox_11->value(); conversionMatrix[2][1] = (int)ui->spinBox_12->value(); conversionMatrix[2][2] = (int)ui->spinBox_13->value(); conversionMatrix[2][3] = (int)ui->spinBox_14->value(); conversionMatrix[2][4] = (int)ui->spinBox_15->value(); conversionMatrix[3][0] = (int)ui->spinBox_16->value(); conversionMatrix[3][1] = (int)ui->spinBox_17->value(); conversionMatrix[3][2] = (int)ui->spinBox_18->value(); conversionMatrix[3][3] = (int)ui->spinBox_19->value(); conversionMatrix[3][4] = (int)ui->spinBox_20->value(); conversionMatrix[4][0] = (int)ui->spinBox_21->value(); conversionMatrix[4][1] = (int)ui->spinBox_22->value(); conversionMatrix[4][2] = (int)ui->spinBox_23->value(); conversionMatrix[4][3] = (int)ui->spinBox_24->value(); conversionMatrix[4][4] = (int)ui->spinBox_25->value(); Filters * newFilter = new Filters(imageBefore, conversionMatrix); newFilter->setSizeMatrix(5); newFilter->customFilter(ui->spinBox_51->value(), ui->spinBox_52->value()); for(int i = 0; i<5; i++) delete []conversionMatrix[i]; delete []conversionMatrix; imageAfter = newFilter->getImageAfter(); showImageAfter(); } else { QMessageBox::information(this, tr("Wrong scale value"),tr("Scale = \"0\"! Division by 0... Format C: in 3... 2... 1...")); } }
ACTION_P2(InvokeUnusedWithFilters, allocator, timeout) { Filters filters; filters.set_refuse_seconds(timeout); process::dispatch( allocator->real, &master::allocator::AllocatorProcess::resourcesUnused, arg0, arg1, arg2, filters); }
void resourceOffers( SchedulerDriver* driver, const vector<Offer>& offers) override { LOG(INFO) << "Received " << offers.size() << " resource offers. Declining them"; Filters filters; // Refuse for eternity so Master doesn't send us the same // offers. filters.set_refuse_seconds(Duration::max().secs()); for (size_t i = 0; i < offers.size(); i++) { driver->declineOffer(offers[i].id(), filters); } }
void search_reply_push_filters(SharedPtrData reply, void *filters_json, void *filter_state_json, char **error) { #if UNITY_SCOPES_VERSION_MAJOR == 0 && (UNITY_SCOPES_VERSION_MINOR < 6 || (UNITY_SCOPES_VERSION_MINOR == 6 && UNITY_SCOPES_VERSION_MICRO < 10)) std::string errorMessage = "SearchReply.PushFilters() is only available when compiled against libunity-scopes >= 0.6.10"; *error = strdup(errorMessage.c_str()); std::cerr << errorMessage << std::endl; #else try { Variant filters_var = Variant::deserialize_json(from_gostring(filters_json)); Variant filter_state_var = Variant::deserialize_json(from_gostring(filter_state_json)); Filters filters; for (const auto &f : filters_var.get_array()) { filters.emplace_back(FilterBase::deserialize(f.get_dict())); } auto filter_state = FilterState::deserialize(filter_state_var.get_dict()); get_ptr<SearchReply>(reply)->push(filters, filter_state); } catch (const std::exception &e) { *error = strdup(e.what()); } #endif }
static void New(const v8::FunctionCallbackInfo<v8::Value>& args) { v8::Isolate* isolate = v8::Isolate::GetCurrent(); v8::HandleScope scope(isolate); // if (args.IsConstructCall()) { // Invoked as constructor: `new MyObject(...)` hid_t value = args[0]->IsUndefined() ? -1 : args[0]->ToInt32()->Value(); std::string name = args[1]->IsUndefined() ? std::string("") : std::string(*v8::String::Utf8Value (args[1]->ToString())); Filters* obj = new Filters(value, name); obj->Wrap(args.This()); args.GetReturnValue().Set(args.This()); // } else { // std::cout<<"Filters::New plain"<<std::endl; // // Invoked as plain function `MyObject(...)`, turn into construct call. // const int argc = 1; // v8::Local<v8::Value> argv[argc] = { args[0] }; // Local<v8::FunctionTemplate> cons = Local<v8::FunctionTemplate>::New(isolate, Constructor); // args.GetReturnValue().Set(cons->GetFunction()->NewInstance(argc, argv)); // } }
/* This method builds prefix tree based on the list of filter strings. Every node of the tree contains subcategory name and, optionally, logging level - if node matches complete filter string. For example, given following filters: a (error) a.b.c (trace) a.b.x (trace) aa (error) aa.b (warn) The code builds following prefix tree: | |- a (error) -- b - c (trace) | | | `-- x (trace) | `- aa (error) - b (warn) */ spark::LogHandler::LogHandler(LogLevel level, const Filters &filters) : level_(level) { for (auto it = filters.begin(); it != filters.end(); ++it) { const char* const category = it->first; const LogLevel level = it->second; std::vector<FilterData> *filters = &filters_; // Root nodes size_t pos = 0; for (size_t i = 0;; ++i) { if (category[i] && category[i] != '.') { // Category name separator continue; } const size_t size = i - pos; if (!size) { break; // Invalid category name } const char* const name = category + pos; // Use binary search to find existent node or position for new node bool found = false; auto it = std::lower_bound(filters->begin(), filters->end(), std::make_pair(name, size), [&found](const FilterData &filter, const std::pair<const char*, size_t> &value) { const int cmp = std::strncmp(filter.name, value.first, std::min(filter.size, value.second)); if (cmp == 0) { if (filter.size == value.second) { found = true; } return filter.size < value.second; } return cmp < 0; }); if (!found) { it = filters->insert(it, FilterData(name, size)); // Add node } if (!category[i]) { it->level = level; break; } filters = &it->filters; pos = i + 1; } } }
void MainWindow::denoisingFilter() { Filters * newFilter = new Filters(); newFilter->setSizeMatrix(7); newFilter->denoisingFilter(imageBefore); for(int i = 0 ; i < 1 ; i++) { imageAfter = newFilter->getImageAfter(); newFilter->denoisingFilter(imageAfter); } imageAfter = newFilter->getImageAfter(); showImageAfter(); }
void write( const std::string& message, bool newline=true ) { // Check for filter pass bool pass = filters.size() == 0; foreach ( filter, filters ) { if (message.compare( 0, filter->length(), *filter ) == 0) { pass = true; break; } } if (!pass) return; foreach( i, writers ) { if( i->second.isValid() ) { i->second->write( message, newline ); } } }
void CephSchedulerAgent<T>::resourceOffers( T* driver, const vector<Offer>& offers) { LOG(INFO) << "Received " << offers.size() << " offers! "; TaskType taskType; int token; int isInitialMonNode = 0; //handle waiting OSD task, give them osdID to start docker handleWaitingOSDTasks(driver); Phase currentPhase = stateMachine->getCurrentPhase(); //try start new node foreach (const Offer& offer, offers) { //check offer with the correct role LOG(INFO) << "Hostname: " << offer.hostname(); if (!hasRole(offer, config->role)) { LOG(INFO) << "Decline this offer. Host " << offer.hostname() << " don't have correct role:" << config->role; Filters refuse; refuse.set_refuse_seconds(86400.0); driver->declineOffer(offer.id(),refuse); continue; } //reload or new hostconfig stateMachine->addConfig(offer.hostname()); tryLaunchDiskTask(driver, offer, offer.hostname()); bool accept = stateMachine->nextMove(taskType,token,offer.hostname()); if (!accept) { LOG(INFO) << "In the " << static_cast<int>(currentPhase) << " Staging Phase, cannot accept offer from " << offer.hostname() << " in this phase"; driver->declineOffer(offer.id()); continue; } LOG(INFO) << "Check offer's resources from " <<offer.hostname(); if (offerNotEnoughResources(offer,taskType)) { LOG(INFO) << "Not enough, decline it from " << offer.hostname(); driver->declineOffer(offer.id()); continue; } if (currentPhase == Phase::WAINTING_REQUEST){ accept = fetchPendingRESTfulRequest(); if (!accept){ LOG(INFO) << "No pending OSD RESTful request."; driver->declineOffer(offer.id()); stateMachine->decreaseOSDIndex(); continue; } } LOG(INFO) << "Accepted offer from" << offer.hostname() << ", launch " << static_cast<int>(taskType) <<":" << token << " node"; if (taskType == TaskType::MON && token == 0) { LOG(INFO) << "This is the initial MON"; isInitialMonNode = 1; } string taskId; string executorId; launchNode( driver, offer, taskType, token, isInitialMonNode, taskId, executorId); stateMachine->addStagingTask( taskId, executorId, taskType, offer.hostname(), offer.slave_id().value()); if (!isInitialMonNode && taskType == TaskType::OSD) { ceph::TaskState initialMon = stateMachine->getInitialMon(); const string m = lexical_cast<string>(static_cast<int>(MessageToExecutor::REGISTER_OSD)); ExecutorID eId; eId.set_value(initialMon.executorId); SlaveID sId; sId.set_value(initialMon.slaveId); driver->sendFrameworkMessage( eId, sId, m); }//end if }//end foreach
// This test verifies that the framework can launch a command task // that specifies both container image and persistent volumes. TEST_F(LinuxFilesystemIsolatorMesosTest, ROOT_ChangeRootFilesystemCommandExecutorPersistentVolume) { Try<Owned<cluster::Master>> master = StartMaster(); ASSERT_SOME(master); string registry = path::join(sandbox.get(), "registry"); AWAIT_READY(DockerArchive::create(registry, "test_image")); slave::Flags flags = CreateSlaveFlags(); flags.resources = "cpus:2;mem:1024;disk(role1):1024"; flags.isolation = "filesystem/linux,docker/runtime"; flags.docker_registry = registry; flags.docker_store_dir = path::join(sandbox.get(), "store"); flags.image_providers = "docker"; Owned<MasterDetector> detector = master.get()->createDetector(); Try<Owned<cluster::Slave>> slave = StartSlave(detector.get(), flags); ASSERT_SOME(slave); MockScheduler sched; FrameworkInfo frameworkInfo = DEFAULT_FRAMEWORK_INFO; frameworkInfo.set_roles(0, "role1"); MesosSchedulerDriver driver( &sched, frameworkInfo, master.get()->pid, DEFAULT_CREDENTIAL); Future<FrameworkID> frameworkId; EXPECT_CALL(sched, registered(&driver, _, _)) .WillOnce(FutureArg<1>(&frameworkId)); Future<vector<Offer>> offers; EXPECT_CALL(sched, resourceOffers(&driver, _)) .WillOnce(FutureArg<1>(&offers)) .WillRepeatedly(Return()); // Ignore subsequent offers. driver.start(); AWAIT_READY(frameworkId); AWAIT_READY(offers); ASSERT_FALSE(offers->empty()); Offer offer = offers.get()[0]; string dir1 = path::join(sandbox.get(), "dir1"); ASSERT_SOME(os::mkdir(dir1)); Resource persistentVolume = createPersistentVolume( Megabytes(64), "role1", "id1", "path1", None(), None(), frameworkInfo.principal()); // We use the filter explicitly here so that the resources will not // be filtered for 5 seconds (the default). Filters filters; filters.set_refuse_seconds(0); TaskInfo task = createTask( offer.slave_id(), Resources::parse("cpus:1;mem:512").get() + persistentVolume, "echo abc > path1/file"); task.mutable_container()->CopyFrom(createContainerInfo( "test_image", {createVolumeHostPath("/tmp", dir1, Volume::RW)})); // Create the persistent volumes and launch task via `acceptOffers`. driver.acceptOffers( {offer.id()}, {CREATE(persistentVolume), LAUNCH({task})}, filters); Future<TaskStatus> statusStarting; Future<TaskStatus> statusRunning; Future<TaskStatus> statusFinished; EXPECT_CALL(sched, statusUpdate(&driver, _)) .WillOnce(FutureArg<1>(&statusStarting)) .WillOnce(FutureArg<1>(&statusRunning)) .WillOnce(FutureArg<1>(&statusFinished)); AWAIT_READY(statusStarting); EXPECT_EQ(TASK_STARTING, statusStarting->state()); AWAIT_READY(statusRunning); EXPECT_EQ(TASK_RUNNING, statusRunning->state()); AWAIT_READY(statusFinished); EXPECT_EQ(TASK_FINISHED, statusFinished->state()); // NOTE: The command executor's id is the same as the task id. ExecutorID executorId; executorId.set_value(task.task_id().value()); string directory = slave::paths::getExecutorLatestRunPath( flags.work_dir, offer.slave_id(), frameworkId.get(), executorId); EXPECT_FALSE(os::exists(path::join(directory, "path1"))); string volumePath = slave::paths::getPersistentVolumePath( flags.work_dir, "role1", "id1"); EXPECT_SOME_EQ("abc\n", os::read(path::join(volumePath, "file"))); driver.stop(); driver.join(); }
virtual void resourceOffers(SchedulerDriver* driver, const vector<Offer>& offers) { foreach (const Offer& offer, offers) { LOG(INFO) << "Received offer " << offer.id() << " with " << offer.resources(); // If the framework got this offer for the first time, the state is // `State::INIT`; framework will reserve it (sending RESERVE operation // to master) in this loop. if (!states.contains(offer.slave_id())) { // If all tasks were launched, do not reserve more resources; wait // for them to finish and unreserve resources. if (tasksLaunched == totalTasks) { continue; } states[offer.slave_id()] = State::INIT; } const State state = states[offer.slave_id()]; Filters filters; filters.set_refuse_seconds(0); switch (state) { case State::INIT: { // Framework reserves resources from this offer for only one task; // the task'll be dispatched when reserved resources are re-offered // to this framework. Resources resources = offer.resources(); Offer::Operation reserve = RESERVE(taskResources); Try<Resources> apply = resources.apply(reserve); if (apply.isError()) { LOG(INFO) << "Failed to reserve resources for task in offer " << stringify(offer.id()) << ": " << apply.error(); break; } driver->acceptOffers({offer.id()}, {reserve}, filters); states[offer.slave_id()] = State::RESERVING; break; } case State::RESERVING: { Resources resources = offer.resources(); Resources reserved = resources.reserved(role); if (!reserved.contains(taskResources)) { break; } states[offer.slave_id()] = State::RESERVED; // We fallthrough here to save an offer cycle. } case State::RESERVED: { Resources resources = offer.resources(); Resources reserved = resources.reserved(role); CHECK(reserved.contains(taskResources)); // If all tasks were launched, unreserve those resources. if (tasksLaunched == totalTasks) { driver->acceptOffers( {offer.id()}, {UNRESERVE(taskResources)}, filters); states[offer.slave_id()] = State::UNRESERVING; break; } // Framework dispatches task on the reserved resources. CHECK(tasksLaunched < totalTasks); // Launch tasks on reserved resources. const string& taskId = stringify(tasksLaunched++); LOG(INFO) << "Launching task " << taskId << " using offer " << offer.id(); TaskInfo task; task.set_name("Task " + taskId + ": " + command); task.mutable_task_id()->set_value(taskId); task.mutable_slave_id()->MergeFrom(offer.slave_id()); task.mutable_command()->set_shell(true); task.mutable_command()->set_value(command); task.mutable_resources()->MergeFrom(taskResources); driver->launchTasks(offer.id(), {task}, filters); states[offer.slave_id()] = State::TASK_RUNNING; break; } case State::TASK_RUNNING: LOG(INFO) << "The task on " << offer.slave_id() << " is running, waiting for task done"; break; case State::UNRESERVING: { Resources resources = offer.resources(); Resources reserved = resources.reserved(role); if (!reserved.contains(taskResources)) { states[offer.slave_id()] = State::UNRESERVED; } break; } case State::UNRESERVED: // If state of slave is UNRESERVED, ignore it. The driver is stopped // when all tasks are done and all resources are unreserved. break; } }