Пример #1
0
void crearArchivoDeLog() {
    char* pathLog = "AdministradorSwap.log";
    char* archLog = "SWAP-Admin";
    loggerInfo = log_create(pathLog, archLog, 1, LOG_LEVEL_INFO);
    loggerError = log_create(pathLog, archLog, 1, LOG_LEVEL_ERROR);
    loggerDebug = log_create(pathLog, archLog, 0, LOG_LEVEL_DEBUG);
}
Пример #2
0
int swapConfigFile()
{

	//Crea Logs
	t_log *errorLogger, *traceLogger;
	traceLogger = log_create("LogTraceUMC.txt","UMCConfigFile",true,LOG_LEVEL_TRACE);
	errorLogger = log_create("LogErroresUMC.txt","UMCConfigFile",true,LOG_LEVEL_ERROR);

	//Declaracion de Variables
	t_config *ptrConfig, *ptrConfigUpdate;
	SwapConfigFile *ptrvaloresConfigFile;
	ptrvaloresConfigFile = NULL;
	ptrvaloresConfigFile = malloc(sizeof(SwapConfigFile));
	ptrConfigUpdate = NULL;

	//Se asigna a ptrConfig el archivo de configuracion. Si no lo encuentra, finaliza
	//y lo advierte en el log
	ptrConfig = config_create("/home/utnso/workspace/SwapConfigFile/Debug/config.txt");
	if (ptrConfig == NULL){
		log_error(errorLogger,"Archivo de configuración no disponible. No puede ejecutar el UMC.\n");
		return EXIT_FAILURE;
	} else {
		log_trace(traceLogger,"Iniciando Proceso UMC.\n");
	}

	//El procedimiento carga los valores del Config File en las variables creadas
	levantaConfigFileEnVariables(ptrvaloresConfigFile,ptrConfig);

	log_trace(traceLogger,"Archivo de Configuracion levantado exitosamente.\n");

	printf("%d\n\n", ptrvaloresConfigFile->puerto_escucha);

	while (1)
	{
		huboUnCambio=0;
		detectaCambiosEnConfigFile();
		if (huboUnCambio)
		{
			ptrConfigUpdate = config_create("/home/utnso/workspace/SwapConfigFile/Debug/config.txt");
			if(ptrConfigUpdate->properties->elements_amount==0) {
				log_error(errorLogger,"No se puede levantar el Archivo de Configuracion.\n");
			} else {
				levantaConfigFileEnVariables(ptrvaloresConfigFile, ptrConfigUpdate);
				printf("%d\n\n", ptrvaloresConfigFile->puerto_escucha);
				log_trace(traceLogger,"Archivo de Configuracion actualizado y levantado.\n");
			}
			config_destroy(ptrConfigUpdate);

		}
	}

	printf("%s\n\n", ptrvaloresConfigFile->nombre_swap);

	liberaVariables(traceLogger, ptrConfig, errorLogger);
	free(ptrvaloresConfigFile);

	return EXIT_SUCCESS;

}; //Fin de Main
Пример #3
0
void inicializar_log(char* file_name, char *app_name)
{

	log_i = log_create(file_name, app_name, false, LOG_LEVEL_INFO);
	log_d = log_create(file_name, app_name, false, LOG_LEVEL_DEBUG);
	log_t = log_create(file_name, app_name, false, LOG_LEVEL_TRACE);
	log_w = log_create(file_name, app_name, false, LOG_LEVEL_WARNING);
	log_e = log_create(file_name, app_name, false, LOG_LEVEL_ERROR);
}
Пример #4
0
Cursor_Region::Cursor_Region ( const Cursor_Region &rhs ) : Sequence_Region( rhs )
{
    _label = strdup( rhs._label );
    _type = strdup( rhs._type );

    log_create();
}
Пример #5
0
int main(int argc, char *argv[]) {
	limpiarPantalla();
	logger = log_create("logWorker", "Worker.c", 1, LOG_LEVEL_TRACE);
	cargarConfiguracionNodo(&config,argv[1]);
	levantarServidorWorker(config.IP_NODO, config.PUERTO_WORKER);


	//aparear("/home/utnso/tp-2017-2c-PEQL/Worker/Debug/tmp/j1n4b13e0","/home/utnso/tp-2017-2c-PEQL/Worker/Debug/tmp/j1n4b17e0","/home/utnso/pruebafeliz.txt");

	/*t_list* listaArchivosTemporales = list_create();
	list_add(listaArchivosTemporales, "/home/utnso/tp-2017-2c-PEQL/Worker/a.txt");
	list_add(listaArchivosTemporales, "/home/utnso/tp-2017-2c-PEQL/Worker/b.txt");
	list_add(listaArchivosTemporales, "/home/utnso/tp-2017-2c-PEQL/Worker/c.txt");
	apareoArchivosLocales(listaArchivosTemporales,"/home/utnso/tp-2017-2c-PEQL/Worker/resultado.txt");
	//Para probar reduccion
	t_list* listaArchivosTemporales = list_create();
	list_add(listaArchivosTemporales, "/home/utnso/tp-2017-2c-PEQL/Worker/Debug/tmp/j1n1b0e0");
	list_add(listaArchivosTemporales, "/home/utnso/tp-2017-2c-PEQL/Worker/Debug/tmp/j1n1b3e0");
	list_add(listaArchivosTemporales, "/home/utnso/tp-2017-2c-PEQL/Worker/Debug/tmp/j1n1b6e0");
	list_add(listaArchivosTemporales, "/home/utnso/tp-2017-2c-PEQL/Worker/Debug/tmp/j1n1b9e0");
	char *archivoPreReduccion = "preReduccion";
	char* destino = "destinoFinal";
	char *path = string_new();
	char cwd[1024];
	string_append(&path, getcwd(cwd, sizeof(cwd)));

	char* aux = string_from_format("%s/tmp/%s", path, archivoPreReduccion); // /home/utnso/tp-2017-2c-PEQL/Worker/Debug/tmp/preReduccion
	apareoArchivosLocales(listaArchivosTemporales, aux);
	char* command = string_from_format("cat %s | perl %s > %s", aux, string_from_format("../scripts/reductorLocal.pl"), string_from_format("%s/tmp/%s", path, destino));
	ejecutarComando(command, clientSocket);
	log_trace(logger, "Reduccion local realizada correctamente");*/


	return EXIT_SUCCESS;
}
void init(){

	LOGGER = log_create(LOG_PATH, "MaRTA", true, LOG_LEVEL_DEBUG);
	CONF = config_create(CONF_PATH); //HACK estaba mal el nombre de la funcion o no la encontraba o no se

	if(LOGGER == NULL){
		perror("ERROR! no pudo levantar ni el log!");
		exit(EXIT_FAILURE);
	}

	if(CONF == NULL){
		log_error(LOGGER, "\nERROR AL LEVANTAR ARCHIVO DE CONFIGURACION\n( Don't PANIC! Si estas por consola ejecuta: ln -s ../%s %s )\n\n"
				, CONF_PATH
				, CONF_PATH);

		exit(EXIT_FAILURE);
	}

//	if(!validarConfig()){ //HACK no lo necesitaba, no entendi el codigo del map y no me servia, anda :P
//		log_error(LOGGER, "No pudo obtenerse alguno de los parametros de configuracion");
//		exit(EXIT_FAILURE);
//	}

	mapa_nodos = dictionary_create();
	lista_jobs = list_create();
	pthread_mutex_init(&mutex_mapa_nodos, NULL);
	pthread_mutex_init(&mutex_lista_jobs, NULL);


	log_info(LOGGER, "intenta conectarse a la ip %s con puerto %d", config_get_string_value(CONF, "IP_FS"), config_get_int_value(CONF, "PUERTO_FS"));
	socketFS = conectarAServidor(config_get_string_value(CONF, "IP_FS"), config_get_int_value(CONF, "PUERTO_FS"));
	while (socketFS == -1) {
		 log_info(LOGGER, "Filesystem no levantado. Se reintenta conexion en unos segundos");
		 sleep(5);
		 socketFS = conectarAServidor(config_get_string_value(CONF, "IP_FS"), config_get_int_value(CONF, "PUERTO_FS"));
	}

	header_t header;
	initHeader(&header);
	header.tipo = MARTA_TO_FS_HANDSHAKE;
	header.largo_mensaje = 0;
	header.cantidad_paquetes = 1;

	log_info(LOGGER, "Conectado a FS! envio header %s", getDescription(header.tipo));
	enviar_header(socketFS, &header);
	t_mensaje mensaje;
	memset(&mensaje, 0, sizeof(t_mensaje));
	recibir_t_mensaje(socketFS, &mensaje);
	log_info(LOGGER, "recibo respuesta %s de FS", getDescription(mensaje.tipo));

	while(mensaje.tipo != ACK){
		log_info(LOGGER, "Todavia el FS no esta disponible. Header recibido: %s. Reintento en 5 segundos", getDescription(header.tipo));
		sleep(5);
		enviar_header(socketFS, &header);
		recibir_t_mensaje(socketFS, &mensaje);
	}

	recibirNodosFS();
	log_info(LOGGER, "%s: FS está operativo. Continúo", getDescription(header.tipo));
}
Пример #7
0
int main(int argc, char *argv[]) {
	signal(SIGUSR1, (void*) manejarSenial);
	logger = log_create("/home/utnso/personaje.log", "PERSONAJE", true, LOG_LEVEL_TRACE);
	log_info(logger, "Log creado con exito, se procede a loguear el proceso Personaje");

	log_debug(logger, "Chequeando el path del personaje...");
	if (argv[1] == NULL ) {
		log_error(logger, "El path del personaje no puede ser vacio.");
		log_destroy(logger);
		return EXIT_FAILURE;
	}

	path = argv[1];

	int levantarConfig = levantarPersonaje(path);
	if (levantarConfig == 1) {
		return EXIT_FAILURE;
	}

	enviarSeniales();

	int resultado = procesar();
	if (resultado == 1) {
		return EXIT_FAILURE;
	}

	finalizar();
	return EXIT_SUCCESS;
}
Пример #8
0
int main(int argc, char **argv)
{
	const uint16_t acceptor_port = (uint16_t)((argc >= 2) ? atoi(argv[1]) : 8080);
	char const * const settings_file_name = ((argc >= 3) ? argv[2] : "settings.txt");
	settings_t settings;
	server_t server;
	log_t log;

	log_create(&log, stderr);

	if (!load_settings(&settings, settings_file_name, &log))
	{
		return 1;
	}

	if (!server_create(&server, &log, &settings, acceptor_port))
	{
		settings_destroy(&settings);
		return 1;
	}

	settings_destroy(&settings);

	server_run(&server);
	server_destroy(&server);

	log_destroy(&log);
	return 0;
}
int main (int argc, char** argv) {

	pthread_t thread;
	int listener, nuevaConexion;

	/* Creación de archivo log */
	Logger = log_create(LOG_PATH, "MSP", false, LOG_LEVEL_TRACE);
	clean_file(LOG_PATH);

	cargarConfiguracion(argv[1]);
	inicializarMSP();

	log_trace(Logger, "Inicio de MSP.\n	Tamaño de Memoria Principal: %u.\n	Tamaño de SWAP: %u.", MaxMem, MaxSwap);

	listener = server_socket(Puerto);
	pthread_create(&thread, NULL, atenderConsola, NULL);

	while (true) {

		nuevaConexion = accept_connection(listener);

		pthread_mutex_lock(&LogMutex);
		log_trace(Logger, "Nueva conexión.");
		pthread_mutex_unlock(&LogMutex);

		pthread_create(&thread, NULL, atenderProceso, &nuevaConexion);
	}

	return EXIT_SUCCESS;

}
/**
 * @NAME: inicializarPersonaje
 * @DESC: Inicializa todas las variables y estructuras necesarias para el proceso personaje
 */
