/**************************************************************************//** * @file * Source module isolating the ECOMP Vendor Event Listener (EVEL) API. * * This file implements the EVEL library which is intended to provide a * simple wrapper around the complexity of AT&T's Vendor Event Listener API so * that VNFs can use it without worrying about details of: * * * The API's encoding into JSON. * * The API's transport over HTTP/HTTPS. * * License * ------- * * Copyright © 2017 AT&T Intellectual Property. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *****************************************************************************/ #include #include #include #include #include #include "evel.h" #include "evel_internal.h" #include "evel_throttle.h" #include "metadata.h" /**************************************************************************//** * The type of equipment represented by this VNF. *****************************************************************************/ EVEL_SOURCE_TYPES event_source_type = EVEL_SOURCE_OTHER; /**************************************************************************//** * The Functional Role of the equipment represented by this VNF. *****************************************************************************/ char *functional_role = NULL; /**************************************************************************//** * Library initialization. * * Initialize the EVEL library. * * @note This function initializes the cURL library. Applications making use * of libcurl may need to pull the initialization out of here. Note * also that this function is not threadsafe as a result - refer to * libcurl's API documentation for relevant warnings. * * @sa Matching Term function. * * @param fqdn The API's FQDN or IP address. * @param port The API's port. * @param path The optional path (may be NULL). * @param topic The optional topic part of the URL (may be NULL). * @param secure Whether to use HTTPS (0=HTTP, 1=HTTPS) * @param username Username for Basic Authentication of requests. * @param password Password for Basic Authentication of requests. * @param source_type The kind of node we represent. * @param role The role this node undertakes. * @param verbosity 0 for normal operation, positive values for chattier * logs. * * @returns Status code * @retval EVEL_SUCCESS On success * @retval ::EVEL_ERR_CODES On failure. *****************************************************************************/ EVEL_ERR_CODES evel_initialize(const char * const fqdn, int port, const char * const path, const char * const topic, int secure, const char * const username, const char * const password, EVEL_SOURCE_TYPES source_type, const char * const role, int verbosity ) { EVEL_ERR_CODES rc = EVEL_SUCCESS; char base_api_url[EVEL_MAX_URL_LEN + 1] = {0}; char event_api_url[EVEL_MAX_URL_LEN + 1] = {0}; char throt_api_url[EVEL_MAX_URL_LEN + 1] = {0}; char path_url[EVEL_MAX_URL_LEN + 1] = {0}; char topic_url[EVEL_MAX_URL_LEN + 1] = {0}; char version_string[10] = {0}; int offset; /***************************************************************************/ /* Check assumptions. */ /***************************************************************************/ assert(fqdn != NULL); assert(port > 0 && port <= 65535); assert(source_type < EVEL_MAX_SOURCE_TYPES); assert(role != NULL); /***************************************************************************/ /* Start logging so we can report on progress. */ /***************************************************************************/ log_initialize(verbosity == 0 ? EVEL_LOG_INFO : EVEL_LOG_DEBUG, "EVEL"); EVEL_INFO("EVEL started"); EVEL_INFO("API server is: %s", fqdn); EVEL_INFO("API port is: %d", port); if (path != NULL) { EVEL_INFO("API path is: %s", path); } else { EVEL_INFO("No API path"); } if (topic != NULL) { EVEL_INFO("API topic is: %s", topic); } else { EVEL_INFO("No API topic"); } EVEL_INFO("API transport is: %s", secure ? "HTTPS" : "HTTP"); EVEL_INFO("Event Source Type is: %d", source_type); EVEL_INFO("Functional Role is: %s", role); EVEL_INFO("Log verbosity is: %d", verbosity); /***************************************************************************/ /* Initialize event throttling to the default state. */ /***************************************************************************/ evel_throttle_initialize(); /***************************************************************************/ /* Save values we will need during operation. */ /***************************************************************************/ event_source_type = source_type; functional_role = strdup(role); /***************************************************************************/ /* Ensure there are no trailing zeroes and unnecessary decimal points in */ /* the version. */ /***************************************************************************/ offset = sprintf(version_string, "%d", EVEL_API_MAJOR_VERSION); if (EVEL_API_MINOR_VERSION != 0) { sprintf(version_string + offset, ".%d", EVEL_API_MINOR_VERSION); } /***************************************************************************/ /* Build a common base of the API URLs. */ /***************************************************************************/ strcpy(path_url, "/"); snprintf(base_api_url, EVEL_MAX_URL_LEN, "%s://%s:%d%s/eventListener/v%s", secure ? "https" : "http", fqdn, port, (((path != NULL) && (strlen(path) > 0)) ? strncat(path_url, path, EVEL_MAX_URL_LEN) : ""), version_string); /***************************************************************************/ /* Build the URL to the event API. */ /***************************************************************************/ strcpy(topic_url, "/"); snprintf(event_api_url, EVEL_MAX_URL_LEN, "%s%s", base_api_url, (((topic != NULL) && (strlen(topic) > 0)) ? strncat(topic_url, topic, EVEL_MAX_URL_LEN) : "")); EVEL_INFO("Vendor Event Listener API is located at: %s", event_api_url); /***************************************************************************/ /* Build the URL to the throttling API. */ /***************************************************************************/ snprintf(throt_api_url, EVEL_MAX_URL_LEN, "%s/clientThrottlingState", base_api_url); EVEL_INFO("Vendor Event Throttling API is located at: %s", throt_api_url); /***************************************************************************/ /* Spin-up the event-handler, which gets cURL readied for use. */ /***************************************************************************/ rc = event_handler_initialize(event_api_url, throt_api_url, username, password, verbosity); if (rc != EVEL_SUCCESS) { log_error_state("Failed to initialize event handler (including cURL)"); goto exit_label; } /***************************************************************************/ /* Extract the metadata from OpenStack. If we fail to extract it, we */ /* record that in the logs, but carry on, assuming we're in a test */ /* without a metadata service. */ /***************************************************************************/ rc = openstack_metadata(verbosity); if (rc != EVEL_SUCCESS) { EVEL_INFO("Failed to load OpenStack metadata - assuming test environment"); rc = EVEL_SUCCESS; } /***************************************************************************/ /* Start the event handler thread. */ /***************************************************************************/ rc = event_handler_run(); if (rc != EVEL_SUCCESS) { log_error_state("Failed to start event handler thread. " "Error code=%d", rc); goto exit_label; } exit_label: return(rc); } /**************************************************************************//** * Clean up the EVEL library. * * @note that at present don't expect Init/Term cycling not to leak memory! * * @returns Status code * @retval EVEL_SUCCESS On success * @retval "One of ::EVEL_ERR_CODES" On failure. *****************************************************************************/ EVEL_ERR_CODES evel_terminate(void) { int rc = EVEL_SUCCESS; /***************************************************************************/ /* First terminate any pending transactions in the event-posting thread. */ /***************************************************************************/ rc = event_handler_terminate(); if (rc != EVEL_SUCCESS) { log_error_state("Failed to terminate EVEL library cleanly!"); } /***************************************************************************/ /* Shut down the Event Handler library in a tidy manner. */ /***************************************************************************/ curl_global_cleanup(); /***************************************************************************/ /* Clean up allocated memory. */ /***************************************************************************/ free(functional_role); /***************************************************************************/ /* Clean up event throttling. */ /***************************************************************************/ evel_throttle_terminate(); EVEL_INFO("EVEL stopped"); return(rc); } /**************************************************************************//** * Free an event. * * Free off the event supplied. Will free all the contained allocated memory. * * @note It is safe to free a NULL pointer. *****************************************************************************/ void evel_free_event(void * event) { EVENT_HEADER * evt_ptr = event; EVEL_ENTER(); if (event != NULL) { /*************************************************************************/ /* Work out what kind of event we're dealing with so we can cast it */ /* appropriately. */ /*************************************************************************/ switch (evt_ptr->event_domain) { case EVEL_DOMAIN_INTERNAL: EVEL_DEBUG("Event is an Internal event at %lp", evt_ptr); evel_free_internal_event((EVENT_INTERNAL *) evt_ptr); memset(evt_ptr, 0, sizeof(EVENT_INTERNAL)); free(evt_ptr); break; case EVEL_DOMAIN_HEARTBEAT: EVEL_DEBUG("Event is a Heartbeat at %lp", evt_ptr); evel_free_header(evt_ptr); memset(evt_ptr, 0, sizeof(EVENT_HEADER)); free(evt_ptr); break; case EVEL_DOMAIN_FAULT: EVEL_DEBUG("Event is a Fault at %lp", evt_ptr); evel_free_fault((EVENT_FAULT *)evt_ptr); memset(evt_ptr, 0, sizeof(EVENT_FAULT)); free(evt_ptr); break; case EVEL_DOMAIN_MEASUREMENT: EVEL_DEBUG("Event is a Measurement at %lp", evt_ptr); evel_free_measurement((EVENT_MEASUREMENT *)evt_ptr); memset(evt_ptr, 0, sizeof(EVENT_MEASUREMENT)); free(evt_ptr); break; case EVEL_DOMAIN_MOBILE_FLOW: EVEL_DEBUG("Event is a Mobile Flow at %lp", evt_ptr); evel_free_mobile_flow((EVENT_MOBILE_FLOW *)evt_ptr); memset(evt_ptr, 0, sizeof(EVENT_MOBILE_FLOW)); free(evt_ptr); break; case EVEL_DOMAIN_REPORT: EVEL_DEBUG("Event is a Report at %lp", evt_ptr); evel_free_report((EVENT_REPORT *)evt_ptr); memset(evt_ptr, 0, sizeof(EVENT_REPORT)); free(evt_ptr); break; case EVEL_DOMAIN_SERVICE: EVEL_DEBUG("Event is a Service Event at %lp", evt_ptr); evel_free_service((EVENT_SERVICE *)evt_ptr); memset(evt_ptr, 0, sizeof(EVENT_SERVICE)); free(evt_ptr); break; case EVEL_DOMAIN_SIGNALING: EVEL_DEBUG("Event is a Signaling at %lp", evt_ptr); evel_free_signaling((EVENT_SIGNALING *)evt_ptr); memset(evt_ptr, 0, sizeof(EVENT_SIGNALING)); free(evt_ptr); break; case EVEL_DOMAIN_STATE_CHANGE: EVEL_DEBUG("Event is a State Change at %lp", evt_ptr); evel_free_state_change((EVENT_STATE_CHANGE *)evt_ptr); memset(evt_ptr, 0, sizeof(EVENT_STATE_CHANGE)); free(evt_ptr); break; case EVEL_DOMAIN_SYSLOG: EVEL_DEBUG("Event is a Syslog at %lp", evt_ptr); evel_free_syslog((EVENT_SYSLOG *)evt_ptr); memset(evt_ptr, 0, sizeof(EVENT_SYSLOG)); free(evt_ptr); break; case EVEL_DOMAIN_OTHER: EVEL_DEBUG("Event is an Other at %lp", evt_ptr); evel_free_other((EVENT_OTHER *)evt_ptr); memset(evt_ptr, 0, sizeof(EVENT_OTHER)); free(evt_ptr); break; default: EVEL_ERROR("Unexpected event domain (%d)", evt_ptr->event_domain); assert(0); } } EVEL_EXIT(); }