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();
}
