コード例 #1
0
ファイル: corract.c プロジェクト: Life-Cycle-Management/si-HM
/* Gets pid for an appl. giving its dbus-path */
static guint get_pid_from_app_path(const gchar * inPath){
	DBusGProxy * lPropProxy = NULL;
	GValue lServicePidV = {0};
	guint lServicePid = 0;
	GError * lError = NULL;

	assert(inPath);
	if (!g_conn){
		g_conn = dbus_g_bus_get(DBUS_BUS_SYSTEM, &lError);
		if (!g_conn || lError){
			log_error_message("Could not obtain dbus connection!\n%s\n", (lError ? lError->message : ""));
			g_error_free(lError);
			lError = NULL;
			goto res_free;
		}
	}

	/* Get a proxy to systemd Properties */
	lPropProxy = dbus_g_proxy_new_for_name(g_conn,
			SYSD_SERVICE_NAME,       //systemd service name
			inPath,                  //service path
			SYSD_INTERFACE_PROP);    //systemd properties interface
	if (NULL == lPropProxy){
		log_error_message("Failed to get Properties proxy!\n", 0);
		goto res_free;
	}

	/* Call Get method of dbus Properties interface
	   Find out Service ControlGroups list. */
	if (!dbus_g_proxy_call_with_timeout(lPropProxy,
				"Get",
				REPLY_TIMEOUT,
				&lError,
				G_TYPE_STRING,
				SYSD_INTERFACE_SERVICE,   //systemd Service interface
				G_TYPE_STRING,
				"ExecMainPID",                   //look for property
				G_TYPE_INVALID,
				G_TYPE_VALUE,
				&lServicePidV,                   //property value
				G_TYPE_INVALID)){
		log_error_message("Method call failed: %s\n", lError->message);
		g_error_free(lError);
		goto res_free;
	}

	log_debug_message("[%s] Got GValue, taking guint...\n", __func__);
	lServicePid = g_value_get_uint(&lServicePidV);
	log_debug_message("[%s] Got pid=%u\n", __func__, lServicePid);


res_free:
	if (lPropProxy){
		g_object_unref(lPropProxy);
		lPropProxy = NULL;
	}

	return lServicePid;
}
コード例 #2
0
static gboolean w_timeout(gpointer data)
{
    WatchdogService *wservice = (WatchdogService *) data;

    log_debug_message("timeout check\n",0);
    watchdog_service_timeout(wservice);
    
    return TRUE;
}
コード例 #3
0
/* Signal handler for the daemon */
void AlSignalHandler(int p_sig)

