Esempio n. 1
0
void finalizar_log()
{
	log_destroy(log_i);
	log_destroy(log_d);
	log_destroy(log_t);
	log_destroy(log_w);
	log_destroy(log_e);
}
Esempio n. 2
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);
}
void liberaVariables(t_log* traceLogger, t_config* ptrConfig, t_log* errorLogger) {
	//Libera Logs y el Config File
	log_trace(traceLogger, "Se libera el Archivo de Configuracion.\n");
	config_destroy(ptrConfig);
	log_trace(traceLogger, "Se libera el Log de Errores.\n");
	log_destroy(errorLogger);
	log_trace(traceLogger, "Se libera el Trace Log.\n");
	log_destroy(traceLogger);
}
Esempio n. 4
0
void limpiar_estructuras_swap() {

    log_destroy(loggerDebug);
    log_destroy(loggerError);
    log_destroy(loggerInfo);
    list_destroy_and_destroy_elements(metricas, free);
    list_destroy_and_destroy_elements(espacioLibre, free);
    list_destroy_and_destroy_elements(espacioOcupado, free);
    sem_destroy(&sem_mutex_libre);
    sem_destroy(&sem_mutex_ocupado);
    free(arch);
    clean_socket(socketServidor);
}
Esempio n. 5
0
int main(int argc, char **argv)
{
	if(!check_permissions()) { exit(EXIT_FAILURE); }
	if((argc != 3) && (argc != 4)) {
		printf("usage: %s iface ttl\n", argv[0]);
		exit(EXIT_FAILURE);
	}

	char *iface = argv[1];
	int ttl = atoi(argv[2]);
	int ipversion;// ipversion = 4 to IPv4; ipversion = 6 to IPv6;
	if(argc == 4){
		ipversion = atoi(argv[3]);
	}
	else{
		ipversion = 4;
	}

	log_init(LOG_EXTRA, "log.txt", 1, 1024*1024*16);

	struct packet *pkt;
	struct sender4 *s;
	if (ipversion == 4){
		s = sender4_create(iface);
		pkt = sender4_send_icmp(s, 2, ttl, 1, 1, 1, 1, 1000);
		sender4_destroy(s);
	}
	else if (ipversion == 6){
		struct sender6 *s6 = sender6_create(iface);
		struct libnet_in6_addr ipv6_dst;
		struct sockaddr_in6 sa;
		inet_pton(AF_INET6, "2800:3f0:4004:803::1012", &(sa.sin6_addr));
		memcpy(&ipv6_dst, &sa.sin6_addr, sizeof(struct libnet_in6_addr));
		pkt = sender6_send_icmp(s6, ipv6_dst, ttl, 1, 1, 1, 1, 1, 1000);
		sender6_destroy(s6);
	}

	char *str = packet_tostr(pkt);
	logd(LOG_DEBUG, "%s\n", str);
	free(str);
	packet_destroy(pkt);

	sleep(2);

	if (ipversion == 4){
		pkt = sender4_send_icmp_fixrev(s, 2, ttl, 1, 1, 1, 1, 1000);
	}
	/*else if (ipversion == 6){
        struct libnet_in6_addr dst_ipv6;
        dst_ipv6 = nameToAddr6WithSender(s, "::2");
        pkt = sender_send_icmp6_fixrev(s, dst_ipv6, ttl, 1, 1, 1, 1, 1000);
	}
	str = packet_tostr(pkt);
	logd(LOG_DEBUG, "%s\n", str);
	free(str);
	packet_destroy(pkt);*/

	log_destroy();
	exit(EXIT_SUCCESS);
}
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);
}
int main(int argc, char*argv[]) {

	pthread_mutex_init(&semModificadorDeVidas, NULL);
	sem_init(&semReinicio, 0, 0);
	sem_init(&semFinPlan, 0, 0);

	// Inicializa el log.
	logger = logInit(argv, "PERSONAJE");

	if (signal(SIGINT, muertoPorSenial) == SIG_ERR) {
		log_error(logger, "Error en el manejo de la senal de muerte del personaje.\n", stderr);
		exit(EXIT_FAILURE);
	}

	if (signal(SIGTERM, restarVida) == SIG_ERR) {
		log_error(logger, "Error en el manejo de la senal de restar vidas del personaje.\n", stderr);
		exit(EXIT_FAILURE);
	}

	if (signal(SIGUSR1, sig_aumentar_vidas) == SIG_ERR) {
		log_error(logger, "Error en el manejo de la senal de de aumentar vidas del personaje.\n", stderr);
		exit(EXIT_FAILURE);
	}

	// Creamos el archivo de Configuración
	cargarArchivoConfiguracion(argv[1]);
	//Me conecto con la plataforma para despues de terminar todos los niveles correctamente avisarle
	socketOrquestador = connectToServer(ip_plataforma, atoi(puerto_orq), logger);
	log_debug(logger, "El personaje se conecto con el orquestador");

	//vuelve a tirar todos los hilos por todos los niveles

	do {
		log_debug(logger, "Tiro los hilos para jugar en cada nivel");

		reiniciar = false;

		crearTodosLosHilos();

		sem_wait(&semReinicio);
		sem_wait(&semFinPlan);
		//Ya terminaron todos los hilos. Si murio el ultimo me va a decir que reinicie o no.
		if (reiniciar) {
			liberarHilos();
			log_debug(logger, "El personaje %c termina su conexion y reinicia todos los niveles", personaje.simbolo);
		}

	} while (reiniciar);

	notificarFinPlanNiveles();

	cerrarConexion(&socketOrquestador);
	log_debug(logger, "El personaje se desconecto del orquestador");

	log_destroy(logger);
	config_destroy(configPersonaje);
	list_destroy_and_destroy_elements(personaje.lPersonajes, (void*) _liberar_personaje_individual);
	exit(EXIT_SUCCESS);

}
Esempio n. 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;
}
Esempio n. 9
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;
}
Esempio n. 10
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;
}
Esempio n. 11
0
void finalizar() {
	close(socketNivel);
	close(socketPlanificador);
	log_debug(logger, "El personaje %s finalizo sus niveles de forma correcta.", personaje->nombre);
	avisarFinalizacionDelPersonaje(); // le avisa al orquestador que termino el plan de niveles
	log_destroy(logger);
}
Esempio n. 12
0
void destroyOnConnectionFailure() {
	close(umvSocket);
	close(pcpSocket);
	log_destroy(logger);
	config_destroy(configuracion_CPU);
	exit(EXIT_FAILURE);
}
Esempio n. 13
0
void system_destroy() {
	log_destroy();

	endwin();

	Pa_Terminate();
}
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;
}
Esempio n. 15
0
/*
 * Log function taking a format and variable number of arguments fitting the
 * given format.
 */