void inicializarPersonaje() {
	// TODO agregar inicializaciones necesarias

	levantarArchivoConfiguracionPersonaje(CONFIG_FILE);

	LOGGER = log_create(configPersonajeLogPath(), "PERSONAJE", configPersonajeLogConsola(), configPersonajeLogNivel() );
	log_info(LOGGER, "INICIALIZANDO PERSONAJE '%s' ", configPersonajeNombre());

	strcpy(personaje.nombre, configPersonajeNombre());
	strcpy(personaje.ip_orquestador, configPersonajePlataformaIp());
	personaje.puerto_orquestador = configPersonajePlataformaPuerto();

	reiniciar(false);

	listaHilosxNivel = list_create();

	pthread_mutex_init (&mutexEnvioMensaje, NULL);
	pthread_mutex_init (&mutexVidas, NULL);
	pthread_mutex_init (&mutexListaHilosxNivel, NULL);
	pthread_mutex_init (&mutexReinicio, NULL);

	REINTENTOS = 0;

	inicializarVariablesGlobales();
}
Пример #11
0
int main( int argc, char *argv[] )
{
    Huint       j;
    Huint       self;
    register Huint start_time;
    register Huint end_time;

    log_create( &logbuf, LOOPS * 2 );
    for( j = 0; j < LOOPS; j++ )
    {
        start_time = timer_get_globallo();
        self = hthread_self();
        end_time = timer_get_globallo();
        
        logbuf.buffer[ logbuf.pos++ ] = start_time;
        logbuf.buffer[ logbuf.pos++ ] = end_time;
        
#ifdef PRINT
            //XExc_mDisableExceptions(XEXC_NON_CRITICAL);
            printf( "Self: %u\n", self );
            //XExc_mEnableExceptions(XEXC_NON_CRITICAL);
#endif
    }

    //XExc_mDisableExceptions(XEXC_NON_CRITICAL);
    printf( "Flushing %u timing values...\n", logbuf.pos );
    log_flush( &logbuf );
    //log_close( &logbuf );
	printf( "--DONE--\n" );
    //XExc_mEnableExceptions(XEXC_NON_CRITICAL);

	return 1;
}
Пример #12
0
void inicializarLog() {

	remove(LOG_PATH);
	logFile = log_create(LOG_PATH, "ProcesoNivel", false,
			log_level_from_string(configObj->logLevel));
	separador_log(configObj->nombre);
}
Пример #13
0
static void main_loop(int flag, LogLevel_t level, const char *logName)
{
	int cnt = 0;
	DBG("Log Test Start: %d.", cnt++);
	INFO("Info: %d", cnt++);
	ERR("Err: %d", cnt++);
	FILE *fp = fopen("not_exit", "b");
	ERRSTR("Open none exist file");

	LogHandle hLog;

	hLog = log_create(level, flag, logName, 1024 * 1024);
	assert(hLog != NULL);
	
	for(level = LOG_LEVEL_DBG; level < LOG_LEVEL_MAX; level++)
	{
		log_print(hLog, "Log level: %d", level);
		log_set_level(hLog, level);
		
		log_debug(hLog, "Debug info, log name %s", logName);
		log_warning(hLog,"Warning, flag: %u, level: %d", flag, level);
		log_error(hLog,"Error, log handle addr: 0x%X", hLog);
	}

	const char *pErr = str_err((int)E_BUSY);
	printf("Err string: %s\n", pErr);

	log_print(hLog, "Log test success!");
}
Пример #14
0
int main(int argc, char *argv[]) {

	logger = log_create("Job.log", "JOB", 1, LOG_LEVEL_DEBUG);

	if (argc != 2) {
		printf("ERROR -> La sintaxis es:  ./Job.c \"Ruta_archivo_config\" \n");
		return EXIT_FAILURE;
	}

	if (!initConfig(argv[1])) {
		log_error(logger, "Config failed");
		freeCfg();
		return EXIT_FAILURE;
	}

	if (pthread_mutex_init(&Msockmarta, NULL) != 0) {
		log_error(logger, "ERROR - No se pudo inicializar el mutex Msockmarta");
		return 1;
	}

	if ((sock_marta = conectarMarta()) >= 0) {
		log_info(logger, "sock_marta: %d", sock_marta);
		atenderMarta(sock_marta);
		;
	}

	return EXIT_SUCCESS;
}
Пример #15
0
int main(int argc, char *argv[]) {
	jobConfig = config_create(FILE_CONFIG);
	logger = log_create(FILE_LOG, "JOB", true, LOG_LEVEL_TRACE);
	pthread_mutex_init(&mutex_log, NULL);


	signal(SIGCHLD, SIG_IGN);
	//sem_t sem;
	sem_init(&sem, 0, 0);


	//test conexion con marta
	conectar_con_marta();


	log_trace(logger, "FIN TODO");


	/* cleanup semaphores */
	sem_destroy (&sem);

	//desconecto al nodo
	/*int socket = client_socket("192.168.1.37", 6001);
	t_msg* msg = argv_message(-1, 0);
	enviar_mensaje(socket, msg);
	destroy_message(msg);
	close(socket);*/

	//finalizo el programa para que no intente conectar con el nodo
	log_destroy(logger);
	config_destroy(jobConfig);

	return EXIT_SUCCESS;
}
Пример #16
0
Module::Module ( ) : Fl_Group( 0, 0, 50, 50, "Unnamed" )
{
    init();


    log_create();
}
Пример #17
0
int main(int argc, char *argv[]) {

	logger = log_create("Log.txt", "NODO", false, LOG_LEVEL_DEBUG);

		fd = socket_listen(30123);
		sock_job = socket_accept(fd);

		log_info(logger,"fd : %d", fd);
		log_info(logger,"conexion job: %d", sock_job);
		int hand = socket_handshake_to_client(sock_job, HANDSHAKE_NODO, HANDSHAKE_JOB);
		if (!hand) {
			printf("Error al conectar con Job \n");
			return EXIT_FAILURE;
		}

		void *buffer;
		size_t sbuffer = 0;
		int recibi;
		recibi = socket_recv_packet(sock_job, &buffer, &sbuffer);
		log_info(logger,"Recibi todo ok : %d\n",recibi);
		desserializeMap(buffer);
		/*
		recvOrder(fd);
		serializeMapResult(fd, true, 1);
		recvOrder(fd);
		char failedTemp[60];
		memset(failedTemp, '\0', sizeof(char) * 60);
		strcpy(failedTemp, "TemporalFallido");
		serializeReduceResult(fd, false, 0, failedTemp);
		recvOrder(fd);
		*/
		log_destroy(logger);
		return EXIT_SUCCESS;
}
Пример #18
0
static void realizarLogueo(t_log_level logLevel, int loguearEnPantalla, char *mensaje)
{
	pthread_mutex_lock(&mutex_log);

	t_log *log = log_create(pathArchivoDeLog, "FILESYSTEM", loguearEnPantalla, LOG_LEVEL_TRACE);

	switch(logLevel)
	{
	case LOG_LEVEL_TRACE:
		log_trace(log, mensaje);
		break;
	case LOG_LEVEL_DEBUG:
		log_debug(log, mensaje);
		break;
	case LOG_LEVEL_INFO:
		log_info(log, mensaje);
		break;
	case LOG_LEVEL_WARNING:
		log_warning(log, mensaje);
		break;
	case LOG_LEVEL_ERROR:
		log_error(log, mensaje);
		break;
	}

	log_destroy(log);

	pthread_mutex_unlock(&mutex_log);
}
Пример #19
0
AUX_Module::AUX_Module ( ) : JACK_Module ( false )
{
    is_default( false );

    _number = 0;

    {
        Port p( this, Port::INPUT, Port::CONTROL, "Gain (dB)" );
        p.hints.type = Port::Hints::LOGARITHMIC;
        p.hints.ranged = true;
        p.hints.minimum = -70.0f;
        p.hints.maximum = 6.0f;
        p.hints.default_value = 0.0f;
        
        p.connect_to( new float );
        p.control_value( p.hints.default_value );

        add_port( p );
    }

    log_create();

    color( FL_DARK1 );

    copy_label( "Aux" );
}
Пример #20
0
/*{{{  bit_create -- create a bitmap as a sub-rectangle of another bitmap*/
BITMAP *
bit_create(BITMAP *map, int x, int y, int wide, int high)
{
  BITMAP *result;

  if (x + wide > map->wide)
    wide = map->wide - x;
  if (y + high > map->high)
    high = map->high - y;
  if (wide < 1 || high < 1)
    return (BITMAP *)0;

  if ((result = (BITMAP *)malloc(sizeof(BITMAP))) == (BITMAP *)0)
    return (BITMAP *)0;

  result->data = map->data;
  result->x0 = map->x0 + x;
  result->y0 = map->y0 + y;
  result->wide = wide;
  result->high = high;
  result->depth = map->depth;
  result->primary = map->primary;
  result->cache = NULL;
  result->color = 0;
#ifdef MOVIE
  log_create(map);
#endif
  result->id = map->id;
  result->type = map->type;
  result->deviceinfo = map->deviceinfo;
  return (result);
}
Пример #21
0
Cursor_Point::Cursor_Point ( const Cursor_Point &rhs ) : Sequence_Point( rhs )
{
    label( rhs.label() );
    type( rhs.type() );

    log_create();
}
Пример #22
0
t_queue* enviarRecursoOrquestador(recursosPersonajesStruct *unPersonaje)
{
        t_log *log = log_create(logName,"Nivel",FALSE,LOG_LEVEL_INFO);
        int32_t length,size;
        liberadosNoSerializadoStruct colaLib;
        colaNoSerializadaStruct *colaAsig;
        nivelYPersonaje nivelYPersonaje;
        colaLib.cola=unPersonaje->recursos;
        void *data = serializador_liberados(&colaLib,&size);
        length = size + sizeof(header_t);

        int32_t socketOrquestador = socketCreateClient(getIp(nivel.orquestador), getPort(nivel.orquestador));


        nivelYPersonaje.personaje = unPersonaje->simbolo;
        strcpy(nivelYPersonaje.nivelNombre,nivel.nombre);

        socketSend(socketOrquestador, data, length);
        socketSend(socketOrquestador, &(nivelYPersonaje), sizeof(char[30]));

        recv(socketOrquestador,&length,sizeof(int32_t),MSG_WAITALL);
        void *buffer = malloc(length);
        recv(socketOrquestador,buffer,length,MSG_WAITALL);
        colaAsig = desserializador_recursos(buffer);

        shutdown(socketOrquestador,2);
        log_destroy(log);
        return colaAsig->cola;
}
Пример #23
0
void initFileSystem()
{
	logFile = log_create("./FileSystem.log","FileSystem", true, LOG_LEVEL_TRACE);
	pthread_mutex_init(&mLogFile, NULL);

	t_config* archivoConfig = config_create("./FileSystem.config");

	PUERTO_LISTEN = config_get_int_value(archivoConfig, "PUERTO_LISTEN");
	char* tmp = config_get_string_value(archivoConfig, "IP_LISTEN");
	strcpy(IP_LISTEN,tmp);
	free(tmp);

	LISTA_NODOS = config_get_int_value(archivoConfig, "LISTA_NODOS");

	//config_destroy(archivoConfig);

	listaArchivos = list_create();
	pthread_mutex_init(&mListaArchivos, NULL);

	listaDirs = list_create();
	pthread_mutex_init(&mListaDirs, NULL);
	t_reg_directorio* raiz = malloc(sizeof(t_reg_directorio));
	strcpy(raiz->directorio, "\0");
	raiz->padre = -1;
	list_add(listaDirs, raiz);

	initConsola();
	initComandos();
	initConexiones();
	leerPersistencia();
}
Пример #24
0
void logearOrdenReduce(char* nombre){

	t_log_level nivel;

	t_log* archivoDeLog;

	nivel = LOG_LEVEL_INFO;

	archivoDeLog = log_create("LogNodo", "Nodo", 0, nivel);

		 char *unaPalabra = string_new();

		 string_append(&unaPalabra, "Solicitud de Reduce con el script ");

		 string_append(&unaPalabra, nombre);






		log_info(archivoDeLog,unaPalabra);

		free(unaPalabra);
		log_destroy(archivoDeLog);

}
void inicializar_panel(t_tipo_proceso tipo_proceso, char* path){
	char* tipo_proceso_str;

	if (tipo_proceso == KERNEL)
		tipo_proceso_str = "kernel";
	else if (tipo_proceso == CPU)
		tipo_proceso_str = "cpu";
	else
		tipo_proceso_str = "?";

	proceso_tipo = tipo_proceso;

	char* logFile = string_duplicate(path);
	string_append(&logFile, tipo_proceso_str);
	string_append(&logFile, ".log");

	remove(logFile);
	logger = log_create(logFile, tipo_proceso_str, true, LOG_LEVEL_INFO);

	log_info(logger, "Inicializando panel para %s, en \"%s\"", tipo_proceso_str, logFile);

	free(logFile);

	kernel_cpus_conectadas = list_create();
	kernel_consolas_conectadas = list_create();
}
Пример #26
0
int main(int argc,char *argv[]) {

	t_configuracion_cpu* configCPU = malloc(sizeof(t_configuracion_cpu));

	logger = log_create("cpu.log", "CPU",true, LOG_LEVEL_INFO);
	crearLog();

	//valida los parametros de entrada del main
	if (argc != 2) {
	    log_error_y_cerrar_logger(logger, "Uso: cpu config_path (faltan parametros de entrada)\n");
		return EXIT_FAILURE;
	}

    log_info(logger, "Inciando proceso CPU..");
	levantarDatosDeConfiguracion(configCPU, argv[1]);

	//Conexión al nucleo
	conectarAlNucleo(configCPU);

	//Conexión al umc
	conectarAUMC(configCPU);

	signal(SIGUSR1, handler_seniales);

	int header;

	printf("Me quedo escuchando mensajes del nucleo (socket:%d)\n", socket_nucleo);

	while(1){

		if( recv(socket_nucleo, &header, sizeof(int), 0) <= 0)
		{
			perror("Desconexion del nucleo\n");
			close(socket_nucleo);
			return 0;
		}

		switch (header) {
			case EJECUTA:
				ejecutar();
				break;

			case CAMBIO_QUANTUM_SLEEP:
				recv(socket_nucleo,&quantum_sleep,sizeof(int),0);
				break;

			default:
				printf("obtuve otro id %d\n", header);
				sleep(3);
				break;
		}
	}

	finalizarCpu();
	log_destroy(logger);


	return EXIT_SUCCESS;
}
Пример #27
0
Module::Module ( bool is_default, int W, int H, const char *L ) : Fl_Group( 0, 0, W, H, L ), Loggable( !is_default )
{
    this->is_default( is_default );

    init();

    log_create();
}
Пример #28
0
void
klog_setup(klog_options_st *options, klog_metrics_st *metrics)
{
    size_t nbuf = KLOG_NBUF;
    char *filename = NULL;

    log_info("Set up the %s module", KLOG_MODULE_NAME);

    if (klog_init) {
        log_warn("%s has already been setup, overwrite", KLOG_MODULE_NAME);
        log_destroy(&klogger);
    }

    klog_metrics = metrics;

    if (options != NULL) {
        filename = option_str(&options->klog_file);
        klog_backup = option_str(&options->klog_backup);
        if (klog_backup != NULL) {
            size_t nbyte = strnlen(klog_backup, PATH_MAX + 1);
            if (nbyte > PATH_MAX) {
                log_crit("klog file path too long");
                goto error;
            }
            strncpy(backup_path, klog_backup, PATH_MAX);
            klog_backup = backup_path;
        }
        nbuf = option_uint(&options->klog_nbuf);
        klog_sample = option_uint(&options->klog_sample);
        if (klog_sample == 0) {
            log_crit("klog sample rate cannot be 0 - divide by zero");
            goto error;
        }
        klog_max =  option_uint(&options->klog_max);
    }

    if (filename == NULL) { /* no klog filename provided, do not log */
        klog_enabled = false;
        return;
    }

    klogger = log_create(filename, nbuf);
    if (klogger == NULL) {
        log_crit("Could not create klogger!");
        goto error;
    }

    klog_enabled = true;

    klog_init = true;

    return;

error:
    log_destroy(&klogger);
    exit(EX_CONFIG);
}
Пример #29
0
void rutinaFinalizoCorrectamente(int resultado){
if (resultado == 0){

	t_log_level nivel;
	t_log* archivoDeLog;
	nivel = LOG_LEVEL_INFO;
	archivoDeLog = log_create("/home/utnso/Escritorio/log.txt", "LaMartus", 0, nivel);
	log_info(archivoDeLog,"salio ok map/reduce");

}else{

	t_log_level nivel;
	t_log* archivoDeLog;
	nivel = LOG_LEVEL_ERROR;
	archivoDeLog = log_create("/home/utnso/Escritorio/log.txt", "LaMartus", 0, nivel);
	log_error(archivoDeLog,"fallo map/reduce");
}
}
Пример #30
0
Control_Point::Control_Point ( Sequence *t, nframes_t when, float y )
{
    _sequence = t;
    _y = y;
    _r->start = when;
    _box_color = FL_WHITE;

    log_create();
}