Introduce cloudproxy servicejellyfish_9.99.4jellyfish_9.99.3jellyfish_9.99.2jellyfish/9.99.4jellyfish/9.99.3jellyfish/9.99.29.99.49.99.39.99.2

Cloudproxy service allows applications to communicate with clouds.
The commit includes the test applications as sample for real client imlementation.

Bug-AGL: SPEC-3370

Change-Id: I82d8122e93d01451f4471cc20c706e75c16f1c29
Signed-off-by: maratsabitov <marat.sabitov@mera.com>

1 files changed, 441 insertions, 0 deletions

diff --git a/src/cloudproxy-bindings.cpp b/src/cloudproxy-bindings.cpp
new file mode 100755
index 0000000..1a40730
--- /dev/null
+++ b/src/cloudproxy-bindings.cpp
@@ -0,0 +1,441 @@
+/*
+ * Copyright (C) 2020 MERA
+ *
+ * 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 <afb/afb-binding.h>
+#include <json-c/json.h>
+
+#include <memory>
+#include <algorithm>
+
+#include <iothub.h>
+#include <iothub_device_client.h>
+#include <iothub_client_options.h>
+#include <iothub_message.h>
+#include <iothubtransportmqtt.h>
+#include <azure_c_shared_utility/threadapi.h> // ThreadAPI_Sleep()
+#include <azure_c_shared_utility/tickcounter.h> // tickcounter_ms_t
+
+#include "hmi-debug.h"
+#include "utils.h"
+#include "ClientManager.h"
+
+#include <glib.h>
+
+static const char* API_name{"cloudproxy"};
+
+static std::string g_connectionString;
+static IOTHUB_DEVICE_CLIENT_HANDLE g_device_handle{nullptr};
+static bool g_iot_inited{false};
+
+
+
+static utils::scope_exit g_destroy([]{
+    if (g_iot_inited)
+    {
+        if (g_device_handle)
+            IoTHubDeviceClient_Destroy(g_device_handle);
+
+        IoTHub_Deinit();
+    }
+});
+
+
+static bool loadConf()
+{
+    const char* CONF_FILE_PATH{"/etc/config.ini"};
+    const char* DEFAULT_ETC_PATH{"/etc/cloudproxy-service"};
+    const char *p = getenv("AFM_APP_INSTALL_DIR");
+    if(!p)
+    {
+        HMI_ERROR("cloudproxy-service", "AFM_APP_INSTALL_DIR is not set, try to find conf in %s", DEFAULT_ETC_PATH);
+        p = DEFAULT_ETC_PATH;
+    }
+
+    std::string conf_path = p;
+    conf_path += CONF_FILE_PATH;
+
+    g_autoptr(GKeyFile) conf_file = g_key_file_new();
+    g_autoptr(GError) error = nullptr;
+
+    if (!conf_file || !g_key_file_load_from_file(conf_file, conf_path.c_str(), G_KEY_FILE_NONE, &error))
+    {
+        HMI_ERROR("cloudproxy-service", "can't load file %s", conf_path.c_str());
+        return false;
+    }
+
+    g_autofree gchar *value = g_key_file_get_string(conf_file, "AzureCloudConnection", "DeviceConnectionString", &error);
+    if (value == nullptr)
+    {
+        HMI_ERROR("cloudproxy-service", "can't read DeviceConnectionString from config %d", conf_path.c_str());
+        return false;
+    }
+
+    g_connectionString = value;
+    if (g_connectionString.empty())
+    {
+        HMI_ERROR("cloudproxy-service", "DeviceConnectionString is empty");
+        return false;
+    }
+
+    return true;
+}
+
+
+//--------------  Iot callbacks
+static void connection_status_callback(IOTHUB_CLIENT_CONNECTION_STATUS result, IOTHUB_CLIENT_CONNECTION_STATUS_REASON reason, void* user_context)
+{
+    HMI_NOTICE("cloudproxy-service", "%s called: result %d, reason %d", __FUNCTION__, result, reason);
+
+    (void)reason;
+    (void)user_context;
+    // This sample DOES NOT take into consideration network outages.
+    if (result == IOTHUB_CLIENT_CONNECTION_AUTHENTICATED && reason == IOTHUB_CLIENT_CONNECTION_OK)
+    {
+        HMI_NOTICE("cloudproxy-service", "The device client is connected to iothub");
+    }
+    else
+    {
+        HMI_NOTICE("cloudproxy-service", "The device client has been disconnected");
+    }
+}
+
+static IOTHUBMESSAGE_DISPOSITION_RESULT receive_msg_callback(IOTHUB_MESSAGE_HANDLE message, void* user_context)
+{
+    HMI_NOTICE("cloudproxy-service", "%s called", __FUNCTION__);
+    (void)user_context;
+    const char* messageId;
+    const char* correlationId;
+
+    IOTHUBMESSAGE_CONTENT_TYPE content_type = IoTHubMessage_GetContentType(message);
+
+    if (content_type == IOTHUBMESSAGE_BYTEARRAY)
+    {
+        const unsigned char* buff_msg;
+        size_t buff_len;
+
+        if (IoTHubMessage_GetByteArray(message, &buff_msg, &buff_len) != IOTHUB_MESSAGE_OK)
+        {
+            HMI_ERROR("cloudproxy-service", "Failure retrieving byte array message");
+        }
+        else
+        {
+            HMI_NOTICE("cloudproxy-service", "Received Binary message, size %d, data '%.*s'", (int)buff_len, (int)buff_len, buff_msg);
+        }
+
+        const char* app_id = IoTHubMessage_GetProperty(message, "application_id");
+        HMI_NOTICE("cloudproxy-service", "Received property 'application_id': %s", (app_id ? app_id : "<unavailable>"));
+
+        if (app_id && app_id[0])
+            ClientManager::instance().emitReceivedMessage(app_id, std::string((const char*)buff_msg, buff_len));
+        else
+            HMI_ERROR("cloudproxy-service", "Can't emit SendMessageConfirmation: appid is not valid");
+    }
+    else if (content_type == IOTHUBMESSAGE_STRING)
+    {
+        const char* string_msg = IoTHubMessage_GetString(message);
+        if (string_msg == nullptr)
+        {
+            HMI_NOTICE("cloudproxy-service", "Failure retrieving String message");
+        }
+        else
+        {
+            HMI_NOTICE("cloudproxy-service", "Received String message, size %d, data '%s'", strlen(string_msg), string_msg);
+        }
+
+        const char* app_id = IoTHubMessage_GetProperty(message, "application_id");
+        HMI_NOTICE("cloudproxy-service", "Received property 'application_id': %s", (app_id ? app_id : "<unavailable>"));
+
+        if (app_id && app_id[0])
+            ClientManager::instance().emitReceivedMessage(app_id, string_msg);
+        else
+            HMI_ERROR("cloudproxy-service", "Can't emit SendMessageConfirmation: appid is not valid");
+    }
+    else
+    {
+        HMI_ERROR("cloudproxy-service", "Unsupported message content type");
+    }
+
+    return IOTHUBMESSAGE_ACCEPTED;
+}
+
+
+static int device_method_callback(const char* method_name, const unsigned char* payload, size_t size, unsigned char** response, size_t* resp_size, void* userContextCallback)
+{
+    HMI_NOTICE("cloudproxy-service", "%s called, method_name %s", __FUNCTION__, method_name);
+
+    const char* device_id = (const char*)userContextCallback;
+    char* end = nullptr;
+    int newInterval;
+
+    int status = 501;
+    const char* RESPONSE_STRING = "{ \"Response\": \"Unknown method requested.\" }";
+
+    HMI_NOTICE("cloudproxy-service", "Device Method called for device %s", device_id);
+    HMI_NOTICE("cloudproxy-service", "Device Method name:    %s", method_name);
+    HMI_NOTICE("cloudproxy-service", "Device Method payload: %.*s", (int)size, (const char*)payload);
+
+    HMI_NOTICE("cloudproxy-service", "Response status: %d", status);
+    HMI_NOTICE("cloudproxy-service", "Response payload: %s", RESPONSE_STRING);
+
+    *resp_size = strlen(RESPONSE_STRING);
+    if ((*response = (unsigned char*)malloc(*resp_size)) == NULL)
+    {
+        status = -1;
+    }
+    else
+    {
+        memcpy(*response, RESPONSE_STRING, *resp_size);
+    }
+
+    return status;
+}
+
+
+static void send_confirm_callback(IOTHUB_CLIENT_CONFIRMATION_RESULT result, void* userContextCallback)
+{
+    HMI_NOTICE("cloudproxy-service", "%s called, result %d", __FUNCTION__, result);
+    (void)userContextCallback;
+    // When a message is sent this callback will get invoked
+
+    HMI_NOTICE("cloudproxy-service", "Confirmation callback result %s", MU_ENUM_TO_STRING(IOTHUB_CLIENT_CONFIRMATION_RESULT, result));
+
+    const char* appid = (const char*)userContextCallback;
+    if (!appid || !appid[0])
+    {
+        HMI_ERROR("cloudproxy-service", "Confirmation callback: appid is not set");
+
+        if (userContextCallback)
+            free(userContextCallback);
+
+        return;
+    }
+
+    ClientManager::instance().emitSendMessageConfirmation(appid, result == IOTHUB_CLIENT_CONFIRMATION_OK);
+    free(userContextCallback);
+}
+//--------------
+
+//-------------- help functions
+static bool createConnection()
+{
+    HMI_NOTICE("cloudproxy-service", "%s called", __FUNCTION__);
+
+    if (g_device_handle)
+    {
+        HMI_WARNING("cloudproxy-service", "connection already created");
+        return true;
+    }
+
+    g_device_handle = IoTHubDeviceClient_CreateFromConnectionString(g_connectionString.c_str(), MQTT_Protocol);
+    if (!g_device_handle)
+    {
+        HMI_ERROR("cloudproxy-service", "Failure creating IoTHubDeviceClient device");
+        return false;
+    }
+
+    bool traceOn = false;
+    IoTHubDeviceClient_SetOption(g_device_handle, OPTION_LOG_TRACE, &traceOn);
+    IoTHubDeviceClient_SetConnectionStatusCallback(g_device_handle, connection_status_callback, nullptr);
+    IoTHubDeviceClient_SetMessageCallback(g_device_handle, receive_msg_callback, nullptr);
+    IoTHubDeviceClient_SetDeviceMethodCallback(g_device_handle, device_method_callback, nullptr);
+
+    tickcounter_ms_t ms_delay = 10;
+    IoTHubDeviceClient_SetOption(g_device_handle, OPTION_DO_WORK_FREQUENCY_IN_MS, &ms_delay); // DoWork multithread
+
+    return true;
+}
+
+//--------------
+
+
+static void pingSample(afb_req_t request)
+{
+   static int pingcount = 0;
+   afb_req_success_f(request, json_object_new_int(pingcount), "Ping count = %d", pingcount);
+   HMI_NOTICE("cloudproxy-service", "Verbosity macro at level notice invoked at ping invocation count = %d", pingcount);
+   pingcount++;
+}
+
+
+static bool initAzureSdk()
+{
+    //Allow program to try to establish connection several times
+    if (!g_iot_inited)
+    {
+        if(IoTHub_Init())
+        {
+            HMI_ERROR("cloudproxy-service","Azure IoTHub_Init() failed");
+        }
+        else
+        {
+            g_iot_inited = true;
+        }
+    }
+
+    return g_iot_inited;
+}
+
+static void sendMessage(afb_req_t request)
+{
+    HMI_NOTICE("cloudproxy-service", "%s called", __FUNCTION__);
+
+    json_object* object = afb_req_json(request);
+    if (!object)
+    {
+        HMI_ERROR("cloudproxy-service", "Can't parse request");
+        afb_req_fail_f(request, "failed", "called %s", __FUNCTION__);
+        return;
+    }
+
+    const std::string appid{utils::get_application_id(request)};
+    std::string data;
+    json_object *obj_data;
+    if(!json_object_object_get_ex(object, "data", &obj_data))
+    {
+        HMI_ERROR("cloudproxy-service", "can't obtain application_id or data from request");
+        return;
+    }
+    data = json_object_get_string(obj_data);
+
+    if (!g_device_handle && !createConnection())
+    {
+        HMI_ERROR("cloudproxy-service", "Can't create connection to cloud");
+        afb_req_fail_f(request, "failed", "called %s", __FUNCTION__);
+        return;
+    }
+
+    IOTHUB_MESSAGE_HANDLE message_handle = IoTHubMessage_CreateFromString(data.c_str());
+
+    utils::scope_exit message_handle_destroy([&message_handle](){
+        // The message is copied to the sdk, so the we can destroy it
+        if (message_handle)
+            IoTHubMessage_Destroy(message_handle);
+    });
+
+    if (!message_handle)
+    {
+        HMI_ERROR("cloudproxy-service", "Can't create IoTHubMessage message");
+        afb_req_fail_f(request, "failed", "called %s", __FUNCTION__);
+        return;
+    }
+
+    IoTHubMessage_SetProperty(message_handle, "application_id", appid.c_str());
+
+    if (IoTHubDeviceClient_SendEventAsync(g_device_handle, message_handle, send_confirm_callback, strdup(appid.c_str())))
+    {
+        HMI_ERROR("cloudproxy-service", "Can't send IoTHubMessage message");
+        afb_req_fail_f(request, "failed", "called %s", __FUNCTION__);
+        return;
+    }
+
+    afb_req_success(request, json_object_new_object(), __FUNCTION__);
+}
+
+
+static void subscribe(afb_req_t request)
+{
+    HMI_NOTICE("cloudproxy-service", "%s called", __FUNCTION__);
+
+    std::string req_appid{utils::get_application_id(request)};
+    if(req_appid.empty())
+    {
+        HMI_ERROR("cloudproxy-service", "Can't subscribe: empty appid");
+        afb_req_fail_f(request, "%s failed: application_id is not defined in request", __FUNCTION__);
+        return;
+    }
+
+    if (!ClientManager::instance().handleRequest(request, __FUNCTION__, req_appid))
+    {
+        HMI_ERROR("cloudproxy-service", "%s failed in handleRequest", __FUNCTION__);
+        afb_req_fail_f(request, "%s failed", __FUNCTION__);
+    }
+    else
+    {
+        afb_req_success(request, json_object_new_object(), __FUNCTION__);
+    }
+}
+
+static void unsubscribe(afb_req_t request)
+{
+    HMI_NOTICE("cloudproxy-service", "%s called", __FUNCTION__);
+
+    std::string req_appid{utils::get_application_id(request)};
+    if(req_appid.empty())
+    {
+        HMI_ERROR("cloudproxy-service", "Can't unsubscribe: empty appid");
+        afb_req_fail_f(request, "%s failed: application_id is not defined in request", __FUNCTION__);
+        return;
+    }
+
+    if (!ClientManager::instance().handleRequest(request, __FUNCTION__, req_appid))
+    {
+        HMI_ERROR("cloudproxy-service", "%s failedin handleRequest", __FUNCTION__);
+        afb_req_fail_f(request, "%s failed", __FUNCTION__);
+    }
+    else
+    {
+        afb_req_success(request, json_object_new_object(), __FUNCTION__);
+    }
+}
+
+/*
+ * array of the verbs exported to afb-daemon
+ */
+static const afb_verb_t verbs[]= {
+    /* VERB'S NAME                 FUNCTION TO CALL                  */
+    { .verb="ping",              .callback=pingSample             },
+    { .verb="sendMessage",       .callback=sendMessage            },
+    { .verb="subscribe",         .callback=subscribe              },
+    { .verb="unsubscribe",       .callback=unsubscribe            },
+    {nullptr } /* marker for end of the array */
+};
+
+
+static int preinit(afb_api_t api)
+{
+    HMI_NOTICE("cloudproxy-service", "binding preinit (was register)");
+
+    if (!loadConf())
+    {
+        HMI_ERROR("cloudproxy-service", "Can't load configuration file or configuration is wrong");
+        return -1;
+    }
+
+    if (!initAzureSdk())
+    {
+        HMI_ERROR("cloudproxy-service", "Can't initialize Azure SDK");
+        return -1;
+    }
+
+    return 0;
+}
+
+
+static int init(afb_api_t api)
+{
+    HMI_NOTICE("cloudproxy-service","binding init");
+    return (g_iot_inited ? 0 : -1);
+}
+
+const afb_binding_t afbBindingExport = {
+    .api = "cloudproxy",
+    .specification = nullptr,
+    .info = nullptr,
+    .verbs = verbs,
+    .preinit = preinit,
+    .init = init,
+    .onevent = nullptr
+};