static void _log_write(char *buf, size_t len)
{
    int ret;

    assert(buf);
	assert(logconfig.fp);

	/* Make sure buffer is NULL terminated. */
	buf[len - 1] = '\0';

    ret = fprintf(logconfig.fp, "%s", buf);
    if (ret < 0) {
        fprintf(stderr, "[tsocks] logging failed. Stopping logging.\n");
        log_destroy();
        goto end;
    }

    /*
     * On a write failure we stop the logging but a flush failure is not that
     * critical.
     */
    (void) fflush(logconfig.fp);

end:
    return;
}
Esempio n. 16
0
static void 
jfs_destroy(void *arg)
{
  int rc;

  /* stop all reads */
  jfs_pool_destroy(jfs_read_pool);
  
  /* let writes propogate */
  jfs_pool_wait(jfs_write_pool);
  jfs_pool_destroy(jfs_write_pool);

  rc = sqlite3_shutdown();
  if(rc != SQLITE_OK) {
	log_error("SQLITE shutdown FAILED!!!\n");
  }
  
  jfs_datapath_cache_destroy();
  jfs_key_cache_destroy();
  jfs_meta_cache_destroy();
  jfs_dynamic_hierarchy_destroy();

  free(joinfs_context.querypath);
  free(joinfs_context.mountpath);
  free(joinfs_context.logpath);
  free(joinfs_context.dbpath);

  log_msg("joinFS shutdown completed successfully.\n", arg);
  log_destroy();
}
Esempio n. 17
0
void log_close(LOG_REC *log)
{
	g_return_if_fail(log != NULL);

	log_remove_config(log);
	log_destroy(log);
}
Esempio n. 18
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;
}
Esempio n. 19
0
void exitFileSystem()
{
	list_destroy(listaArchivos);
	log_destroy(logFile);
	cerrarConexiones();
	exit(0);
}
Esempio n. 20
0
/**
 * @brief Free any memory associated with a scheduler_t.
 *
 * This will stop the interface if it is currently running, and free all the
 * memory associated with the different regular expression and similar
 * structures.
 *
 * @param scheduler
 */