{
    switch(p_sig) {
	    case SIGTERM:
		log_debug_message("Application launcher received TERM signal ...\n", 0);
		log_debug_message("Application launcher daemon exiting ....\n", 0);
		log_debug_message("Removing lock file %s \n", AL_PID_FILE);
		remove(AL_PID_FILE);
		log_message("Daemon exited !\n", 0);
                exit(EXIT_SUCCESS);
		break;
	    case SIGKILL:
		log_debug_message("Application launcher received KILL signal ...\n", 0);
		break;
 	    default:
		log_debug_message("Daemon received unhandled signal %s\n!", strsignal(p_sig));
		break;
        }
}
コード例 #4
0
int main(int argc, char **argv) {
    char log_text[2000];
    char* nombre = string_substring_from(argv[1], 2);
    char* nombre_log = string_duplicate(nombre);
    char* log = ".log";
    string_append(&nombre_log, log);
    inicializar_log(nombre_log, "Programa");
    habilitar_log_info();
    sprintf(log_text, "Proceso Programa %s Iniciado", nombre);
    log_info_message(log_text);
    log_info_message("Chequeando el path del script...");
    if (argv[1] == NULL ) {
        log_error_message("El path del script no puede ser vacio.");
        finalizar_log();
        return EXIT_FAILURE;
    }

//	CONEXION CON KERNEL
    t_KER_PRO_CPU_UMV mensajeAEnviar = obtener_nueva_shared_str();
    t_KER_PRO_CPU_UMV* mensajeARecibir;
    log_debug_message("Se inicia la conexion con el KERNEL");
    int socket;
//	ACA VA LO DE LA VARIABLE DE ENTORNO
    char* rutaConfiguracion = getenv("ANSISOP_CONFIG");
    t_config *config = config_create(rutaConfiguracion);
    int puerto = config_get_int_value(config, "Puerto");
    char* ip = config_get_string_value(config, "IP");
    sprintf(log_text, "LA IP ES: %s\n", ip);
    log_info_message(log_text);
    sprintf(log_text, "EL PUERTO ES: %i\n", puerto);
    log_info_message(log_text);
    socket = conectar_a_servidor(ip, puerto);
    if (socket == -1) {
        return EXIT_FAILURE;
    }
    log_debug_message("Conectado\n");

//	SE LEVANTA EL SCRIPT
    sprintf(log_text, "Se levantan datos del script en el path:%s", argv[1]);
    log_info_message(log_text);

    int num = 0;
    log_debug_message("se abre el archivo");
    FILE* script;
    script = fopen(argv[1], "r");
    log_debug_message("se abrio el archivo");
    int tamanio;
    fseek(script, 0, SEEK_END);
    tamanio = ftell(script) + 1;
    sprintf(log_text, "El tamanio del script es: (%d)", tamanio);
    log_info_message(log_text);
    char codigo[tamanio];
    rewind(script);
    char aux;
    while (feof(script) == 0) {
        aux = fgetc(script);
        codigo[num] = aux;
        num++;
    }
    log_debug_message("se termino de leer");

//	printf("num vale: (%d)\n", num);
    num = num - 1;
//	printf("ahora num vale: (%d)\n", num);

    sprintf(log_text, "LEO: ('nueva linea')y pongo en posicion (%d)", num);
    log_debug_message(log_text);
    codigo[num] = '\n';
    num++;
    sprintf(log_text, "LEO: ('barra 0')y pongo en posicion (%d)", num);
    log_debug_message(log_text);
    codigo[num] = '\0';

    sprintf(log_text, "El script es: \n%s", codigo);
    log_debug_message(log_text);

    sprintf(log_text, "La longitud del codigo es: %i\n", strlen(codigo));
    log_info_message(log_text);

    fclose(script);

    mensajeAEnviar.codigo = codigo;
    mensajeAEnviar.mensaje = nombre;
    log_debug_message("se copia el codigo");

    sprintf(log_text, "El codigo copiado en el mensaje es: (%s)",
            mensajeAEnviar.codigo);
    log_debug_message(log_text);

//	SE ENVIA EL HANDSHAKE

    log_info_message(
        "Se envia HANDSHAKE al PLP con el Codigo y el Nombre del programa\n");
    enviar_mensaje_a_servidor(socket, HANDSHAKE_PROGRAMA_PLP, &mensajeAEnviar);
    void *msj = recibir_mensaje_de_servidor(socket);
    if (msj != NULL ) {
        mensajeARecibir = (t_KER_PRO_CPU_UMV*) msj;
    } else {
        log_debug_message("ERROR AL RECIBIR MENSAJE NULO");
        return -1;
    }
    if (mensajeARecibir->gen_msg.id_MSJ != HANDSHAKE_PROGRAMA_PLP
            || mensajeARecibir->OK != 1) {
        sprintf(log_text, "%s\n", mensajeARecibir->mensaje);
        log_info_message(log_text);
        return -1;
    } else {
        log_info_message("Respuesta Handshake entre PROGRAMA-KERNEL recibida");
    }

    while (1) {
        log_info_message(
            "\nEL PROGRAMA SE QUEDA ESPERANDO MENSAJES DE IMPRIMIR/ IMPRIMIR TEXTO O FINALIZAR EJECUCION\n");
        msj = recibir_mensaje_de_servidor(socket);
        if (msj != NULL ) {
            mensajeARecibir = (t_KER_PRO_CPU_UMV*) msj;
        } else {
            log_debug_message("ERROR AL RECIBIR MENSAJE NULO");
            return -1;
        }

        switch (mensajeARecibir->gen_msg.id_MSJ) {
        case IMPRIMIR: {
            log_info_message("LLEGO MENSAJE CON ID IMPRIMIR");
            sprintf(log_text, "SE IMPRIME EL VALOR DE LA VARIABLE: %i\n",
                    mensajeARecibir->valor);
            log_info_message(log_text);
            break;
        }
        case IMPRIMIR_TEXTO: {
//			SE HACE LO DE IMPRIMIR TEXTO
            log_info_message("LLEGO MENSAJE CON ID IMPRIMIR TEXTO");
            sprintf(log_text, "SE IMPRIME EL TEXTO:\n\n %s\n",
                    mensajeARecibir->texto);
            log_info_message(log_text);
            break;
        }
        case FINALIZACION_EJECUCION_PROGRAMA: {
            log_info_message(
                "\n---------------LLEGO UN MENSAJE DE FINALIZACION----------------\n");
            log_info_message("\nLA EJECUCION DE ESTE PROGRAMA HA CONCLUIDO\n");
            return EXIT_SUCCESS;
            break;
        }
        default: {
            log_info_message(
                "\n---------------LLEGO UN MENSAJE DESCONOCIDO A PROGRAMA----------------\n");
        }
        }
    }
    return EXIT_SUCCESS;
}
コード例 #5
0
ファイル: corract.c プロジェクト: Life-Cycle-Management/si-HM
gint take_action(gchar * serviceName, gchar * serviceDbusPath, CorrectiveActionType corrActType){
	gint r = 0;
	gchar * file_name = NULL;
	gchar * app_name = NULL;
	gchar * app_to_run = NULL;
	gchar ** corr_act_lst = NULL;
	gchar * action_type = NULL;
	gsize corr_act_lst_len = 0;
	gboolean isTarget = FALSE;

	g_return_if_fail(serviceName != NULL);
	g_return_if_fail(serviceDbusPath != NULL);

	/* Get absolute filename from appName */
	file_name = resolve_file_name(serviceName);

	if (g_str_has_suffix(serviceName, ".target"))
		isTarget = TRUE;

	/* Parse CorrectiveAction string list
	   from Unit Configuration File */
	r = parse_corrective_action(file_name, &corr_act_lst, &corr_act_lst_len, corrActType, isTarget);
	if (r != 0){
		goto free_res;
	}

	action_type = corr_act_lst[0];
	log_debug_message("%s -> processing action '%s'\n", serviceName, action_type);

	/* PROCESSING CORRECTIVE ACTIONS */

	if (g_str_equal(action_type, CORRECTIVE_ACTION_APP_STOP)){
		if (isTarget) {
                        /* For ".target" do NOT call AL to stop it, but
                           workaround to call "systemctl stop" command */

                        char l_cmd[128];
                        int l_ret;
                        sprintf(l_cmd, "systemctl stop %s", serviceName);
                        l_ret = system(l_cmd);
                        if (l_ret != 0) {
                                log_error_message("Command '%s' FAILED! Exit code=%d\n", l_cmd, l_ret);
                        }
                } else {
                        /* For ".service" call AL to stop it */
                        /* but first find pid */

                        guint appPid = get_pid_from_app_path(serviceDbusPath);
                        if (appPid <= 0){
                                r = 1;
                                goto free_res;
                        }

                        r = call_AL_stop_app(appPid);
                        if (r != 0){
                                goto free_res;
                        }
                }
	}
	else if (g_str_equal(action_type, CORRECTIVE_ACTION_APP_RESTART)){
                /* Get app.Name (without ".service" or ".target" suffix) */
		app_name = resolve_app_name(serviceName);
		if (!app_name){
			r = 1;
			goto free_res;
		}

		r = call_AL_restart_app(app_name);
		if (r!=0){
			goto free_res;
		}
	}
	else if (g_str_equal(action_type, CORRECTIVE_ACTION_APP_RUN_APP)){
		gchar * service_to_run = NULL;

		if (corr_act_lst_len < 2 || !corr_act_lst[1]){
			log_error_message("In %s=%s service to run is not specified!\n", g_corr_act_type_key[corrActType], CORRECTIVE_ACTION_APP_RUN_APP);
			r = 1;
			goto free_res;
		}

		service_to_run = corr_act_lst[1];

		app_to_run = resolve_app_name(service_to_run);
		if (!app_to_run){
			r = 1;
			goto free_res;
		}

		r = call_AL_run_app(app_to_run);
		if (r!=0){
			goto free_res;
		}
	}
	else if (g_str_equal(action_type, CORRECTIVE_ACTION_APP_REBOOT_SYS)){
		r = call_AL_reboot_system();
		if (r!=0){
			goto free_res;
		}
	}
	else {
		log_error_message("CorrectiveAction=%s UNKNOWN ACTION\n", action_type);
	}

free_res:

	if (file_name)
		g_free(file_name);

	if (app_name)
		g_free(app_name);

	if (app_to_run)
		g_free(app_to_run);

	if (corr_act_lst)
		g_strfreev(corr_act_lst);

	return r;
}