| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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 <stdlib.h> |
| #include <string.h> |
| |
| #include "celix_shell_constants.h" |
| #include "celix_bundle_context.h" |
| #include "celix_dependency_manager.h" |
| |
| |
| static const char * const OK_COLOR = "\033[92m"; |
| static const char * const WARNING_COLOR = "\033[93m"; |
| static const char * const NOK_COLOR = "\033[91m"; |
| static const char * const END_COLOR = "\033[m"; |
| |
| void printInactiveBundles(FILE *out, celix_dependency_manager_t *mng, bool useColors); |
| |
| void printSpecifiedBundles(FILE *out, celix_dependency_manager_t *mng, bool useColors, bool fullInfo, bool plantUmlInfo); |
| |
| void printAllBundles(FILE *out, celix_dependency_manager_t *mng, bool useColors, const celix_array_list_t *bundleIds, |
| bool fullInfo, bool plantUmlInfo); |
| |
| static void printPlantUmlInfo(FILE *out, celix_dependency_manager_t *mng); |
| static void printUmlComponents(FILE *out, const celix_array_list_t *infos); |
| |
| static void printUmlDependencies(FILE *out, const celix_array_list_t *infos); |
| |
| |
| static void parseCommandLine(const char*line, celix_array_list_t **requestedBundleIds, bool *fullInfo, bool *plantUmlInfo, bool *wtf, FILE *err) { |
| *fullInfo = false; |
| *wtf = false; |
| char *str = strdup(line); |
| // skip first argument since this is the command |
| strtok(str," "); |
| char* tok = strtok(NULL," "); |
| *requestedBundleIds = celix_arrayList_create(); |
| while (tok) { |
| if (strncmp("wtf", tok, strlen("wtf")) == 0) { |
| *wtf = true; |
| } else if (tok[0] == 'f') { // f or full argument => show full info |
| *fullInfo = true; |
| } else if (tok[0] == 'u') { // u or full plant UML syntax output =>copy paste in a file java -jar plantuml.jar <file> gives a nice dependency graph |
| *plantUmlInfo = true; |
| } else if ( (tok[0] >= '0') && (tok[0] <= '9')) { // bundle id |
| long id = strtol(tok, NULL, 10); |
| celix_arrayList_addLong(*requestedBundleIds, id); |
| } else { |
| fprintf (err, "DM: Skipping unknown argument: %s", tok ); |
| } |
| tok = strtok(NULL," "); |
| } |
| free (str); |
| } |
| |
| static void printFullInfo(FILE *out, bool colors, long bundleId, const char* bndName, dm_component_info_pt compInfo) { |
| const char *startColors = ""; |
| const char *endColors = ""; |
| if (colors) { |
| startColors = compInfo->active ? OK_COLOR : NOK_COLOR; |
| endColors = END_COLOR; |
| } |
| fprintf(out, "%sComponent: Name=%s%s\n", startColors, compInfo->name, endColors); |
| fprintf(out, "|- UUID = %s\n", compInfo->id); |
| fprintf(out, "|- Active = %s\n", compInfo->active ? "true" : "false"); |
| fprintf(out, "|- State = %s\n", compInfo->state); |
| fprintf(out, "|- Bundle = %li (%s)\n", bundleId, bndName); |
| fprintf(out, "|- Nr of times started = %i\n", (int)compInfo->nrOfTimesStarted); |
| fprintf(out, "|- Nr of times resumed = %i\n", (int)compInfo->nrOfTimesResumed); |
| |
| fprintf(out, "|- Interfaces (%d):\n", celix_arrayList_size(compInfo->interfaces)); |
| for (int interfCnt = 0; interfCnt < celix_arrayList_size(compInfo->interfaces); interfCnt++) { |
| dm_interface_info_pt intfInfo = celix_arrayList_get(compInfo->interfaces, interfCnt); |
| fprintf(out, " |- %sInterface %i: %s%s\n", startColors, (interfCnt+1), intfInfo->name, endColors); |
| |
| hash_map_iterator_t iter = hashMapIterator_construct((hash_map_pt) intfInfo->properties); |
| char *key = NULL; |
| while ((key = hashMapIterator_nextKey(&iter)) != NULL) { |
| fprintf(out, " | %15s = %s\n", key, celix_properties_get(intfInfo->properties, key, "!ERROR!")); |
| } |
| } |
| |
| fprintf(out, "|- Dependencies (%d):\n", celix_arrayList_size(compInfo->dependency_list)); |
| for (int depCnt = 0; depCnt < celix_arrayList_size(compInfo->dependency_list); ++depCnt) { |
| dm_service_dependency_info_pt dependency; |
| dependency = celix_arrayList_get(compInfo->dependency_list, depCnt); |
| const char *depStartColors = ""; |
| if (colors) { |
| if (dependency->required) { |
| depStartColors = dependency->available ? OK_COLOR : NOK_COLOR; |
| } else { |
| depStartColors = dependency->available ? OK_COLOR : WARNING_COLOR; |
| } |
| } |
| fprintf(out, " |- %sDependency %i: %s%s\n", depStartColors, (depCnt+1), dependency->serviceName == NULL ? "(any)" : dependency->serviceName, endColors); |
| fprintf(out, " | %15s = %s\n", "Available", dependency->available ? "true " : "false"); |
| fprintf(out, " | %15s = %s\n", "Required", dependency->required ? "true " : "false"); |
| fprintf(out, " | %15s = %s\n", "Version Range", dependency->versionRange == NULL ? "N/A" : dependency->versionRange); |
| fprintf(out, " | %15s = %s\n", "Filter", dependency->filter == NULL ? "N/A" : dependency->filter); |
| } |
| fprintf(out, "\n"); |
| |
| } |
| static void printPlantUmlInfo(FILE *out, celix_dependency_manager_t *mng) { |
| |
| celix_array_list_t *infos = celix_dependencyManager_createInfos(mng); |
| |
| fprintf(out, "@startuml\n"); |
| |
| printUmlComponents(out, infos); |
| printUmlDependencies(out, infos); |
| |
| fprintf(out, "@enduml\n"); |
| |
| celix_dependencyManager_destroyInfos(mng, infos); |
| |
| } |
| |
| static void printUmlComponents(FILE *out, const celix_array_list_t *infos) { |
| unsigned int nof_bundles = celix_arrayList_size(infos); |
| for (int bnd = 0; bnd < nof_bundles; ++bnd) { |
| celix_dependency_manager_info_t *info = celix_arrayList_get(infos, bnd); |
| for (int cmpCnt = 0; cmpCnt < celix_arrayList_size(info->components); ++cmpCnt) { |
| celix_dm_component_info_t *compInfo = celix_arrayList_get(info->components, cmpCnt); |
| fprintf(out, "class %s\n", compInfo->name); |
| for (int interfCnt = 0; interfCnt < celix_arrayList_size(compInfo->interfaces); interfCnt++) { |
| dm_interface_info_pt intfInfo = celix_arrayList_get(compInfo->interfaces, interfCnt); |
| fprintf(out, "interface %s\n", intfInfo->name); |
| } |
| } |
| } |
| // depdencies at last, since the type overwrites the interface for a nice graph |
| for (int bnd = 0; bnd < nof_bundles; ++bnd) { |
| celix_dependency_manager_info_t *info = celix_arrayList_get(infos, bnd); |
| for (int cmpCnt = 0; cmpCnt < celix_arrayList_size(info->components); ++cmpCnt) { |
| celix_dm_component_info_t *compInfo = celix_arrayList_get(info->components, cmpCnt); |
| for (int depCnt = 0; depCnt < celix_arrayList_size(compInfo->dependency_list); ++depCnt) { |
| dm_service_dependency_info_pt dependency; |
| dependency = celix_arrayList_get(compInfo->dependency_list, depCnt); |
| fprintf(out, "interface %s\n", dependency->serviceName); |
| } |
| } |
| } |
| fprintf(out, "\n"); |
| } |
| |
| |
| static void printUmlDependencies(FILE *out, const celix_array_list_t *infos) { |
| unsigned int nof_bundles = celix_arrayList_size(infos); |
| |
| // Now print the UML relations |
| for (int bnd = 0; bnd < nof_bundles; ++bnd) { |
| celix_dependency_manager_info_t *info = celix_arrayList_get(infos, bnd); |
| for (int cmpCnt = 0; cmpCnt < celix_arrayList_size(info->components); ++cmpCnt) { |
| celix_dm_component_info_t *compInfo = celix_arrayList_get(info->components, cmpCnt); |
| for (int interfCnt = 0; interfCnt < celix_arrayList_size(compInfo->interfaces); interfCnt++) { |
| dm_interface_info_pt intfInfo = celix_arrayList_get(compInfo->interfaces, interfCnt); |
| fprintf(out, "%s --|> %s\n", compInfo->name, intfInfo->name); |
| } |
| for (int depCnt = 0; depCnt < celix_arrayList_size(compInfo->dependency_list); ++depCnt) { |
| dm_service_dependency_info_pt dependency; |
| dependency = celix_arrayList_get(compInfo->dependency_list, depCnt); |
| if (dependency->available) { |
| fprintf(out, "%s *--> %s\n", compInfo->name, dependency->serviceName); |
| } else if (dependency->required) { |
| fprintf(out, "%s *..> %s\n", compInfo->name, dependency->serviceName); |
| } else { |
| fprintf(out, "%s ..> %s\n", compInfo->name, dependency->serviceName); |
| } |
| } |
| } |
| } |
| } |
| |
| |
| static void printBasicInfo(FILE *out, bool colors, long bundleId, const char* bndName, dm_component_info_pt compInfo) { |
| const char *startColors = ""; |
| const char *endColors = ""; |
| if (colors) { |
| startColors = compInfo->active ? OK_COLOR : NOK_COLOR; |
| endColors = END_COLOR; |
| } |
| fprintf(out, "Component: Name=%s, ID=%s, %sActive=%s%s, State=%s, Bundle=%li (%s)\n", compInfo->name, compInfo->id, |
| startColors, compInfo->active ? "true " : "false", endColors, compInfo->state, bundleId, bndName); |
| |
| } |
| |
| static void dm_printInfo(FILE *out, bool useColors, bool fullInfo, celix_dependency_manager_info_t *info) { |
| if (info != NULL) { |
| int size = celix_arrayList_size(info->components); |
| if (size > 0) { |
| for ( int cmpCnt = 0; cmpCnt < size; cmpCnt++) { |
| dm_component_info_pt compInfo = celix_arrayList_get(info->components, cmpCnt); |
| if (fullInfo) { |
| printFullInfo(out, useColors, info->bndId, info->bndSymbolicName, compInfo); |
| } else { |
| printBasicInfo(out, useColors, info->bndId, info->bndSymbolicName, compInfo); |
| } |
| } |
| fprintf(out, "\n"); |
| |
| } |
| } |
| } |
| |
| celix_status_t dmListCommand_execute(void* handle, char * line, FILE *out, FILE *err) { |
| celix_bundle_context_t *ctx = handle; |
| celix_dependency_manager_t *mng = celix_bundleContext_getDependencyManager(ctx); |
| |
| const char *config = NULL; |
| bundleContext_getPropertyWithDefault(ctx, CELIX_SHELL_USE_ANSI_COLORS, CELIX_SHELL_USE_ANSI_COLORS_DEFAULT_VALUE, &config); |
| bool useColors = config != NULL && strncmp("true", config, 5) == 0; |
| |
| celix_array_list_t *bundleIds = NULL; |
| bool fullInfo = false; |
| bool plantUmlInfo = false; |
| bool wtf = false; |
| parseCommandLine(line, &bundleIds, &fullInfo, &plantUmlInfo, &wtf, err); |
| |
| if (wtf) { |
| printInactiveBundles(out, mng, useColors); |
| } else if (plantUmlInfo) { |
| printPlantUmlInfo(out, mng); |
| } else if (celix_arrayList_size(bundleIds) == 0) { |
| printSpecifiedBundles(out, mng, useColors, fullInfo, plantUmlInfo); |
| } else { |
| printAllBundles(out, mng, useColors, bundleIds, fullInfo, plantUmlInfo); |
| } |
| |
| celix_arrayList_destroy(bundleIds); |
| |
| return CELIX_SUCCESS; |
| } |
| |
| void printAllBundles(FILE *out, celix_dependency_manager_t *mng, bool useColors, const celix_array_list_t *bundleIds, |
| bool fullInfo, bool plantUmlInfo) { |
| for (int i = 0; i < celix_arrayList_size(bundleIds); ++i) { |
| long bndId = celix_arrayList_getLong(bundleIds, i); |
| celix_dependency_manager_info_t *info = celix_dependencyManager_createInfo(mng, bndId); |
| if (info != NULL) { |
| dm_printInfo(out, useColors, fullInfo, info); |
| celix_dependencyManager_destroyInfo(mng, info); |
| } |
| } |
| } |
| |
| void printSpecifiedBundles(FILE *out, celix_dependency_manager_t *mng, bool useColors, bool fullInfo, bool plantUmlInfo) { |
| celix_array_list_t *infos = celix_dependencyManager_createInfos(mng); |
| if (plantUmlInfo) { |
| printPlantUmlInfo(out, mng); |
| } else { |
| for (int i = 0; i < celix_arrayList_size(infos); ++i) { |
| celix_dependency_manager_info_t *info = celix_arrayList_get(infos, i); |
| dm_printInfo(out, useColors, fullInfo, info); |
| } |
| } |
| celix_dependencyManager_destroyInfos(mng, infos); |
| } |
| |
| void |
| printInactiveBundles(FILE *out, celix_dependency_manager_t *mng, bool useColors) {//only print dm that are not active |
| bool allActive = true; |
| int nrOfComponents = 0; |
| celix_array_list_t *infos = celix_dependencyManager_createInfos(mng); |
| for (int i = 0; i < celix_arrayList_size(infos); ++i) { |
| celix_dependency_manager_info_t *info = celix_arrayList_get(infos, i); |
| for (int k = 0; k < celix_arrayList_size(info->components); ++k) { |
| celix_dm_component_info_t *cmpInfo = celix_arrayList_get(info->components, k); |
| nrOfComponents += 1; |
| if (!cmpInfo->active) { |
| allActive = false; |
| printFullInfo(out, useColors, info->bndId, info->bndSymbolicName, cmpInfo); |
| } |
| } |
| } |
| celix_dependencyManager_destroyInfos(mng, infos); |
| if (allActive) { |
| fprintf(out, "No problem all %i dependency manager components are active\n", nrOfComponents); |
| } |
| } |
