You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@celix.apache.org by pn...@apache.org on 2017/11/20 20:33:02 UTC
[05/46] celix git commit: CELIX-417: Initial refactoring for CMake
usage
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/shell/src/activator.c
----------------------------------------------------------------------
diff --git a/shell/src/activator.c b/shell/src/activator.c
new file mode 100644
index 0000000..ac298d8
--- /dev/null
+++ b/shell/src/activator.c
@@ -0,0 +1,269 @@
+/**
+ *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.
+ */
+/*
+ * activator.c
+ *
+ * \date Aug 13, 2010
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+#include <stdlib.h>
+#include <string.h>
+
+#include "shell_private.h"
+#include "bundle_activator.h"
+#include "std_commands.h"
+#include "service_tracker.h"
+#include "constants.h"
+
+#define NUMBER_OF_COMMANDS 10
+
+struct command {
+ celix_status_t (*exec)(void *handle, char *commandLine, FILE *out, FILE *err);
+ char *name;
+ char *description;
+ char *usage;
+ command_service_pt service;
+ service_registration_pt reg;
+ properties_pt props;
+};
+
+struct bundle_instance {
+ shell_service_pt shellService;
+ service_registration_pt registration;
+ service_tracker_pt tracker;
+
+ struct command std_commands[NUMBER_OF_COMMANDS];
+};
+
+typedef struct bundle_instance *bundle_instance_pt;
+
+celix_status_t bundleActivator_create(bundle_context_pt context_ptr, void **_pptr) {
+ celix_status_t status = CELIX_SUCCESS;
+
+ bundle_instance_pt instance_ptr = NULL;
+
+ if (!_pptr || !context_ptr) {
+ status = CELIX_ENOMEM;
+ }
+
+ if (status == CELIX_SUCCESS) {
+ instance_ptr = (bundle_instance_pt) calloc(1, sizeof(struct bundle_instance));
+ if (!instance_ptr) {
+ status = CELIX_ENOMEM;
+ }
+ }
+
+ if (status == CELIX_SUCCESS) {
+ status = shell_create(context_ptr, &instance_ptr->shellService);
+ }
+
+ if (status == CELIX_SUCCESS) {
+ instance_ptr->std_commands[0] =
+ (struct command) {
+ .exec = psCommand_execute,
+ .name = "lb",
+ .description = "list bundles.",
+ .usage = "lb [-l | -s | -u]"
+ };
+ instance_ptr->std_commands[1] =
+ (struct command) {
+ .exec = startCommand_execute,
+ .name = "start",
+ .description = "start bundle(s).",
+ .usage = "start <id> [<id> ...]"
+ };
+ instance_ptr->std_commands[2] =
+ (struct command) {
+ .exec = stopCommand_execute,
+ .name = "stop",
+ .description = "stop bundle(s).",
+ .usage = "stop <id> [<id> ...]"
+ };
+ instance_ptr->std_commands[3] =
+ (struct command) {
+ .exec = installCommand_execute,
+ .name = "install",
+ .description = "install bundle(s).",
+ .usage = "install <file> [<file> ...]"
+ };
+ instance_ptr->std_commands[4] =
+ (struct command) {
+ .exec = uninstallCommand_execute,
+ .name = "uninstall",
+ .description = "uninstall bundle(s).",
+ .usage = "uninstall <file> [<file> ...]"
+ };
+ instance_ptr->std_commands[5] =
+ (struct command) {
+ .exec = updateCommand_execute,
+ .name = "update",
+ .description = "update bundle(s).",
+ .usage = "update <id> [<URL>]"
+ };
+ instance_ptr->std_commands[6] =
+ (struct command) {
+ .exec = helpCommand_execute,
+ .name = "help",
+ .description = "display available commands and description.",
+ .usage = "help <command>]"
+ };
+ instance_ptr->std_commands[7] =
+ (struct command) {
+ .exec = logCommand_execute,
+ .name = "log",
+ .description = "print log.",
+ .usage = "log"
+ };
+ instance_ptr->std_commands[8] =
+ (struct command) {
+ .exec = inspectCommand_execute,
+ .name = "inspect",
+ .description = "inspect services and components.",
+ .usage = "inspect (service) (capability|requirement) [<id> ...]"
+ };
+ instance_ptr->std_commands[9] =
+ (struct command) { NULL, NULL, NULL, NULL, NULL, NULL, NULL }; /*marker for last element*/
+
+ unsigned int i = 0;
+ while (instance_ptr->std_commands[i].exec != NULL) {
+ instance_ptr->std_commands[i].props = properties_create();
+ if (!instance_ptr->std_commands[i].props) {
+ status = CELIX_BUNDLE_EXCEPTION;
+ break;
+ }
+
+ properties_set(instance_ptr->std_commands[i].props, OSGI_SHELL_COMMAND_NAME, instance_ptr->std_commands[i].name);
+ properties_set(instance_ptr->std_commands[i].props, OSGI_SHELL_COMMAND_USAGE, instance_ptr->std_commands[i].usage);
+ properties_set(instance_ptr->std_commands[i].props, OSGI_SHELL_COMMAND_DESCRIPTION, instance_ptr->std_commands[i].description);
+ properties_set(instance_ptr->std_commands[i].props, CELIX_FRAMEWORK_SERVICE_LANGUAGE, CELIX_FRAMEWORK_SERVICE_C_LANGUAGE);
+
+ instance_ptr->std_commands[i].service = calloc(1, sizeof(*instance_ptr->std_commands[i].service));
+ if (!instance_ptr->std_commands[i].service) {
+ status = CELIX_ENOMEM;
+ break;
+ }
+
+ instance_ptr->std_commands[i].service->handle = context_ptr;
+ instance_ptr->std_commands[i].service->executeCommand = instance_ptr->std_commands[i].exec;
+
+ i += 1;
+ }
+ }
+
+ if (status == CELIX_SUCCESS) {
+ *_pptr = instance_ptr;
+ }
+
+
+ if (status != CELIX_SUCCESS) {
+ bundleActivator_destroy(instance_ptr, context_ptr);
+ }
+
+ return status;
+}
+
+celix_status_t bundleActivator_start(void *_ptr, bundle_context_pt context_ptr) {
+ celix_status_t status = CELIX_SUCCESS;
+
+ bundle_instance_pt instance_ptr = (bundle_instance_pt) _ptr;
+
+ if (!instance_ptr || !context_ptr) {
+ status = CELIX_ILLEGAL_ARGUMENT;
+ }
+
+ if (status == CELIX_SUCCESS) {
+ properties_pt props = properties_create();
+ properties_set(props, CELIX_FRAMEWORK_SERVICE_LANGUAGE, CELIX_FRAMEWORK_SERVICE_C_LANGUAGE);
+ status = bundleContext_registerService(context_ptr, (char *) OSGI_SHELL_SERVICE_NAME, instance_ptr->shellService, props, &instance_ptr->registration);
+ }
+
+ if (status == CELIX_SUCCESS) {
+ service_tracker_customizer_pt cust = NULL;
+ serviceTrackerCustomizer_create(instance_ptr->shellService->shell, NULL, (void *)shell_addCommand, NULL, (void *)shell_removeCommand, &cust);
+ serviceTracker_create(context_ptr, (char *)OSGI_SHELL_COMMAND_SERVICE_NAME, cust, &instance_ptr->tracker);
+ serviceTracker_open(instance_ptr->tracker);
+ }
+
+
+ if (status == CELIX_SUCCESS) {
+ for (unsigned int i = 0; instance_ptr->std_commands[i].exec != NULL; i++) {
+ status = bundleContext_registerService(context_ptr, (char *) OSGI_SHELL_COMMAND_SERVICE_NAME,
+ instance_ptr->std_commands[i].service,
+ instance_ptr->std_commands[i].props,
+ &instance_ptr->std_commands[i].reg);
+ if (status != CELIX_SUCCESS) {
+ break;
+ }
+
+ }
+ }
+
+ return status;
+}
+
+celix_status_t bundleActivator_stop(void *_ptr, bundle_context_pt context_ptr) {
+ celix_status_t status = CELIX_SUCCESS;
+
+ bundle_instance_pt instance_ptr = (bundle_instance_pt) _ptr;
+
+ if (instance_ptr) {
+ for (unsigned int i = 0; instance_ptr->std_commands[i].exec != NULL; i++) {
+ if (instance_ptr->std_commands[i].reg != NULL) {
+ status = serviceRegistration_unregister(instance_ptr->std_commands[i].reg);
+ instance_ptr->std_commands[i].reg = NULL;
+ instance_ptr->std_commands[i].props = NULL;
+ }
+ }
+
+ if (instance_ptr->tracker != NULL) {
+ serviceTracker_close(instance_ptr->tracker);
+ }
+ } else {
+ status = CELIX_ILLEGAL_ARGUMENT;
+ }
+
+ return status;
+}
+
+celix_status_t bundleActivator_destroy(void *_ptr, bundle_context_pt __attribute__((__unused__)) context_ptr) {
+ celix_status_t status = CELIX_SUCCESS;
+
+ bundle_instance_pt instance_ptr = (bundle_instance_pt) _ptr;
+
+ if (instance_ptr) {
+ serviceRegistration_unregister(instance_ptr->registration);
+
+ for (unsigned int i = 0; instance_ptr->std_commands[i].exec != NULL; i++) {
+ free(instance_ptr->std_commands[i].service);
+ }
+
+ shell_destroy(&instance_ptr->shellService);
+
+ if (instance_ptr->tracker != NULL) {
+ serviceTracker_destroy(instance_ptr->tracker);
+ }
+
+ free(instance_ptr);
+ } else {
+ status = CELIX_ILLEGAL_ARGUMENT;
+ }
+
+ return status;
+}
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/shell/src/help_command.c
----------------------------------------------------------------------
diff --git a/shell/src/help_command.c b/shell/src/help_command.c
new file mode 100644
index 0000000..48615ae
--- /dev/null
+++ b/shell/src/help_command.c
@@ -0,0 +1,112 @@
+/**
+ *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.
+ */
+/*
+ * help_command.c
+ *
+ * \date Aug 20, 2010
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#include "array_list.h"
+#include "bundle_context.h"
+#include "shell.h"
+#include "std_commands.h"
+
+celix_status_t helpCommand_execute(void *_ptr, char *line_str, FILE *out_ptr, FILE *err_ptr) {
+ celix_status_t status = CELIX_SUCCESS;
+
+ bundle_context_pt context_ptr = _ptr;
+ service_reference_pt shell_service_reference_ptr = NULL;
+ shell_service_pt shell_ptr = NULL;
+
+ if (!context_ptr || !line_str || !out_ptr || !err_ptr) {
+ status = CELIX_ILLEGAL_ARGUMENT;
+ }
+
+ if (status == CELIX_SUCCESS) {
+ status = bundleContext_getServiceReference(context_ptr, (char *) OSGI_SHELL_SERVICE_NAME, &shell_service_reference_ptr);
+ }
+
+ if (status == CELIX_SUCCESS) {
+ status = bundleContext_getService(context_ptr, shell_service_reference_ptr, (void **) &shell_ptr);
+ }
+
+ if (status == CELIX_SUCCESS) {
+ uint32_t out_len = 256;
+ char *sub = NULL;
+ char *save_ptr = NULL;
+ char out_str[out_len];
+
+ memset(out_str, 0, sizeof(out_str));
+
+ strtok_r(line_str, OSGI_SHELL_COMMAND_SEPARATOR, &save_ptr);
+ sub = strtok_r(NULL, OSGI_SHELL_COMMAND_SEPARATOR, &save_ptr);
+
+ if (sub == NULL) {
+ unsigned int i;
+ array_list_pt commands = NULL;
+
+ status = shell_ptr->getCommands(shell_ptr->shell, &commands);
+ for (i = 0; i < arrayList_size(commands); i++) {
+ char *name = arrayList_get(commands, i);
+ fprintf(out_ptr, "%s\n", name);
+ }
+ fprintf(out_ptr, "\nUse 'help <command-name>' for more information.\n");
+ arrayList_destroy(commands);
+ } else {
+ celix_status_t sub_status_desc;
+ celix_status_t sub_status_usage;
+ int i;
+ array_list_pt commands = NULL;
+ shell_ptr->getCommands(shell_ptr->shell, &commands);
+ for (i = 0; i < arrayList_size(commands); i++) {
+ char *name = arrayList_get(commands, i);
+ if (strcmp(sub, name) == 0) {
+ char *usage_str = NULL;
+ char *desc_str = NULL;
+
+ sub_status_desc = shell_ptr->getCommandDescription(shell_ptr->shell, name, &desc_str);
+ sub_status_usage = shell_ptr->getCommandUsage(shell_ptr->shell, name, &usage_str);
+
+ if (sub_status_usage == CELIX_SUCCESS && sub_status_desc == CELIX_SUCCESS) {
+ fprintf(out_ptr, "Command : %s\n", name);
+ fprintf(out_ptr, "Usage : %s\n", usage_str == NULL ? "" : usage_str);
+ fprintf(out_ptr, "Description : %s\n", desc_str == NULL ? "" : desc_str);
+ } else {
+ fprintf(err_ptr, "Error retreiving help info for command '%s'\n", sub);
+ }
+
+ if (sub_status_desc != CELIX_SUCCESS && status == CELIX_SUCCESS) {
+ status = sub_status_desc;
+ }
+ if (sub_status_usage != CELIX_SUCCESS && status == CELIX_SUCCESS) {
+ status = sub_status_usage;
+ }
+ }
+ }
+ arrayList_destroy(commands);
+ }
+ }
+
+ return status;
+}
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/shell/src/inspect_command.c
----------------------------------------------------------------------
diff --git a/shell/src/inspect_command.c b/shell/src/inspect_command.c
new file mode 100644
index 0000000..cb93e9c
--- /dev/null
+++ b/shell/src/inspect_command.c
@@ -0,0 +1,277 @@
+/**
+ *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.
+ */
+/*
+ * inspect_command.c
+ *
+ * \date Oct 13, 2011
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "array_list.h"
+#include "bundle_context.h"
+
+#include "std_commands.h"
+
+#define SERVICE_TYPE "service"
+#define CAPABILITY "capability"
+#define REQUIREMENT "requirement"
+
+celix_status_t inspectCommand_printExportedServices(bundle_context_pt context, array_list_pt ids, FILE *outStream, FILE *errStream);
+celix_status_t inspectCommand_printImportedServices(bundle_context_pt context, array_list_pt ids, FILE *outStream, FILE *errStream);
+
+celix_status_t inspectCommand_execute(void *handle, char * commandline, FILE *outStream, FILE *errStream) {
+ celix_status_t status = CELIX_SUCCESS;
+
+ bundle_context_pt context = handle;
+
+ char *token;
+ strtok_r(commandline, " ", &token);
+ char *type = strtok_r(NULL, " ", &token);
+ if (type != NULL) {
+ char *direction = strtok_r(NULL, " ", &token);
+ if (direction != NULL) {
+ array_list_pt ids = NULL;
+ char *id = strtok_r(NULL, " ", &token);
+
+ arrayList_create(&ids);
+ while (id != NULL) {
+ arrayList_add(ids, id);
+ id = strtok_r(NULL, " ", &token);
+ }
+
+ if (strcmp(type, SERVICE_TYPE) == 0) {
+ if (strcmp(direction, CAPABILITY) == 0) {
+ status = inspectCommand_printExportedServices(context, ids, outStream, errStream);
+ if (status != CELIX_SUCCESS) {
+ fprintf(errStream, "INSPECT: Error\n");
+ }
+ } else if (strcmp(direction, REQUIREMENT) == 0) {
+ status = inspectCommand_printImportedServices(context, ids, outStream, errStream);
+ if (status != CELIX_SUCCESS) {
+ fprintf(errStream, "INSPECT: Error\n");
+ }
+ } else {
+ fprintf(errStream, "INSPECT: Invalid argument\n");
+ }
+ } else {
+ fprintf(errStream, "INSPECT: Invalid argument\n");
+ }
+ arrayList_destroy(ids);
+ } else {
+ fprintf(errStream, "INSPECT: Too few arguments\n");
+ }
+ } else {
+ fprintf(errStream, "INSPECT: Too few arguments\n");
+ }
+ return status;
+}
+
+celix_status_t inspectCommand_printExportedServices(bundle_context_pt context, array_list_pt ids, FILE *outStream, FILE *errStream) {
+ celix_status_t status = CELIX_SUCCESS;
+ array_list_pt bundles = NULL;
+
+ if (arrayList_isEmpty(ids)) {
+ status = bundleContext_getBundles(context, &bundles);
+ } else {
+ unsigned int i;
+
+ arrayList_create(&bundles);
+ for (i = 0; i < arrayList_size(ids); i++) {
+ char *idStr = (char *) arrayList_get(ids, i);
+ long id = atol(idStr);
+ bundle_pt b = NULL;
+ celix_status_t st = bundleContext_getBundleById(context, id, &b);
+ if (st == CELIX_SUCCESS) {
+ arrayList_add(bundles, b);
+ } else {
+ fprintf(outStream, "INSPECT: Invalid bundle ID: %ld\n", id);
+ }
+ }
+ }
+
+ if (status == CELIX_SUCCESS) {
+ unsigned int i = 0;
+ for (i = 0; i < arrayList_size(bundles); i++) {
+ bundle_pt bundle = (bundle_pt) arrayList_get(bundles, i);
+
+ if (i > 0) {
+ fprintf(outStream, "\n");
+ }
+
+ if (bundle != NULL) {
+ array_list_pt refs = NULL;
+
+ if (bundle_getRegisteredServices(bundle, &refs) == CELIX_SUCCESS) {
+ module_pt module = NULL;
+ const char * name = NULL;
+ status = bundle_getCurrentModule(bundle, &module);
+ if (status == CELIX_SUCCESS) {
+ status = module_getSymbolicName(module, &name);
+ if (status == CELIX_SUCCESS) {
+ fprintf(outStream, "%s provides services:\n", name);
+ fprintf(outStream, "==============\n");
+
+ if (refs == NULL || arrayList_size(refs) == 0) {
+ fprintf(outStream, "Nothing\n");
+ } else {
+ unsigned int j = 0;
+ for (j = 0; j < arrayList_size(refs); j++) {
+ service_reference_pt ref = (service_reference_pt) arrayList_get(refs, j);
+ unsigned int size = 0;
+ char **keys;
+
+ serviceReference_getPropertyKeys(ref, &keys, &size);
+ for (int k = 0; k < size; k++) {
+ char *key = keys[k];
+ const char *value = NULL;
+ serviceReference_getProperty(ref, key, &value);
+
+ fprintf(outStream, "%s = %s\n", key, value);
+ }
+
+ free(keys);
+
+// objectClass = properties_get(props, (char *) OSGI_FRAMEWORK_OBJECTCLASS);
+// sprintf(line, "ObjectClass = %s\n", objectClass);
+ if ((j + 1) < arrayList_size(refs)) {
+ fprintf(outStream, "----\n");
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if(refs!=NULL){
+ arrayList_destroy(refs);
+ }
+ }
+ }
+ }
+
+ if (bundles != NULL) {
+ arrayList_destroy(bundles);
+ }
+
+ return status;
+}
+
+celix_status_t inspectCommand_printImportedServices(bundle_context_pt context, array_list_pt ids, FILE *outStream, FILE *errStream) {
+ celix_status_t status = CELIX_SUCCESS;
+ array_list_pt bundles = NULL;
+
+ if (arrayList_isEmpty(ids)) {
+ status = bundleContext_getBundles(context, &bundles);
+ } else {
+ unsigned int i;
+
+ arrayList_create(&bundles);
+ for (i = 0; i < arrayList_size(ids); i++) {
+ char *idStr = (char *) arrayList_get(ids, i);
+ long id = atol(idStr);
+ bundle_pt b = NULL;
+ celix_status_t st = bundleContext_getBundleById(context, id, &b);
+ if (st == CELIX_SUCCESS) {
+ arrayList_add(bundles, b);
+ } else {
+ fprintf(outStream, "INSPECT: Invalid bundle ID: %ld\n", id);
+ }
+ }
+ }
+
+ if (status == CELIX_SUCCESS) {
+ unsigned int i = 0;
+ for (i = 0; i < arrayList_size(bundles); i++) {
+ bundle_pt bundle = (bundle_pt) arrayList_get(bundles, i);
+
+ if (i > 0) {
+ fprintf(outStream, "\n");
+ }
+
+ if (bundle != NULL) {
+ array_list_pt refs = NULL;
+
+ if (bundle_getServicesInUse(bundle, &refs) == CELIX_SUCCESS) {
+ module_pt module = NULL;
+ const char * name = NULL;
+ status = bundle_getCurrentModule(bundle, &module);
+ if (status == CELIX_SUCCESS) {
+ status = module_getSymbolicName(module, &name);
+ if (status == CELIX_SUCCESS) {
+ fprintf(outStream, "%s requires services:\n", name);
+ fprintf(outStream, "==============\n");
+
+ if (refs == NULL || arrayList_size(refs) == 0) {
+ fprintf(outStream, "Nothing\n");
+ } else {
+ unsigned int j = 0;
+ for (j = 0; j < arrayList_size(refs); j++) {
+ service_reference_pt ref = (service_reference_pt) arrayList_get(refs, j);
+ bundle_pt usedBundle = NULL;
+ module_pt usedModule = NULL;
+ const char *usedSymbolicName = NULL;
+ long usedBundleId;
+
+ serviceReference_getBundle(ref, &usedBundle);
+ bundle_getBundleId(usedBundle, &usedBundleId);
+ bundle_getCurrentModule(usedBundle, &usedModule);
+ module_getSymbolicName(usedModule, &usedSymbolicName);
+
+ fprintf(outStream, "%s [%ld]\n", usedSymbolicName, usedBundleId);
+
+ unsigned int size = 0;
+ char **keys;
+
+ serviceReference_getPropertyKeys(ref, &keys, &size);
+ for (int k = 0; k < size; k++) {
+ char *key = keys[k];
+ const char *value = NULL;
+ serviceReference_getProperty(ref, key, &value);
+
+ fprintf(outStream, "%s = %s\n", key, value);
+ }
+ free(keys);
+
+// objectClass = properties_get(props, (char *) OSGI_FRAMEWORK_OBJECTCLASS);
+// sprintf(line, "ObjectClass = %s\n", objectClass);
+ if ((j + 1) < arrayList_size(refs)) {
+ fprintf(outStream, "----\n");
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if(refs!=NULL){
+ arrayList_destroy(refs);
+ }
+ }
+ }
+ }
+
+ arrayList_destroy(bundles);
+
+
+ return status;
+}
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/shell/src/install_command.c
----------------------------------------------------------------------
diff --git a/shell/src/install_command.c b/shell/src/install_command.c
new file mode 100644
index 0000000..067ba2b
--- /dev/null
+++ b/shell/src/install_command.c
@@ -0,0 +1,76 @@
+/**
+ *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.
+ */
+/*
+ * install_command.c
+ *
+ * \date Apr 4, 2011
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+#include <stdlib.h>
+#include <string.h>
+
+#include "array_list.h"
+#include "bundle_context.h"
+
+void installCommand_execute(void *handle, char * line, FILE *outStream, FILE *errStream) {
+ bundle_context_pt context = handle;
+
+ char delims[] = " ";
+ char * sub = NULL;
+ char *save_ptr = NULL;
+ char info[256];
+
+ // ignore the command
+ sub = strtok_r(line, delims, &save_ptr);
+ sub = strtok_r(NULL, delims, &save_ptr);
+
+ if (sub == NULL) {
+ fprintf(errStream, "Incorrect number of arguments.\n");
+ } else {
+ info[0] = '\0';
+ while (sub != NULL) {
+ bundle_pt bundle = NULL;
+ bundleContext_installBundle(context, sub, &bundle);
+ if (bundle != NULL) {
+ long id;
+ bundle_archive_pt archive = NULL;
+ char bundleId[sizeof(id) + 1];
+
+ if (strlen(info) > 0) {
+ strcat(info, ", ");
+ }
+ bundle_getArchive(bundle, &archive);
+ bundleArchive_getId(archive, &id);
+ sprintf(bundleId, "%ld", id);
+ strcat(info, bundleId);
+ }
+ sub = strtok_r(NULL, delims, &save_ptr);
+ }
+ if (strchr(info, ',') != NULL) {
+ fprintf(outStream, "Bundle IDs: ");
+ fprintf(outStream, "%s", info);
+ fprintf(outStream, "\n");
+ } else if (strlen(info) > 0) {
+ fprintf(outStream, "Bundle ID: ");
+ fprintf(outStream, "%s", info);
+ fprintf(outStream, "\n");
+ }
+ }
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/shell/src/lb_command.c
----------------------------------------------------------------------
diff --git a/shell/src/lb_command.c b/shell/src/lb_command.c
new file mode 100644
index 0000000..d0504f6
--- /dev/null
+++ b/shell/src/lb_command.c
@@ -0,0 +1,205 @@
+/**
+ *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.
+ */
+/*
+ * std_shell_commands.c
+ *
+ * \date March 27, 2014
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+#include <stdlib.h>
+#include <string.h>
+
+#include "array_list.h"
+#include "bundle_context.h"
+#include "std_commands.h"
+#include "shell_constants.h"
+
+static const char * const HEAD_COLOR = "\033[4m"; //underline
+static const char * const EVEN_COLOR = "\033[1m"; //bold
+static const char * const ODD_COLOR = "\033[3m"; //italic
+static const char * const END_COLOR = "\033[0m";
+
+static char * psCommand_stateString(bundle_state_e state);
+
+celix_status_t psCommand_execute(void *_ptr, char *command_line_str, FILE *out_ptr, FILE *err_ptr) {
+ celix_status_t status = CELIX_SUCCESS;
+ bundle_context_t* ctx = _ptr;
+
+ const char* config = NULL;
+ bundleContext_getPropertyWithDefault(ctx, SHELL_USE_ANSI_COLORS, SHELL_USE_ANSI_COLORS_DEFAULT_VALUE, &config);
+ bool useColors = config != NULL && strncmp("true", config, 5) == 0;
+
+ bundle_context_pt context_ptr = _ptr;
+ array_list_pt bundles_ptr = NULL;
+
+ bool show_location = false;
+ bool show_symbolic_name = false;
+ bool show_update_location = false;
+ char *message_str = "Name";
+
+ if (!context_ptr || !command_line_str || !out_ptr || !err_ptr) {
+ status = CELIX_ILLEGAL_ARGUMENT;
+ }
+
+ if (status == CELIX_SUCCESS) {
+ status = bundleContext_getBundles(context_ptr, &bundles_ptr);
+ }
+
+ if (status == CELIX_SUCCESS) {
+ char *sub_str = NULL;
+ char *save_ptr = NULL;
+
+ strtok_r(command_line_str, OSGI_SHELL_COMMAND_SEPARATOR, &save_ptr);
+ sub_str = strtok_r(NULL, OSGI_SHELL_COMMAND_SEPARATOR, &save_ptr);
+ while (sub_str != NULL) {
+ if (strcmp(sub_str, "-l") == 0) {
+ show_location = true;
+ message_str = "Location";
+ } else if (strcmp(sub_str, "-s") == 0) {
+ show_symbolic_name = true;
+ message_str = "Symbolic name";
+ } else if (strcmp(sub_str, "-u") == 0) {
+ show_update_location = true;
+ message_str = "Update location";
+ }
+ sub_str = strtok_r(NULL, OSGI_SHELL_COMMAND_SEPARATOR, &save_ptr);
+ }
+
+ const char* startColor = "";
+ const char* endColor = "";
+ if (useColors) {
+ startColor = HEAD_COLOR;
+ endColor = END_COLOR;
+ }
+ fprintf(out_ptr, "%s %-5s %-12s %s%s\n", startColor, "ID", "State", message_str, endColor);
+
+ unsigned int size = arrayList_size(bundles_ptr);
+
+ bundle_pt bundles_array_ptr[size];
+
+ for (unsigned int i = 0; i < size; i++) {
+ bundles_array_ptr[i] = arrayList_get(bundles_ptr, i);
+ }
+
+ for (unsigned int i = 0; i < size - 1; i++) {
+ for (unsigned int j = i + 1; j < size; j++) {
+ bundle_pt first_ptr = bundles_array_ptr[i];
+ bundle_pt second_ptr = bundles_array_ptr[j];
+
+ bundle_archive_pt first_archive_ptr = NULL;
+ bundle_archive_pt second_archive_ptr = NULL;
+
+ long first_id;
+ long second_id;
+
+ bundle_getArchive(first_ptr, &first_archive_ptr);
+ bundle_getArchive(second_ptr, &second_archive_ptr);
+
+ bundleArchive_getId(first_archive_ptr, &first_id);
+ bundleArchive_getId(second_archive_ptr, &second_id);
+
+ if (first_id > second_id) {
+ bundle_pt temp_ptr = bundles_array_ptr[i];
+ bundles_array_ptr[i] = bundles_array_ptr[j];
+ bundles_array_ptr[j] = temp_ptr;
+ }
+ }
+ }
+
+ for (unsigned int i = 0; i < size; i++) {
+ celix_status_t sub_status;
+
+ bundle_pt bundle_ptr = bundles_array_ptr[i];
+
+ bundle_archive_pt archive_ptr = NULL;
+ long id = 0;
+ bundle_state_e state = OSGI_FRAMEWORK_BUNDLE_UNKNOWN;
+ const char *state_str = NULL;
+ module_pt module_ptr = NULL;
+ const char *name_str = NULL;
+
+ sub_status = bundle_getArchive(bundle_ptr, &archive_ptr);
+ if (sub_status == CELIX_SUCCESS) {
+ sub_status = bundleArchive_getId(archive_ptr, &id);
+ }
+
+ if (sub_status == CELIX_SUCCESS) {
+ sub_status = bundle_getState(bundle_ptr, &state);
+ }
+
+ if (sub_status == CELIX_SUCCESS) {
+ state_str = psCommand_stateString(state);
+
+ sub_status = bundle_getCurrentModule(bundle_ptr, &module_ptr);
+ }
+
+ if (sub_status == CELIX_SUCCESS) {
+ sub_status = module_getSymbolicName(module_ptr, &name_str);
+ }
+
+ if (sub_status == CELIX_SUCCESS) {
+ if (show_location) {
+ sub_status = bundleArchive_getLocation(archive_ptr, &name_str);
+ } else if (show_symbolic_name) {
+ // do nothing
+ } else if (show_update_location) {
+ sub_status = bundleArchive_getLocation(archive_ptr, &name_str);
+ }
+ }
+
+ if (sub_status == CELIX_SUCCESS) {
+ startColor = "";
+ endColor = "";
+ if (useColors) {
+ startColor = i % 2 == 0 ? EVEN_COLOR : ODD_COLOR;
+ endColor = END_COLOR;
+ }
+ fprintf(out_ptr, "%s %-5ld %-12s %s%s\n", startColor, id, state_str, name_str, endColor);
+
+ }
+
+ if (sub_status != CELIX_SUCCESS) {
+ status = sub_status;
+ break;
+ }
+ }
+
+ arrayList_destroy(bundles_ptr);
+ }
+
+ return status;
+}
+
+static char * psCommand_stateString(bundle_state_e state) {
+ switch (state) {
+ case OSGI_FRAMEWORK_BUNDLE_ACTIVE:
+ return "Active ";
+ case OSGI_FRAMEWORK_BUNDLE_INSTALLED:
+ return "Installed ";
+ case OSGI_FRAMEWORK_BUNDLE_RESOLVED:
+ return "Resolved ";
+ case OSGI_FRAMEWORK_BUNDLE_STARTING:
+ return "Starting ";
+ case OSGI_FRAMEWORK_BUNDLE_STOPPING:
+ return "Stopping ";
+ default:
+ return "Unknown ";
+ }
+}
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/shell/src/log_command.c
----------------------------------------------------------------------
diff --git a/shell/src/log_command.c b/shell/src/log_command.c
new file mode 100644
index 0000000..8b0244a
--- /dev/null
+++ b/shell/src/log_command.c
@@ -0,0 +1,94 @@
+/**
+ *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.
+ */
+/*
+ * log_command.c
+ *
+ * \date Jun 26, 2011
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "bundle_context.h"
+#include "log_reader_service.h"
+#include "linked_list_iterator.h"
+
+celix_status_t logCommand_levelAsString(bundle_context_pt context, log_level_t level, char **string);
+
+void logCommand_execute(bundle_context_pt context, char *line, FILE *outStream, FILE *errStream) {
+ celix_status_t status;
+ service_reference_pt readerService = NULL;
+
+ status = bundleContext_getServiceReference(context, (char *) OSGI_LOGSERVICE_READER_SERVICE_NAME, &readerService);
+ if (status != CELIX_SUCCESS || readerService != NULL) {
+ linked_list_pt list = NULL;
+ linked_list_iterator_pt iter = NULL;
+ log_reader_service_pt reader = NULL;
+
+
+ bundleContext_getService(context, readerService, (void **) &reader);
+ reader->getLog(reader->reader, &list);
+ iter = linkedListIterator_create(list, 0);
+ while (linkedListIterator_hasNext(iter)) {
+ log_entry_pt entry = linkedListIterator_next(iter);
+ char time[20];
+ char *level = NULL;
+ char errorString[256];
+
+ strftime(time, 20, "%Y-%m-%d %H:%M:%S", localtime(&entry->time));
+ logCommand_levelAsString(context, entry->level, &level);
+
+ if (entry->errorCode > 0) {
+ celix_strerror(entry->errorCode, errorString, 256);
+ fprintf(outStream, "%s - Bundle: %s - %s - %d %s\n", time, entry->bundleSymbolicName, entry->message, entry->errorCode, errorString);
+ } else {
+ fprintf(outStream, "%s - Bundle: %s - %s\n", time, entry->bundleSymbolicName, entry->message);
+ }
+ }
+ linkedListIterator_destroy(iter);
+ linkedList_destroy(list);
+ bool result = true;
+ bundleContext_ungetService(context, readerService, &result);
+ bundleContext_ungetServiceReference(context, readerService);
+ } else {
+ fprintf(outStream, "No log reader available\n");
+ }
+}
+
+celix_status_t logCommand_levelAsString(bundle_context_pt context, log_level_t level, char **string) {
+ switch (level) {
+ case OSGI_LOGSERVICE_ERROR:
+ *string = "ERROR";
+ break;
+ case OSGI_LOGSERVICE_WARNING:
+ *string = "WARNING";
+ break;
+ case OSGI_LOGSERVICE_INFO:
+ *string = "INFO";
+ break;
+ case OSGI_LOGSERVICE_DEBUG:
+ default:
+ *string = "DEBUG";
+ break;
+ }
+
+ return CELIX_SUCCESS;
+}
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/shell/src/shell.c
----------------------------------------------------------------------
diff --git a/shell/src/shell.c b/shell/src/shell.c
new file mode 100644
index 0000000..ac8603e
--- /dev/null
+++ b/shell/src/shell.c
@@ -0,0 +1,305 @@
+/**
+ *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.
+ */
+/*
+ * shell.c
+ *
+ * \date Aug 13, 2010
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+#include <stdlib.h>
+#include <string.h>
+#include <log_helper.h>
+
+#include "celix_errno.h"
+
+#include "shell_private.h"
+
+
+#include "utils.h"
+
+celix_status_t shell_getCommands(shell_pt shell_ptr, array_list_pt *commands_ptr);
+celix_status_t shell_getCommandUsage(shell_pt shell_ptr, char *command_name_str, char **usage_pstr);
+celix_status_t shell_getCommandDescription(shell_pt shell_ptr, char *command_name_str, char **command_description_pstr);
+
+celix_status_t shell_create(bundle_context_pt context_ptr, shell_service_pt *shell_service_ptr) {
+ celix_status_t status = CELIX_SUCCESS;
+
+ if (!context_ptr || !shell_service_ptr) {
+ status = CELIX_ILLEGAL_ARGUMENT;
+ }
+
+ if (status == CELIX_SUCCESS) {
+ *shell_service_ptr = calloc(1, sizeof(**shell_service_ptr));
+ if (!*shell_service_ptr) {
+ status = CELIX_ENOMEM;
+ }
+ }
+
+ if (status == CELIX_SUCCESS) {
+ (*shell_service_ptr)->shell = calloc(1, sizeof(*(*shell_service_ptr)->shell));
+ if (!(*shell_service_ptr)->shell) {
+ status = CELIX_ENOMEM;
+ }
+ }
+
+ if (status == CELIX_SUCCESS) {
+ (*shell_service_ptr)->shell->bundle_context_ptr = context_ptr;
+ (*shell_service_ptr)->shell->command_name_map_ptr = hashMap_create(utils_stringHash, NULL, utils_stringEquals, NULL);
+ (*shell_service_ptr)->shell->command_reference_map_ptr = hashMap_create(NULL, NULL, NULL, NULL);
+
+ (*shell_service_ptr)->getCommands = shell_getCommands;
+ (*shell_service_ptr)->getCommandDescription = shell_getCommandDescription;
+ (*shell_service_ptr)->getCommandUsage = shell_getCommandUsage;
+ (*shell_service_ptr)->getCommandReference = shell_getCommandReference;
+ (*shell_service_ptr)->executeCommand = shell_executeCommand;
+
+ status = logHelper_create(context_ptr, &(*shell_service_ptr)->shell->logHelper);
+ }
+
+ if (status != CELIX_SUCCESS) {
+ shell_destroy(shell_service_ptr);
+ }
+
+ return status;
+}
+
+celix_status_t shell_destroy(shell_service_pt *shell_service_ptr) {
+ celix_status_t status = CELIX_SUCCESS;
+
+ if (!shell_service_ptr || !*shell_service_ptr) {
+ status = CELIX_ILLEGAL_ARGUMENT;
+ }
+
+ if (status == CELIX_SUCCESS) {
+ if ((*shell_service_ptr)->shell) {
+ if ((*shell_service_ptr)->shell->command_name_map_ptr) {
+ hashMap_destroy((*shell_service_ptr)->shell->command_name_map_ptr, false, false);
+ }
+ if ((*shell_service_ptr)->shell->command_reference_map_ptr) {
+ hashMap_destroy((*shell_service_ptr)->shell->command_reference_map_ptr, false, false);
+ }
+ if ((*shell_service_ptr)->shell->logHelper) {
+ logHelper_destroy(&((*shell_service_ptr)->shell->logHelper));
+ }
+ free((*shell_service_ptr)->shell);
+ (*shell_service_ptr)->shell = NULL;
+ }
+ free(*shell_service_ptr);
+ *shell_service_ptr = NULL;
+ }
+
+ return status;
+}
+
+celix_status_t shell_addCommand(shell_pt shell_ptr, service_reference_pt reference_ptr, void *svc) {
+ celix_status_t status = CELIX_SUCCESS;
+ command_service_pt command_ptr = NULL;
+ const char *name_str = NULL;
+
+ if (!shell_ptr || !reference_ptr) {
+ return CELIX_ILLEGAL_ARGUMENT;
+ }
+
+ if (status == CELIX_SUCCESS) {
+ command_ptr = svc;
+ }
+
+ if (status == CELIX_SUCCESS) {
+ status = serviceReference_getProperty(reference_ptr, "command.name", &name_str);
+ if (!name_str) {
+ logHelper_log(shell_ptr->logHelper, OSGI_LOGSERVICE_ERROR, "Command service must contain a 'command.name' property!");
+ status = CELIX_BUNDLE_EXCEPTION;
+ }
+ }
+
+ if (status == CELIX_SUCCESS) {
+ hashMap_put(shell_ptr->command_name_map_ptr, (char *)name_str, command_ptr);
+ hashMap_put(shell_ptr->command_reference_map_ptr, reference_ptr, command_ptr);
+ }
+
+ if (status != CELIX_SUCCESS) {
+ shell_removeCommand(shell_ptr, reference_ptr, svc);
+ char err[32];
+ celix_strerror(status, err, 32);
+ logHelper_log(shell_ptr->logHelper, OSGI_LOGSERVICE_ERROR, "Could not add command, got error %s\n", err);
+ }
+
+ return status;
+}
+
+celix_status_t shell_removeCommand(shell_pt shell_ptr, service_reference_pt reference_ptr, void *svc) {
+ celix_status_t status = CELIX_SUCCESS;
+
+ command_service_pt command_ptr = NULL;
+ const char *name_str = NULL;
+
+ if (!shell_ptr || !reference_ptr) {
+ status = CELIX_ILLEGAL_ARGUMENT;
+ }
+
+ if (status == CELIX_SUCCESS) {
+ command_ptr = hashMap_remove(shell_ptr->command_reference_map_ptr, reference_ptr);
+ if (!command_ptr) {
+ status = CELIX_ILLEGAL_ARGUMENT;
+ }
+ }
+
+ if (status == CELIX_SUCCESS) {
+ status = serviceReference_getProperty(reference_ptr, "command.name", &name_str);
+ if (!name_str) {
+ status = CELIX_BUNDLE_EXCEPTION;
+ }
+ }
+
+ if (status == CELIX_SUCCESS) {
+ hashMap_remove(shell_ptr->command_name_map_ptr, (char *)name_str);
+ }
+
+ return status;
+}
+
+celix_status_t shell_getCommands(shell_pt shell_ptr, array_list_pt *commands_ptr) {
+ celix_status_t status = CELIX_SUCCESS;
+
+ hash_map_iterator_pt iter = NULL;
+
+ if (!shell_ptr || !commands_ptr) {
+ status = CELIX_ILLEGAL_ARGUMENT;
+ }
+
+ if (status == CELIX_SUCCESS) {
+ iter = hashMapIterator_create(shell_ptr->command_name_map_ptr);
+ if (!iter) {
+ status = CELIX_BUNDLE_EXCEPTION;
+ }
+ }
+
+ if (status == CELIX_SUCCESS) {
+ arrayList_create(commands_ptr);
+ while (hashMapIterator_hasNext(iter)) {
+ char *name_str = hashMapIterator_nextKey(iter);
+ arrayList_add(*commands_ptr, name_str);
+ }
+ hashMapIterator_destroy(iter);
+ }
+
+ return status;
+}
+
+
+celix_status_t shell_getCommandUsage(shell_pt shell_ptr, char *command_name_str, char **usage_pstr) {
+ celix_status_t status = CELIX_SUCCESS;
+
+ service_reference_pt reference = NULL;
+
+ if (!shell_ptr || !command_name_str || !usage_pstr) {
+ status = CELIX_ILLEGAL_ARGUMENT;
+ }
+
+ if (status == CELIX_SUCCESS) {
+ status = shell_getCommandReference(shell_ptr, command_name_str, &reference);
+ if (!reference) {
+ status = CELIX_BUNDLE_EXCEPTION;
+ }
+ }
+
+ if (status == CELIX_SUCCESS) {
+ status = serviceReference_getProperty(reference, "command.usage", (const char**)usage_pstr);
+ }
+
+ return status;
+}
+
+celix_status_t shell_getCommandDescription(shell_pt shell_ptr, char *command_name_str, char **command_description_pstr) {
+ celix_status_t status = CELIX_SUCCESS;
+
+ service_reference_pt reference = NULL;
+
+ if (!shell_ptr || !command_name_str || !command_description_pstr) {
+ status = CELIX_ILLEGAL_ARGUMENT;
+ }
+
+ if (status == CELIX_SUCCESS) {
+ status = shell_getCommandReference(shell_ptr, command_name_str, &reference);
+ if (!reference) {
+ status = CELIX_BUNDLE_EXCEPTION;
+ }
+ }
+
+ if (status == CELIX_SUCCESS) {
+ serviceReference_getProperty(reference, "command.description", (const char**)command_description_pstr);
+ }
+
+ return status;
+}
+
+celix_status_t shell_getCommandReference(shell_pt shell_ptr, char *command_name_str, service_reference_pt *command_reference_ptr) {
+ celix_status_t status = CELIX_SUCCESS;
+
+ if (!shell_ptr || !command_name_str || !command_reference_ptr) {
+ status = CELIX_ILLEGAL_ARGUMENT;
+ }
+
+ if (status == CELIX_SUCCESS) {
+ *command_reference_ptr = NULL;
+ hash_map_iterator_pt iter = hashMapIterator_create(shell_ptr->command_reference_map_ptr);
+ while (hashMapIterator_hasNext(iter)) {
+ hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
+ service_reference_pt reference = hashMapEntry_getKey(entry);
+ const char *name_str = NULL;
+ serviceReference_getProperty(reference, "command.name", &name_str);
+ if (strcmp(name_str, command_name_str) == 0) {
+ *command_reference_ptr = (service_reference_pt) hashMapEntry_getKey(entry);
+ break;
+ }
+ }
+ hashMapIterator_destroy(iter);
+ }
+
+ return status;
+}
+
+celix_status_t shell_executeCommand(shell_pt shell_ptr, char *command_line_str, FILE *out, FILE *err) {
+ celix_status_t status = CELIX_SUCCESS;
+
+ command_service_pt command_ptr = NULL;
+
+ if (!shell_ptr || !command_line_str || !out || !err) {
+ status = CELIX_ILLEGAL_ARGUMENT;
+ }
+
+ if (status == CELIX_SUCCESS) {
+ size_t pos = strcspn(command_line_str, " ");
+
+ char *command_name_str = (pos != strlen(command_line_str)) ? strndup(command_line_str, pos) : strdup(command_line_str);
+ command_ptr = hashMap_get(shell_ptr->command_name_map_ptr, command_name_str);
+ free(command_name_str);
+ if (!command_ptr) {
+ fprintf(err, "No such command\n");
+ status = CELIX_BUNDLE_EXCEPTION;
+ }
+ }
+
+ if (status == CELIX_SUCCESS) {
+ status = command_ptr->executeCommand(command_ptr->handle, command_line_str, out, err);
+ }
+
+ return status;
+}
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/shell/src/shell_private.h
----------------------------------------------------------------------
diff --git a/shell/src/shell_private.h b/shell/src/shell_private.h
new file mode 100644
index 0000000..7270fa2
--- /dev/null
+++ b/shell/src/shell_private.h
@@ -0,0 +1,51 @@
+/**
+ *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.
+ */
+/*
+ * shell_private.h
+ *
+ * \date Aug 13, 2010
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+
+#ifndef SHELL_PRIVATE_H_
+#define SHELL_PRIVATE_H_
+
+#include "bundle_context.h"
+#include "shell.h"
+#include "hash_map.h"
+#include "command.h"
+#include "log_helper.h"
+
+struct shell {
+ bundle_context_pt bundle_context_ptr;
+ hash_map_pt command_reference_map_ptr;
+ hash_map_pt command_name_map_ptr;
+ log_helper_pt logHelper;
+};
+
+celix_status_t shell_create(bundle_context_pt context_ptr, shell_service_pt *shell_service_ptr);
+celix_status_t shell_destroy(shell_service_pt *shell_service_ptr);
+celix_status_t shell_addCommand(shell_pt shell_ptr, service_reference_pt reference_ptr, void *svc);
+celix_status_t shell_removeCommand(shell_pt shell_ptr, service_reference_pt reference_ptr, void *svc);
+
+celix_status_t shell_getCommandReference(shell_pt shell_ptr, char *command_name_str, service_reference_pt *command_reference_ptr);
+celix_status_t shell_executeCommand(shell_pt shell_ptr, char *command_line_str, FILE *out, FILE *err);
+
+#endif /* SHELL_PRIVATE_H_ */
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/shell/src/start_command.c
----------------------------------------------------------------------
diff --git a/shell/src/start_command.c b/shell/src/start_command.c
new file mode 100644
index 0000000..f43699a
--- /dev/null
+++ b/shell/src/start_command.c
@@ -0,0 +1,84 @@
+/**
+ *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.
+ */
+/*
+ * start_command.c
+ *
+ * \date Aug 20, 2010
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "std_commands.h"
+#include "bundle_context.h"
+
+celix_status_t startCommand_execute(void *_ptr, char *command_line_str, FILE *out_ptr, FILE *err_ptr) {
+ celix_status_t status = CELIX_SUCCESS;
+
+ bundle_context_pt context_ptr = _ptr;
+
+ if (!context_ptr || !command_line_str || !out_ptr || !err_ptr) {
+ status = CELIX_ILLEGAL_ARGUMENT;
+ }
+
+ if (status == CELIX_SUCCESS) {
+ char *sub_str = NULL;
+ char *save_ptr = NULL;
+
+ strtok_r(command_line_str, OSGI_SHELL_COMMAND_SEPARATOR, &save_ptr);
+ sub_str = strtok_r(NULL, OSGI_SHELL_COMMAND_SEPARATOR, &save_ptr);
+
+ if (sub_str == NULL) {
+ fprintf(out_ptr, "Incorrect number of arguments.\n");
+ } else {
+ while (sub_str != NULL) {
+ celix_status_t sub_status = CELIX_SUCCESS;
+
+ bundle_pt bundle_ptr = NULL;
+
+ char *end_str = NULL;
+ long id = strtol(sub_str, &end_str, 10);
+ if (*end_str) {
+ sub_status = CELIX_ILLEGAL_ARGUMENT;
+ fprintf(err_ptr, "Bundle id '%s' is invalid, problem at %s\n", sub_str, end_str);
+ }
+
+ if (sub_status == CELIX_SUCCESS) {
+ sub_status = bundleContext_getBundleById(context_ptr, id, &bundle_ptr);
+ }
+
+ if (sub_status == CELIX_SUCCESS) {
+ bundle_startWithOptions(bundle_ptr, 0);
+ }
+
+ if (sub_status != CELIX_SUCCESS) {
+ status = sub_status;
+ break;
+ }
+
+ sub_str = strtok_r(NULL, OSGI_SHELL_COMMAND_SEPARATOR, &save_ptr);
+ }
+ }
+
+ }
+
+ return status;
+}
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/shell/src/std_commands.h
----------------------------------------------------------------------
diff --git a/shell/src/std_commands.h b/shell/src/std_commands.h
new file mode 100644
index 0000000..ef7f37e
--- /dev/null
+++ b/shell/src/std_commands.h
@@ -0,0 +1,44 @@
+/**
+ *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.
+ */
+/*
+ * std_commands.h
+ *
+ * \date March 27, 2014
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+
+#ifndef __STD_COMMANDS_H_
+#define __STD_COMMANDS_H_
+
+#include "celix_errno.h"
+
+#define OSGI_SHELL_COMMAND_SEPARATOR " "
+
+celix_status_t psCommand_execute(void *_ptr, char *command_line_str, FILE *out_ptr, FILE *err_ptr);
+celix_status_t startCommand_execute(void *_ptr, char *command_line_str, FILE *out_ptr, FILE *err_ptr);
+celix_status_t stopCommand_execute(void *handle, char * commandline, FILE *outStream, FILE *errStream);
+celix_status_t installCommand_execute(void *handle, char * commandline, FILE *outStream, FILE *errStream);
+celix_status_t uninstallCommand_execute(void *handle, char * commandline, FILE *outStream, FILE *errStream);
+celix_status_t updateCommand_execute(void *handle, char * commandline, FILE *outStream, FILE *errStream);
+celix_status_t logCommand_execute(void *handle, char * commandline, FILE *outStream, FILE *errStream);
+celix_status_t inspectCommand_execute(void *handle, char * commandline, FILE *outStream, FILE *errStream);
+celix_status_t helpCommand_execute(void *handle, char * commandline, FILE *outStream, FILE *errStream);
+
+#endif
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/shell/src/stop_command.c
----------------------------------------------------------------------
diff --git a/shell/src/stop_command.c b/shell/src/stop_command.c
new file mode 100644
index 0000000..0093c99
--- /dev/null
+++ b/shell/src/stop_command.c
@@ -0,0 +1,82 @@
+/**
+ *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.
+ */
+/*
+ * stop_command.c
+ *
+ * \date Aug 20, 2010
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+#include <stdlib.h>
+#include <string.h>
+
+#include "bundle_context.h"
+#include "std_commands.h"
+
+celix_status_t stopCommand_execute(void *_ptr, char *command_line_str, FILE *out_ptr, FILE *err_ptr) {
+ celix_status_t status = CELIX_SUCCESS;
+
+ bundle_context_pt context_ptr = _ptr;
+
+ if (!context_ptr || !command_line_str || !out_ptr || !err_ptr) {
+ status = CELIX_ILLEGAL_ARGUMENT;
+ }
+
+ if (status == CELIX_SUCCESS) {
+ char *sub_str = NULL;
+ char *save_ptr = NULL;
+
+ strtok_r(command_line_str, OSGI_SHELL_COMMAND_SEPARATOR, &save_ptr);
+ sub_str = strtok_r(NULL, OSGI_SHELL_COMMAND_SEPARATOR, &save_ptr);
+
+ if (sub_str == NULL) {
+ fprintf(out_ptr, "Incorrect number of arguments.\n");
+ } else {
+ while (sub_str != NULL) {
+ celix_status_t sub_status = CELIX_SUCCESS;
+
+ bundle_pt bundle_ptr = NULL;
+
+ char *end_str = NULL;
+ long id = strtol(sub_str, &end_str, 10);
+ if (*end_str) {
+ sub_status = CELIX_ILLEGAL_ARGUMENT;
+ fprintf(err_ptr, "Bundle id '%s' is invalid, problem at %s\n", sub_str, end_str);
+ }
+
+ if (sub_status == CELIX_SUCCESS) {
+ sub_status = bundleContext_getBundleById(context_ptr, id, &bundle_ptr);
+ }
+
+ if (sub_status == CELIX_SUCCESS) {
+ bundle_stopWithOptions(bundle_ptr, 0);
+ }
+
+ if (sub_status != CELIX_SUCCESS) {
+ status = sub_status;
+ break;
+ }
+
+ sub_str = strtok_r(NULL, OSGI_SHELL_COMMAND_SEPARATOR, &save_ptr);
+ }
+ }
+ }
+
+ return status;
+}
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/shell/src/uninstall_command.c
----------------------------------------------------------------------
diff --git a/shell/src/uninstall_command.c b/shell/src/uninstall_command.c
new file mode 100644
index 0000000..fb30831
--- /dev/null
+++ b/shell/src/uninstall_command.c
@@ -0,0 +1,58 @@
+/**
+ *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.
+ */
+/*
+ * uninstall_command.c
+ *
+ * \date Aug 20, 2010
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+#include <stdlib.h>
+#include <string.h>
+
+#include "array_list.h"
+#include "bundle_context.h"
+
+celix_status_t uninstallCommand_execute(void *handle, char * line, FILE *outStream, FILE *errStream) {
+ bundle_context_pt context = handle;
+ char delims[] = " ";
+ char * sub = NULL;
+ char *save_ptr = NULL;
+ celix_status_t status = CELIX_SUCCESS;
+
+ sub = strtok_r(line, delims, &save_ptr);
+ sub = strtok_r(NULL, delims, &save_ptr);
+
+ if (sub == NULL) {
+ fprintf(errStream, "Incorrect number of arguments.\n");
+ } else {
+ while (sub != NULL) {
+ long id = atol(sub);
+ bundle_pt bundle = NULL;
+ status = bundleContext_getBundleById(context, id, &bundle);
+ if (status==CELIX_SUCCESS && bundle!=NULL) {
+ bundle_uninstall(bundle);
+ } else {
+ fprintf(errStream, "Bundle id is invalid.");
+ }
+ sub = strtok_r(NULL, delims, &save_ptr);
+ }
+ }
+ return status;
+}
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/shell/src/update_command.c
----------------------------------------------------------------------
diff --git a/shell/src/update_command.c b/shell/src/update_command.c
new file mode 100644
index 0000000..64999ac
--- /dev/null
+++ b/shell/src/update_command.c
@@ -0,0 +1,117 @@
+/**
+ *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.
+ */
+/*
+ * update_command.c
+ *
+ * \date Aug 20, 2010
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ *
+ */
+#include <stdlib.h>
+#include <string.h>
+#include <curl/curl.h>
+#include <sys/stat.h>
+
+#include "array_list.h"
+#include "bundle_context.h"
+
+celix_status_t updateCommand_download(bundle_context_pt context, char * url, char **inputFile);
+size_t updateCommand_writeData(void *ptr, size_t size, size_t nmemb, FILE *stream);
+
+void updateCommand_execute(void *handle, char * line, FILE *outStream, FILE *errStream) {
+ bundle_context_pt context = handle;
+ bundle_pt bundle = NULL;
+ char delims[] = " ";
+ char * sub = NULL;
+ char *save_ptr = NULL;
+
+ sub = strtok_r(line, delims, &save_ptr);
+ sub = strtok_r(NULL, delims, &save_ptr);
+
+ if (sub == NULL) {
+ fprintf(errStream, "Incorrect number of arguments.\n");
+ } else {
+ long id = atol(sub);
+ celix_status_t ret = bundleContext_getBundleById(context, id, &bundle);
+ if (ret==CELIX_SUCCESS && bundle!=NULL) {
+ char inputFile[256];
+ sub = strtok_r(NULL, delims, &save_ptr);
+ inputFile[0] = '\0';
+ if (sub != NULL) {
+ char *test = inputFile;
+ printf("URL: %s\n", sub);
+
+ if (updateCommand_download(context, sub, &test) == CELIX_SUCCESS) {
+ printf("Update bundle with stream\n");
+ bundle_update(bundle, inputFile);
+ } else {
+ fprintf(errStream, "Unable to download from %s\n", sub);
+ }
+ } else {
+ bundle_update(bundle, NULL);
+ }
+ } else {
+ fprintf(errStream, "Bundle id is invalid.\n");
+ }
+ }
+}
+
+celix_status_t updateCommand_download(bundle_context_pt context, char * url, char **inputFile) {
+ CURL *curl = NULL;
+ CURLcode res = CURLE_FILE_COULDNT_READ_FILE;
+ curl = curl_easy_init();
+ if (curl) {
+ FILE *fp = NULL;
+ snprintf(*inputFile, 13,"updateXXXXXX");
+ umask(0011);
+ int fd = mkstemp(*inputFile);
+ if (fd) {
+ fp = fopen(*inputFile, "wb+");
+ if(fp!=NULL){
+ printf("Temp file: %s\n", *inputFile);
+ curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
+ curl_easy_setopt(curl, CURLOPT_URL, url);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, updateCommand_writeData);
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);
+ //curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
+ //curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, updateCommand_downloadProgress);
+ res = curl_easy_perform(curl);
+ fclose(fp);
+ }
+ /* always cleanup */
+ curl_easy_cleanup(curl);
+ if(fp==NULL){
+ return CELIX_FILE_IO_EXCEPTION;
+ }
+ }
+ }
+ if (res != CURLE_OK) {
+ printf("Error: %d\n", res);
+ *inputFile[0] = '\0';
+ return CELIX_ILLEGAL_STATE;
+ } else {
+ return CELIX_SUCCESS;
+ }
+}
+
+size_t updateCommand_writeData(void *ptr, size_t size, size_t nmemb, FILE *stream) {
+ size_t written = fwrite(ptr, size, nmemb, stream);
+ return written;
+}
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/shell_bonjour/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/shell_bonjour/CMakeLists.txt b/shell_bonjour/CMakeLists.txt
index 300fef0..2276f09 100644
--- a/shell_bonjour/CMakeLists.txt
+++ b/shell_bonjour/CMakeLists.txt
@@ -26,28 +26,24 @@ if (SHELL_BONJOUR)
set(BUNDLE_VERSION "0.1.0")
set(BUNDLE_NAME "bonjour_shell")
- include_directories("${PROJECT_SOURCE_DIR}/utils/public/include")
- include_directories("${PROJECT_SOURCE_DIR}/shell/public/include")
- include_directories("${LIBXML2_INCLUDE_DIR}")
- include_directories("private/include")
-
- set(MEMSTREAM_SOURCES )
- if (APPLE OR ANDROID)
- set(MEMSTREAM_SOURCES ${PROJECT_SOURCE_DIR}/utils/private/src/memstream/open_memstream.c ${PROJECT_SOURCE_DIR}/utils/private/src/memstream/fmemopen.c)
- include_directories(${PROJECT_SOURCE_DIR}/utils/public/include/memstream)
- endif()
add_bundle(bonjour_shell
- VERSION "1.0.0"
+ VERSION "1.0.0"
SOURCES
private/src/activator.c
private/src/bonjour_shell.c
- ${MEMSTREAM_SOURCES}
)
-
- target_link_libraries(bonjour_shell celix_framework celix_utils ${LIBXML2_LIBRARIES} ${DNS_SD_LIB})
+ add_library(Celix::bonjour_shell ALIAS bonjour_shell)
+
+
+ target_include_directories(bonjour_shell PRIVATE
+ "${PROJECT_SOURCE_DIR}/utils/public/include"
+ "${LIBXML2_INCLUDE_DIR}"
+ private/include
+ )
+ target_link_libraries(bonjour_shell PRIVATE ${LIBXML2_LIBRARIES} ${DNS_SD_LIB} Celix::shell_api)
add_deploy("bonjour_shell_deploy" BUNDLES
- shell
+ Celix::shell
bonjour_shell
PROPERTIES "bonjour.shell.id=Apache Celix"
)
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/shell_tui/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/shell_tui/CMakeLists.txt b/shell_tui/CMakeLists.txt
index 0216261..bd6b316 100644
--- a/shell_tui/CMakeLists.txt
+++ b/shell_tui/CMakeLists.txt
@@ -27,10 +27,14 @@ if (SHELL_TUI)
private/src/history
)
+ target_include_directories(shell_tui PRIVATE
+ "${PROJECT_SOURCE_DIR}/utils/public/include"
+ private/include
+ )
+ target_link_libraries(shell_tui PRIVATE Celix::shell_api)
+
install_bundle(shell_tui)
-
- include_directories("private/include")
- include_directories("${PROJECT_SOURCE_DIR}/utils/public/include")
- include_directories("${PROJECT_SOURCE_DIR}/shell/public/include")
- target_link_libraries(shell_tui celix_framework)
+
+ #Alias setup to match external usage
+ add_library(Celix::shell_tui ALIAS shell_tui)
endif (SHELL_TUI)
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/shell_tui/README.md
----------------------------------------------------------------------
diff --git a/shell_tui/README.md b/shell_tui/README.md
index a637214..8a58fcb 100644
--- a/shell_tui/README.md
+++ b/shell_tui/README.md
@@ -10,3 +10,8 @@ The Celix Shell TUI implements a textual user interface for the Celix Shell.
- SHELL_USE_ANSI_CONTROL_SEQUENCES - Wether to use ANSI control
sequences to support backspace, left, up, etc key commands in the
shell tui. Default is true if a TERM environment is set else false.
+
+## Using info
+
+If the Celix Shell TUI is installed The `FindCelix.cmake` will set:
+ - The `Celix::shell_tui` bundle target if the shell_tui is installed
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/utils/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/utils/CMakeLists.txt b/utils/CMakeLists.txt
index 9132f45..e0c187f 100644
--- a/utils/CMakeLists.txt
+++ b/utils/CMakeLists.txt
@@ -15,93 +15,98 @@
# specific language governing permissions and limitations
# under the License.
-celix_subproject(UTILS "Option to build the utilities library" ON)
-if (UTILS)
- cmake_minimum_required(VERSION 2.6)
-
+set(MEMSTREAM_SOURCES )
+set(MEMSTREAM_INCLUDES )
+if (APPLE OR ANDROID)
+ set(MEMSTREAM_SOURCES src/memstream/open_memstream.c src/memstream/fmemopen.c)
+ set(MEMSTREAM_INCLUDE_DIR include/memstream)
+endif()
+
+add_library(utils SHARED
+ src/array_list.c
+ src/hash_map.c
+ src/linked_list.c
+ src/linked_list_iterator.c
+ src/celix_threads.c
+ src/version.c
+ src/version_range.c
+ src/thpool.c
+ src/properties.c
+ src/utils.c
+ ${MEMSTREAM_SOURCES}
+)
+set_target_properties(utils PROPERTIES OUTPUT_NAME "celix_utils")
+
if (ANDROID)
- add_definitions(-DUSE_FILE32API)
+ target_compile_definitions(utils PRIVATE -DUSE_FILE32API)
endif ()
- include_directories("private/include")
- include_directories("public/include")
- add_library(celix_utils SHARED
- private/src/array_list.c
- private/src/hash_map.c
- private/src/linked_list.c
- private/src/linked_list_iterator.c
- private/src/celix_threads.c
- private/src/version.c
- private/src/version_range.c
- private/src/thpool.c
- private/src/properties.c
- private/src/utils.c
- )
-
- set_target_properties(celix_utils PROPERTIES "SOVERSION" 2)
-
- IF(UNIX AND NOT ANDROID)
- target_link_libraries(celix_utils m pthread)
- ELSEIF(ANDROID)
- target_link_libraries(celix_utils m)
- ENDIF()
-
- install(TARGETS celix_utils DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT framework)
- FILE(GLOB files "public/include/*.h")
- INSTALL(FILES ${files} DESTINATION include/celix COMPONENT framework)
-
- celix_subproject(UTILS-TESTS "Option to build the utilities library tests" "OFF")
-
- if (ENABLE_TESTING AND UTILS-TESTS)
- find_package(CppUTest REQUIRED)
-
- SET(CMAKE_SKIP_BUILD_RPATH FALSE)
- SET(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
- SET(CMAKE_INSTALL_RPATH "${PROJECT_BINARY_DIR}/utils")
-
-
- include_directories(${CUNIT_INCLUDE_DIRS})
- include_directories(${CPPUTEST_INCLUDE_DIR})
- include_directories(public/include)
- include_directories(utils/private/include)
-
- add_executable(hash_map_test private/test/hash_map_test.cpp)
- target_link_libraries(hash_map_test celix_utils ${CPPUTEST_LIBRARY} pthread)
-
- add_executable(array_list_test private/test/array_list_test.cpp)
- target_link_libraries(array_list_test celix_utils ${CPPUTEST_LIBRARY} pthread)
-
- add_executable(celix_threads_test private/test/celix_threads_test.cpp)
- target_link_libraries(celix_threads_test celix_utils ${CPPUTEST_LIBRARY} ${CPPUTEST_EXT_LIBRARY} pthread)
- add_executable(linked_list_test private/test/linked_list_test.cpp)
- target_link_libraries(linked_list_test celix_utils ${CPPUTEST_LIBRARY} pthread)
-
- add_executable(thread_pool_test private/test/thread_pool_test.cpp)
- target_link_libraries(thread_pool_test celix_utils ${CPPUTEST_LIBRARY} pthread)
-
- add_executable(properties_test private/test/properties_test.cpp)
- target_link_libraries(properties_test ${CPPUTEST_LIBRARY} ${CPPUTEST_EXT_LIBRARY} celix_utils pthread)
-
- add_executable(utils_test private/test/utils_test.cpp)
- target_link_libraries(utils_test ${CPPUTEST_LIBRARY} celix_utils pthread)
-
- configure_file(private/resources-test/properties.txt ${CMAKE_BINARY_DIR}/utils/resources-test/properties.txt COPYONLY)
-
- add_test(NAME run_array_list_test COMMAND array_list_test)
- add_test(NAME run_hash_map_test COMMAND hash_map_test)
- add_test(NAME run_celix_threads_test COMMAND celix_threads_test)
- add_test(NAME run_thread_pool_test COMMAND thread_pool_test)
- add_test(NAME run_linked_list_test COMMAND linked_list_test)
- add_test(NAME run_properties_test COMMAND properties_test)
- add_test(NAME run_utils_test COMMAND utils_test)
-
- SETUP_TARGET_FOR_COVERAGE(array_list_test array_list_test ${CMAKE_BINARY_DIR}/coverage/array_list_test/array_list_test)
- SETUP_TARGET_FOR_COVERAGE(hash_map hash_map_test ${CMAKE_BINARY_DIR}/coverage/hash_map_test/hash_map_test)
- SETUP_TARGET_FOR_COVERAGE(celix_threads_test celix_threads_test ${CMAKE_BINARY_DIR}/coverage/celix_threads_test/celix_threads_test)
- SETUP_TARGET_FOR_COVERAGE(thread_pool_test thread_pool_test ${CMAKE_BINARY_DIR}/coverage/thread_pool_test/thread_pool_test)
- SETUP_TARGET_FOR_COVERAGE(linked_list_test linked_list_test ${CMAKE_BINARY_DIR}/coverage/linked_list_test/linked_list_test)
- SETUP_TARGET_FOR_COVERAGE(properties_test properties_test ${CMAKE_BINARY_DIR}/coverage/properties_test/properties_test)
- SETUP_TARGET_FOR_COVERAGE(utils_test utils_test ${CMAKE_BINARY_DIR}/coverage/utils_test/utils_test)
-
- endif(ENABLE_TESTING AND UTILS-TESTS)
-endif (UTILS)
+target_include_directories(utils PUBLIC include ${MEMSTREAM_INCLUDE_DIR})
+target_include_directories(utils PRIVATE src)
+set_target_properties(utils PROPERTIES "SOVERSION" 2)
+
+IF(UNIX AND NOT ANDROID)
+ target_link_libraries(utils PRIVATE m pthread)
+ELSEIF(ANDROID)
+ target_link_libraries(utils PRIVATE m)
+ENDIF()
+
+install(TARGETS utils DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT framework)
+
+#Alias setup to match external usage
+add_library(Celix::utils ALIAS utils)
+
+
+celix_subproject(UTILS-TESTS "Option to build the utilities library tests" "OFF")
+if (ENABLE_TESTING AND UTILS-TESTS)
+ find_package(CppUTest REQUIRED)
+
+ SET(CMAKE_SKIP_BUILD_RPATH FALSE)
+ SET(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
+ SET(CMAKE_INSTALL_RPATH "${PROJECT_BINARY_DIR}/utils")
+
+
+ include_directories(${CUNIT_INCLUDE_DIRS})
+ include_directories(${CPPUTEST_INCLUDE_DIR})
+ include_directories(include)
+ include_directories(src)
+
+ add_executable(hash_map_test private/test/hash_map_test.cpp)
+ target_link_libraries(hash_map_test Celix::utils ${CPPUTEST_LIBRARY} pthread)
+
+ add_executable(array_list_test private/test/array_list_test.cpp)
+ target_link_libraries(array_list_test Celix::utils ${CPPUTEST_LIBRARY} pthread)
+
+ add_executable(celix_threads_test private/test/celix_threads_test.cpp)
+ target_link_libraries(celix_threads_test Celix::utils ${CPPUTEST_LIBRARY} ${CPPUTEST_EXT_LIBRARY} pthread)
+ add_executable(linked_list_test private/test/linked_list_test.cpp)
+ target_link_libraries(linked_list_test Celix::utils ${CPPUTEST_LIBRARY} pthread)
+
+ add_executable(thread_pool_test private/test/thread_pool_test.cpp)
+ target_link_libraries(thread_pool_test Celix::utils ${CPPUTEST_LIBRARY} pthread)
+
+ add_executable(properties_test private/test/properties_test.cpp)
+ target_link_libraries(properties_test ${CPPUTEST_LIBRARY} ${CPPUTEST_EXT_LIBRARY} Celix::utils pthread)
+
+ add_executable(utils_test private/test/utils_test.cpp)
+ target_link_libraries(utils_test ${CPPUTEST_LIBRARY} Celix::utils pthread)
+
+ configure_file(private/resources-test/properties.txt ${CMAKE_BINARY_DIR}/utils/resources-test/properties.txt COPYONLY)
+
+ add_test(NAME run_array_list_test COMMAND array_list_test)
+ add_test(NAME run_hash_map_test COMMAND hash_map_test)
+ add_test(NAME run_celix_threads_test COMMAND celix_threads_test)
+ add_test(NAME run_thread_pool_test COMMAND thread_pool_test)
+ add_test(NAME run_linked_list_test COMMAND linked_list_test)
+ add_test(NAME run_properties_test COMMAND properties_test)
+ add_test(NAME run_utils_test COMMAND utils_test)
+
+ SETUP_TARGET_FOR_COVERAGE(array_list_test array_list_test ${CMAKE_BINARY_DIR}/coverage/array_list_test/array_list_test)
+ SETUP_TARGET_FOR_COVERAGE(hash_map hash_map_test ${CMAKE_BINARY_DIR}/coverage/hash_map_test/hash_map_test)
+ SETUP_TARGET_FOR_COVERAGE(celix_threads_test celix_threads_test ${CMAKE_BINARY_DIR}/coverage/celix_threads_test/celix_threads_test)
+ SETUP_TARGET_FOR_COVERAGE(thread_pool_test thread_pool_test ${CMAKE_BINARY_DIR}/coverage/thread_pool_test/thread_pool_test)
+ SETUP_TARGET_FOR_COVERAGE(linked_list_test linked_list_test ${CMAKE_BINARY_DIR}/coverage/linked_list_test/linked_list_test)
+ SETUP_TARGET_FOR_COVERAGE(properties_test properties_test ${CMAKE_BINARY_DIR}/coverage/properties_test/properties_test)
+ SETUP_TARGET_FOR_COVERAGE(utils_test utils_test ${CMAKE_BINARY_DIR}/coverage/utils_test/utils_test)
+
+endif(ENABLE_TESTING AND UTILS-TESTS)
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/utils/include/array_list.h
----------------------------------------------------------------------
diff --git a/utils/include/array_list.h b/utils/include/array_list.h
new file mode 100644
index 0000000..4f83a45
--- /dev/null
+++ b/utils/include/array_list.h
@@ -0,0 +1,99 @@
+/**
+ *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.
+ */
+/*
+ * array_list.h
+ *
+ * \date Aug 4, 2010
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+
+#ifndef ARRAY_LIST_H_
+#define ARRAY_LIST_H_
+
+#include "celixbool.h"
+#include "exports.h"
+#include "celix_errno.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct arrayList *array_list_pt;
+
+typedef struct arrayListIterator *array_list_iterator_pt;
+
+typedef celix_status_t (*array_list_element_equals_pt)(const void *, const void *, bool *equals);
+
+UTILS_EXPORT celix_status_t arrayList_create(array_list_pt *list);
+
+UTILS_EXPORT celix_status_t arrayList_createWithEquals(array_list_element_equals_pt equals, array_list_pt *list);
+
+UTILS_EXPORT void arrayList_destroy(array_list_pt list);
+
+UTILS_EXPORT void arrayList_trimToSize(array_list_pt list);
+
+UTILS_EXPORT void arrayList_ensureCapacity(array_list_pt list, int capacity);
+
+UTILS_EXPORT unsigned int arrayList_size(array_list_pt list);
+
+UTILS_EXPORT bool arrayList_isEmpty(array_list_pt list);
+
+UTILS_EXPORT bool arrayList_contains(array_list_pt list, void *element);
+
+UTILS_EXPORT int arrayList_indexOf(array_list_pt list, void *element);
+
+UTILS_EXPORT int arrayList_lastIndexOf(array_list_pt list, void *element);
+
+UTILS_EXPORT void *arrayList_get(array_list_pt list, unsigned int index);
+
+UTILS_EXPORT void *arrayList_set(array_list_pt list, unsigned int index, void *element);
+
+UTILS_EXPORT bool arrayList_add(array_list_pt list, void *element);
+
+UTILS_EXPORT int arrayList_addIndex(array_list_pt list, unsigned int index, void *element);
+
+UTILS_EXPORT bool arrayList_addAll(array_list_pt list, array_list_pt toAdd);
+
+UTILS_EXPORT void *arrayList_remove(array_list_pt list, unsigned int index);
+
+UTILS_EXPORT bool arrayList_removeElement(array_list_pt list, void *element);
+
+UTILS_EXPORT void arrayList_clear(array_list_pt list);
+
+UTILS_EXPORT array_list_pt arrayList_clone(array_list_pt list);
+
+UTILS_EXPORT array_list_iterator_pt arrayListIterator_create(array_list_pt list);
+
+UTILS_EXPORT void arrayListIterator_destroy(array_list_iterator_pt iterator);
+
+UTILS_EXPORT bool arrayListIterator_hasNext(array_list_iterator_pt iterator);
+
+UTILS_EXPORT void *arrayListIterator_next(array_list_iterator_pt iterator);
+
+UTILS_EXPORT bool arrayListIterator_hasPrevious(array_list_iterator_pt iterator);
+
+UTILS_EXPORT void *arrayListIterator_previous(array_list_iterator_pt iterator);
+
+UTILS_EXPORT void arrayListIterator_remove(array_list_iterator_pt iterator);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* ARRAY_LIST_H_ */
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/utils/include/celix_errno.h
----------------------------------------------------------------------
diff --git a/utils/include/celix_errno.h b/utils/include/celix_errno.h
new file mode 100644
index 0000000..b51540b
--- /dev/null
+++ b/utils/include/celix_errno.h
@@ -0,0 +1,119 @@
+/*
+ *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.
+ */
+/*
+ * celix_errno.h
+ *
+ * \date Feb 15, 2011
+ * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
+ * \copyright Apache License, Version 2.0
+ */
+/*!
+ \file
+ \brief Error codes
+ \defgroup framework Celix Framework
+ */
+#ifndef CELIX_ERRNO_H_
+#define CELIX_ERRNO_H_
+
+#include <stddef.h>
+#include <errno.h>
+
+#include "exports.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+ * Helper macro which check the current status and executes the provided expression if the
+ * status is still CELIX_SUCCESS (0)
+ */
+#define CELIX_DO_IF(status, expr) ((status) == CELIX_SUCCESS) ? (expr) : (status)
+
+/*!
+ * \defgroup celix_errno Error Codes
+ * \ingroup framework
+ * \{
+ */
+
+struct celix_status {
+ int code;
+ char *error;
+};
+
+/*!
+ * Status type returned by all functions in Celix
+ */
+typedef int celix_status_t;
+
+/*!
+ * Return a readable string for the given error code.
+ *
+ */
+UTILS_EXPORT char *celix_strerror(celix_status_t errorcode, char *buffer, size_t bufferSize);
+
+/*!
+ * Error code indicating successful execution of the function.
+ */
+#define CELIX_SUCCESS 0
+
+/*!
+ * Starting point for Celix errors.
+ */
+#define CELIX_START_ERROR 70000
+
+/*!
+ * The range for Celix errors.
+ */
+#define CELIX_ERRSPACE_SIZE 1000
+
+/*!
+ * The start error number user application can use.
+ */
+#define CELIX_START_USERERR (CELIX_START_ERROR + CELIX_ERRSPACE_SIZE)
+
+/*!
+ * Exception indicating a problem with a bundle
+ */
+#define CELIX_BUNDLE_EXCEPTION (CELIX_START_ERROR + 1)
+/*!
+ * Invalid bundle context is used
+ */
+#define CELIX_INVALID_BUNDLE_CONTEXT (CELIX_START_ERROR + 2)
+/*!
+ * Argument is not correct
+ */
+#define CELIX_ILLEGAL_ARGUMENT (CELIX_START_ERROR + 3)
+#define CELIX_INVALID_SYNTAX (CELIX_START_ERROR + 4)
+#define CELIX_FRAMEWORK_SHUTDOWN (CELIX_START_ERROR + 5)
+#define CELIX_ILLEGAL_STATE (CELIX_START_ERROR + 6)
+#define CELIX_FRAMEWORK_EXCEPTION (CELIX_START_ERROR + 7)
+#define CELIX_FILE_IO_EXCEPTION (CELIX_START_ERROR + 8)
+#define CELIX_SERVICE_EXCEPTION (CELIX_START_ERROR + 9)
+
+#define CELIX_ENOMEM ENOMEM
+
+/**
+ * \}
+ */
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CELIX_ERRNO_H_ */