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);
}
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
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);
}
Cursor_Region::Cursor_Region ( const Cursor_Region &rhs ) : Sequence_Region( rhs )
{
_label = strdup( rhs._label );
_type = strdup( rhs._type );
log_create();
}
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));
}
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;
}
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();
}
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;
}
void inicializarLog() {
remove(LOG_PATH);
logFile = log_create(LOG_PATH, "ProcesoNivel", false,
log_level_from_string(configObj->logLevel));
separador_log(configObj->nombre);
}
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!");
}
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;
}
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;
}
Module::Module ( ) : Fl_Group( 0, 0, 50, 50, "Unnamed" )
{
init();
log_create();
}
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;
}
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);
}
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" );
}
/*{{{ 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);
}
Cursor_Point::Cursor_Point ( const Cursor_Point &rhs ) : Sequence_Point( rhs )
{
label( rhs.label() );
type( rhs.type() );
log_create();
}
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;
}
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();
}
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();
}
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;
}
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();
}
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 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");
}
}
Control_Point::Control_Point ( Sequence *t, nframes_t when, float y )
{
_sequence = t;
_y = y;
_r->start = when;
_box_color = FL_WHITE;
log_create();
}