TEST_F(RegistrarTest, remove) { Registrar registrar(state); SlaveID id1; id1.set_value("1"); SlaveInfo info1; info1.set_hostname("localhost"); info1.mutable_id()->CopyFrom(id1); SlaveID id2; id2.set_value("2"); SlaveInfo info2; info2.set_hostname("localhost"); info2.mutable_id()->CopyFrom(id2); AWAIT_EQ(true, registrar.admit(id1, info1)); AWAIT_EQ(true, registrar.admit(id2, info2)); AWAIT_EQ(true, registrar.remove(info1)); AWAIT_EQ(false, registrar.remove(info1)); AWAIT_EQ(true, registrar.admit(id1, info1)); AWAIT_EQ(true, registrar.remove(info2)); }
TEST_F(RegistrarTest, readmit) { Registrar registrar(state); AWAIT_READY(registrar.recover(MasterInfo())); SlaveInfo info1; info1.set_hostname("localhost"); // Missing ID results in a failure. AWAIT_EXPECT_FAILED(registrar.readmit(info1)); SlaveID id1; id1.set_value("1"); info1.mutable_id()->CopyFrom(id1); SlaveID id2; id2.set_value("2"); SlaveInfo info2; info2.set_hostname("localhost"); info2.mutable_id()->CopyFrom(id2); AWAIT_EQ(true, registrar.admit(info1)); AWAIT_EQ(true, registrar.readmit(info1)); AWAIT_EQ(false, registrar.readmit(info2)); }
importer::importer(const dynamic::repository& rp) : repository_(rp), dynamic_workflow_(repository_) { BOOST_LOG_SEV(lg, debug) << "Initialising importer. "; registrar().validate(); BOOST_LOG_SEV(lg, debug) << "Found " << registrar().file_importers_by_extension().size() << " registered file importers: "; for (const auto& pair : registrar().file_importers_by_extension()) { BOOST_LOG_SEV(lg, debug) << "extension: '" << pair.first << "'" << " file importer: '" << pair.second->id() << "'"; } BOOST_LOG_SEV(lg, debug) << "Finished initialising importer. "; }
int main(int argc, char *argv[]){ int max = 0; /* numero maximo de trabajadores que se van a registrar */ int trabajadoresInscritos = 0; char opcion= 'z'; char (*nombres)[MAX_CHAR]; float *salarios; float *horasextra; float valorHoraExtra = 0; /* ----- Validación de los argumentos ---- */ if (argc<=2){ printf("ERROR: Se esperaba el maximo numero de empleados y el valor de la hora extra; se esperaba %s <numero empleados> <Valor Hora Extra>\n", argv[0]); exit(0); }else{ max = atoi(argv[1]); valorHoraExtra = atof(argv[2]); if(max <=0){ printf("ERROR: argumento no valido se esperaba un numero de trabajadores a registrar positivo mayor que 0: %s\n", argv[1]); exit(0); }if(valorHoraExtra<=0){ printf("ERROR: argumento no valido <valor Hora Extra>\n"); } } /* Memoria dinamica */ nombres = (char (*)[MAX_CHAR])malloc(sizeof(char[MAX_CHAR])*max); salarios =(float *) malloc(sizeof(float)*max); horasextra = (float *)malloc(sizeof(float)*max); do{ getOpcion(&opcion); switch(opcion){ case 'a': registrar(&trabajadoresInscritos, max, nombres,salarios,horasextra); break; case 'b': mostrarListaEmpleados(nombres, salarios, horasextra,trabajadoresInscritos); break; case 'c': calculaNomina(nombres, salarios, horasextra,trabajadoresInscritos,valorHoraExtra); break; case 'q': printf("\nsaliendo del programa...\n"); break; default: printf("---- ****Opción incorrecta %c****------\n\n",opcion); break; } }while(opcion!='q'); printf("\n"); return 0; }
void Slave::setCommunicators(NotifyingCommunicator<google::protobuf::Message*>* dataToSlave, NotifyingCommunicator<google::protobuf::Message*>* dataFromSlave, NotifyingCommunicator<google::protobuf::Message*>* metricsFromSlave) { dataToSlave_ = dataToSlave; dataFromSlave_ = dataFromSlave; metricsFromSlave_ = metricsFromSlave; std::shared_ptr<api::metric::IMetricsRegistrar> registrar(new IMetricsRegistrarImpl(eventLoop_, metricsFromSlave)); taskContext_->setMericsRegistrar(registrar); }
STDAPI DllRegisterServer(void) { /* The documentation seems to claim that regsrv32 will automatically * register any typelib embedded in the DLL, but that seems not to be * the case, so do it manually. It may be that the documentation is * referring to the ATL-generated standard DllRegisterServer. */ HippoRegistrar registrar(L"HippoUtil.dll"); return registrar.registerTypeLib(); }
void executa(int cliSock, char *str) { char *ops = strtok(str, " "); if (strcmp(ops,"registrar")==0){ registrar(str); } else if (strcmp(ops,"listar\n")==0){ listar(); } else if (strcmp(ops,"finalizar\n")==0){ finalizar(); } else{ sprintf(str, "Comando nao encontrado!\n"); } }
std::forward_list<dogen::formatters::artefact> workflow::execute(const formattables::model& fm) const { BOOST_LOG_SEV(lg, debug) << "Started formatting. Model " << fm.name().id(); std::forward_list<dogen::formatters::artefact> r; for (const auto& pair : fm.formattables()) { const auto& formattable(pair.second); const auto& e(*formattable.element()); const auto id(e.name().id()); BOOST_LOG_SEV(lg, debug) << "Procesing element: " << id; const auto ti(std::type_index(typeid(e))); BOOST_LOG_SEV(lg, debug) << "Type index: " << ti.name(); const auto& frp(registrar().formatter_repository()); const auto i(frp.stock_artefact_formatters_by_type_index().find(ti)); if (i == frp.stock_artefact_formatters_by_type_index().end()) { BOOST_LOG_SEV(lg, debug) << "No formatters for type: " << ti.name(); return r; } const auto& eprops(formattable.element_properties()); const auto& hlp_fmts(frp.helper_formatters()); const context ctx(eprops, fm, hlp_fmts); const auto& fmts(i->second); for (const auto& fmt_ptr : fmts) { const auto& fmt(*fmt_ptr); const auto fmtn(fmt.formatter_name()); BOOST_LOG_SEV(lg, debug) << "Using formatter: " << fmtn; const auto artefact(fmt.format(ctx, e)); const auto& p(artefact.path()); BOOST_LOG_SEV(lg, debug) << "Formatted artefact. Path: " << p; r.push_front(artefact); } } BOOST_LOG_SEV(lg, debug) << "Finished formatting."; return r; }
TEST_F(RegistrarTest, recover) { Registrar registrar(state); SlaveInfo slave; slave.set_hostname("localhost"); SlaveID id; id.set_value("1"); slave.mutable_id()->CopyFrom(id); // Operations preceding recovery will fail. AWAIT_EXPECT_FAILED(registrar.admit(slave)); AWAIT_EXPECT_FAILED(registrar.readmit(slave)); AWAIT_EXPECT_FAILED(registrar.remove(slave)); MasterInfo info; info.set_id("foobar"); info.set_ip(0); info.set_port(5050); info.set_pid("0:5050"); Future<Registry> registry = registrar.recover(info); // Before waiting for the recovery to complete, invoke some // operations to ensure they do not fail. Future<bool> admit = registrar.admit(slave); Future<bool> readmit = registrar.readmit(slave); Future<bool> remove = registrar.remove(slave); AWAIT_READY(registry); EXPECT_EQ(info, registry.get().master().info()); AWAIT_EQ(true, admit); AWAIT_EQ(true, readmit); AWAIT_EQ(true, remove); }
// Hilo encargado de la ejecución de los procesos void ejecutarProceso(proceso *procesoActual){ int shmid, datosID,llaveSegmento, contadorLinea, tipo; char *prefijo = (char*)malloc(TAMANIO_LINEAS); char *prefijoLog = (char*)malloc(TAMANIO_LINEAS); char *shm; datos *segmentoDatos; sem_t *mutex,*semDatos; int tamanioMem; char *tipoProceso = (char*)malloc(30); tipo = procesoActual->tipo; switch(procesoActual->tipo){ case TIPO_WRITER: sprintf(tipoProceso,"%s", WRITER); sprintf(prefijo,"1|%s|%3d",WRITER,procesoActual->id); sprintf(prefijoLog,"%s|%3d",WRITER,procesoActual->id); llaveSegmento = LLAVE_SEGMENTO_WRITERS; break; case TIPO_READER: sprintf(tipoProceso, "%s", READER); sprintf(prefijoLog,"%s|%3d",READER,procesoActual->id); llaveSegmento = LLAVE_SEGMENTO_READERS; break; case TIPO_READER_EGOISTA: sprintf(tipoProceso, "%s", READER_EGOISTA); sprintf(prefijoLog,"%s|%3d",READER_EGOISTA,procesoActual->id); llaveSegmento = LLAVE_SEGMENTO_READERS_EGOISTAS; break; default: break; } if(shmid = getMemID(LLAVE_SEGMENTO,NULL)){ datosID = getMem(LLAVE_SEGMENTO_DATOS); shm = getMem(shmid); segmentoDatos = getMem(datosID); tamanioMem = getCantidadLineas() * TAMANIO_LINEAS; mutex = sem_open(SEM_NAME,0,0644,1); semDatos = sem_open(SEM_DATOS_NAME,0,0644,1); } else{ mutex = sem_open(SEM_NAME,O_CREAT,0644,1); semDatos = sem_open(SEM_DATOS_NAME,O_CREAT,0644,1); } while(EXITO){ // Inicializamos el semaforo if(tipo == TIPO_WRITER){ sem_wait(mutex); sem_wait(semDatos); ///////////////////////////////////////////////////// //region critica if(getMemID(LLAVE_SEGMENTO,NULL)){ if(getLectores() == 0){ // Tiempo de escritura if(contadorLinea = escribir(prefijo,tamanioMem,shm,procesoActual)){ setLectura(0);decReader(); actualizar(llaveSegmento,prefijoLog,procesoActual); registrar(procesoActual); sleep(procesoActual->escritura); setLectura(1); } } } else{ sem_post(semDatos); sem_post(mutex); break; } sem_post(semDatos); sem_post(mutex); } else if(tipo == TIPO_READER){ sem_wait(semDatos); if(getMemID(LLAVE_SEGMENTO,NULL)){ if(getLectura()){ decReader(); incLectores(); sem_post(semDatos); leer(tamanioMem,shm,procesoActual); sem_wait(semDatos); decLectores(); } } else{ sem_post(semDatos); break; } sem_post(semDatos); } else if(tipo == TIPO_READER_EGOISTA){ ///////////////////////////////////////////////////// //region critica sem_wait(mutex); sem_wait(semDatos); if(getMemID(LLAVE_SEGMENTO,NULL)){ if(incReader()<4 && getLectores() == 0){ // Tiempo de escritura if(contadorLinea = borrar(tamanioMem,shm,procesoActual)){ setLectura(0); actualizar(llaveSegmento,prefijoLog,procesoActual); registrar(procesoActual); sleep(procesoActual->escritura); setLectura(1); } } } else{ sem_post(semDatos); sem_post(mutex); break; } sem_post(semDatos); sem_post(mutex); } // Tiempo de descanso procesoActual->estado = ESTADO_DESCANSO; actualizar(llaveSegmento,prefijoLog,procesoActual); sleep(procesoActual->descanso); ///////////////////////////////////////////////////// // Luego de dormir se bloquean y esperan el semáforo procesoActual->estado = ESTADO_BLOQUEADO; actualizar(llaveSegmento,prefijoLog,procesoActual); } // Al no encontrar memoria compartida // el proceso muere. //sem_post(mutex); sem_close(mutex); sem_close(semDatos); printf("El %s %d fue finalizado.\n",tipoProceso,procesoActual->id); }
model importer::import_model(const input_descriptor& d) const { const auto extension(d.path().extension().string()); auto& fi(registrar().file_importer_for_extension(extension)); return fi.import(dynamic_workflow_, d); }
workflow::workflow() { registrar().validate(); }