void scheduler_destroy(scheduler_t* scheduler)
{
  // TODO interface close
  // TODO repo close

  event_loop_destroy();

  if(scheduler->main_log)
  {
    log_destroy(scheduler->main_log);
    main_log = NULL;
  }

  if(scheduler->process_name) g_free(scheduler->process_name);
  if(scheduler->sysconfig)    fo_config_free(scheduler->sysconfig);
  if(scheduler->sysconfigdir) g_free(scheduler->sysconfigdir);
  if(scheduler->host_queue)   g_list_free(scheduler->host_queue);
  if(scheduler->workers)      g_thread_pool_free(scheduler->workers, FALSE, TRUE);

  if(scheduler->email_subject) g_free(scheduler->email_subject);
  if(scheduler->email_command) g_free(scheduler->email_command);

  g_sequence_free(scheduler->job_queue);

  g_regex_unref(scheduler->parse_agent_msg);
  g_regex_unref(scheduler->parse_db_email);
  g_regex_unref(scheduler->parse_interface_cmd);

  g_tree_unref(scheduler->meta_agents);
  g_tree_unref(scheduler->agents);
  g_tree_unref(scheduler->host_list);
  g_tree_unref(scheduler->job_list);

  g_free(scheduler);
}
Esempio n. 21
0
void filesystem_shutdown() {
	mongo_dir_shutdown();
	mongo_file_shutdown();
	mongo_node_shutdown();
	mongo_shutdown();
	log_destroy(mdfs_logger);
}
Esempio n. 22
0
Track::~Track ( )
{
    Loggable::block_start();

    /* must destroy sequences first to preserve proper log order */
    takes->clear();
    control->clear();
    annotation->clear();
    delete sequence();

    takes = NULL;
    control = NULL;
    annotation = NULL;

    log_destroy();

    /* ensure that soloing accounting is performed */
    solo( false );

    timeline->remove_track( this );

    /* give up our ports */
    configure_inputs( 0 );
    configure_outputs( 0 );

    _sequence = NULL;

    if ( _name )
        free( _name );

    Loggable::block_end();
}
Esempio n. 23
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);

}
Esempio n. 24
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;
}
void liberarRecusos() {
	// liberar otros recursos
	liberarEstructura();
	free(tablaPaginas); tablaPaginas = NULL;
	free(tablaDeBitMap); tablaDeBitMap = NULL;
	log_destroy(logger); logger = NULL;
	fclose(archivoSwap);
}
Esempio n. 26
0
/*
 * Initialize joinFS.
 */
static void * 
jfs_init(struct fuse_conn_info *conn)
{
  struct sched_param param;
  pthread_attr_t wattr;

  log_init();
  log_msg("Starting joinFS. FUSE Major=%d Minor=%d\n",
          conn->proto_major, conn->proto_minor);

  /* initialize caches */
  jfs_dynamic_path_init();
  jfs_datapath_cache_init();
  jfs_key_cache_init();
  jfs_meta_cache_init();
  jfs_init_db();

  jfs_read_pool = jfs_pool_create(JFS_THREAD_MIN, JFS_THREAD_MAX, 
								  JFS_THREAD_LINGER, NULL, 
								  SQLITE_OPEN_READONLY);
  if(!jfs_read_pool) {
	log_error("Failed to allocate READ pool.\n");
    log_destroy();

	exit(EXIT_FAILURE);
  }

  pthread_attr_init(&wattr);
  pthread_attr_setschedpolicy(&wattr, SCHED_RR);
  pthread_attr_getschedparam(&wattr, &param);
  param.sched_priority = 1;
  pthread_attr_setschedparam(&wattr, &param);

  jfs_write_pool = jfs_pool_create(1, 1, JFS_THREAD_LINGER, 
								   &wattr, SQLITE_OPEN_READWRITE);
  if(!jfs_write_pool) {
	log_error("Failed to allocate WRITE pool.\n");
    log_destroy();

	exit(EXIT_FAILURE);
  }
  
  log_msg("joinFS Thread pools started.\n");
  
  return NULL;
}
Esempio n. 27
0
JACK_Module::~JACK_Module ( )
{
    log_destroy();
    configure_inputs( 0 );
    configure_outputs( 0 );
    if ( _prefix )
        free( _prefix );
}
Esempio n. 28
0
Controller_Module::~Controller_Module ( )
{
    Fl::remove_timeout( update_cb, this );

    log_destroy();

    /* shutdown JACK port, if we have one */
    mode( GUI );
}
Esempio n. 29
0
Cursor_Point::~Cursor_Point ( )
{
//    sequence()->remove( this );

    log_destroy();

    label(NULL);
    type(NULL);
}
Esempio n. 30
0
/*
 * Lib destructor.
 */
static void tsocks_exit(void)
{
	/* Cleanup every entries in the onion pool. */
	onion_pool_destroy(&tsocks_onion_pool);
	/* Cleanup allocated memory in the config file. */
	config_file_destroy(&tsocks_config.conf_file);
	/* Clean up logging. */
	log_destroy();
}