Beispiel #1
0
kaa_error_t kaa_init(kaa_context_t **kaa_context_p)
{
    KAA_RETURN_IF_NIL(kaa_context_p, KAA_ERR_BADPARAM);

    // Initialize logger
    kaa_logger_t *logger = NULL;

    FILE *logfile = fopen("run.log", "w");

    kaa_error_t error = kaa_log_create(&logger, KAA_MAX_LOG_MESSAGE_LENGTH, KAA_MAX_LOG_LEVEL, logfile); // TODO: make log destination configurable
    if (error)
        return error;

    KAA_LOG_INFO(logger, KAA_ERR_NONE, "Kaa SDK version %s, commit hash %s", BUILD_VERSION, BUILD_COMMIT_HASH);

    // Initialize general Kaa context
    error = kaa_context_create(kaa_context_p, logger);
    if (error) {
        KAA_LOG_FATAL(logger, error, "Failed to create Kaa context");
        kaa_log_destroy(logger);
        *kaa_context_p = NULL;
        return error;
    }

    // Initialize endpoint identity
    char *pub_key_buffer = NULL;
    size_t pub_key_buffer_size = 0;
    bool need_deallocation = false;

    ext_get_endpoint_public_key(&pub_key_buffer, &pub_key_buffer_size, &need_deallocation);
    kaa_digest pub_key_hash;
    error = ext_calculate_sha_hash(pub_key_buffer, pub_key_buffer_size, pub_key_hash);

    if (need_deallocation && pub_key_buffer_size > 0) {
        KAA_FREE(pub_key_buffer);
    }

    if (error) {
        KAA_LOG_FATAL(logger, error, "Failed to calculate EP ID");
        kaa_context_destroy(*kaa_context_p);
        *kaa_context_p = NULL;
        kaa_log_destroy(logger);
        return error;
    }

    error = ext_copy_sha_hash((*kaa_context_p)->status->status_instance->endpoint_public_key_hash, pub_key_hash);
    if (error) {
        KAA_LOG_FATAL(logger, error, "Failed to set Endpoint public key");
        kaa_context_destroy(*kaa_context_p);
        *kaa_context_p = NULL;
        kaa_log_destroy(logger);
        return error;
    }
    return KAA_ERR_NONE;
}
Beispiel #2
0
static kaa_error_t kaa_context_create(kaa_context_t **context_p, kaa_logger_t *logger)
{
    // TODO(KAA-982): use asserts
    if (!context_p || !logger) {
        return KAA_ERR_BADPARAM;
    }

    kaa_context_t *context = KAA_CALLOC(1, sizeof(*context));
    if (!context) {
        return KAA_ERR_NOMEM;
    }

    context->logger = logger;

    kaa_error_t error = KAA_ERR_NONE;
    context->status = KAA_CALLOC(1, sizeof(*context->status));
    if (!context->status) {
        error = KAA_ERR_NOMEM;
        goto exit;
    }

    error = kaa_status_create(&context->status->status_instance);
    if (error) {
        goto exit;
    }

    error = kaa_platform_protocol_create(&context->platform_protocol, context->logger,
            context->status->status_instance);
    if (error) {
        goto exit;
    }

    error = kaa_channel_manager_create(&context->channel_manager, context);
    if (error) {
        goto exit;
    }

    error = kaa_extension_init_all(context);
    if (error) {
        goto exit;
    }

    error = kaa_failover_strategy_create(&context->failover_strategy, logger);
    if (error) {
        goto extensions_deinit;
    }

    *context_p = context;

    return KAA_ERR_NONE;

extensions_deinit:
    kaa_extension_deinit_all();

exit:
    kaa_context_destroy(context);

    return error;
}
Beispiel #3
0
kaa_error_t kaa_deinit(kaa_context_t *kaa_context)
{
    KAA_RETURN_IF_NIL(kaa_context, KAA_ERR_BADPARAM);

    kaa_logger_t *logger = kaa_context->logger;
    kaa_error_t error = kaa_context_destroy(kaa_context);
    if (error)
        KAA_LOG_ERROR(logger, error, "Failed to destroy Kaa context");
    kaa_log_destroy(logger);
    return error;
}
Beispiel #4
0
static kaa_error_t kaa_context_create(kaa_context_t **context_p, kaa_logger_t *logger)
{
    KAA_RETURN_IF_NIL2(context_p, logger, KAA_ERR_BADPARAM);

    *context_p = (kaa_context_t *) KAA_MALLOC(sizeof(kaa_context_t));
    KAA_RETURN_IF_NIL(*context_p, KAA_ERR_NOMEM);

    (*context_p)->logger = logger;

    kaa_error_t error = KAA_ERR_NONE;
    (*context_p)->status = (kaa_status_holder_t *) KAA_MALLOC(sizeof(kaa_status_holder_t));
    if (!(*context_p)->status)
        error = KAA_ERR_NOMEM;

    if (!error)
        error = kaa_status_create(&((*context_p)->status->status_instance));

    if (!error)
        error = kaa_platform_protocol_create(&((*context_p)->platfrom_protocol), *context_p,
                                             (*context_p)->status->status_instance);

    if (!error)
        error = kaa_channel_manager_create(&((*context_p)->channel_manager), (*context_p));

    if (!error)
        error = kaa_bootstrap_manager_create(&((*context_p)->bootstrap_manager), (*context_p)->channel_manager,
                                             (*context_p)->logger);

    if (!error)
        error = kaa_profile_manager_create(&((*context_p)->profile_manager), (*context_p)->status->status_instance,
                                           (*context_p)->channel_manager, (*context_p)->logger);

#ifndef KAA_DISABLE_FEATURE_EVENTS
    if (!error)
        error = kaa_event_manager_create(&((*context_p)->event_manager), (*context_p)->status->status_instance,
                                         (*context_p)->channel_manager, (*context_p)->logger);
#else
    (*context_p)->event_manager = NULL;
#endif

#ifndef KAA_DISABLE_FEATURE_LOGGING
    if (!error)
        error = kaa_log_collector_create(&((*context_p)->log_collector), (*context_p)->status->status_instance,
                                         (*context_p)->channel_manager, (*context_p)->logger);
#else
    (*context_p)->log_collector = NULL;
#endif

#ifndef KAA_DISABLE_FEATURE_CONFIGURATION
    if (!error)
        error = kaa_configuration_manager_create(&((*context_p)->configuration_manager), (*context_p)->channel_manager,
                                                 (*context_p)->status->status_instance, (*context_p)->logger);
#else
    (*context_p)->configuration_manager = NULL;
#endif

    if (!error)
        error = kaa_user_manager_create(&((*context_p)->user_manager), (*context_p)->status->status_instance,
                                        (*context_p)->channel_manager, (*context_p)->logger);

    if (error) {
        kaa_context_destroy(*context_p);
        *context_p = NULL;
    }

    return error;
}
Beispiel #5
0
static kaa_error_t kaa_context_create(kaa_context_t **context_p, kaa_logger_t *logger)
{
    KAA_RETURN_IF_NIL2(context_p, logger, KAA_ERR_BADPARAM);

    kaa_context_t *context = KAA_MALLOC(sizeof(*context));
    KAA_RETURN_IF_NIL(context, KAA_ERR_NOMEM);

    context->logger = logger;

    kaa_error_t error = KAA_ERR_NONE;
    context->status = KAA_MALLOC(sizeof(*context->status));
    if (!context->status)
        error = KAA_ERR_NOMEM;

    if (!error)
        error = kaa_status_create(&context->status->status_instance);

    if (!error)
        error = kaa_platform_protocol_create(&context->platform_protocol, context,
                                             context->status->status_instance);

    if (!error)
        error = kaa_channel_manager_create(&context->channel_manager, context);

    if (!error)
        error = kaa_bootstrap_manager_create(&context->bootstrap_manager, context);

    if (!error)
        error = kaa_profile_manager_create(&context->profile_manager, context->status->status_instance,
                                           context->channel_manager, context->logger);

    if (!error)
        error = kaa_failover_strategy_create(&context->failover_strategy, logger);

#ifndef KAA_DISABLE_FEATURE_EVENTS
    if (!error)
        error = kaa_event_manager_create(&context->event_manager, context->status->status_instance,
                                         context->channel_manager, context->logger);
#else
    context->event_manager = NULL;
#endif

#ifndef KAA_DISABLE_FEATURE_LOGGING
    if (!error)
        error = kaa_log_collector_create(&context->log_collector, context->status->status_instance,
                                         context->channel_manager, context->logger);
#else
    context->log_collector = NULL;
#endif

#ifndef KAA_DISABLE_FEATURE_CONFIGURATION
    if (!error)
        error = kaa_configuration_manager_create(&context->configuration_manager, context->channel_manager,
                                                 context->status->status_instance, context->logger);
#else
    context->configuration_manager = NULL;
#endif

#ifndef KAA_DISABLE_FEATURE_NOTIFICATION
    if (!error)
        error = kaa_notification_manager_create(&context->notification_manager, context->status->status_instance,
                                                context->channel_manager, context->logger);
#else
    context->notification_manager = NULL;
#endif

    if (!error)
        error = kaa_user_manager_create(&context->user_manager, context->status->status_instance,
                                        context->channel_manager, context->logger);


    if (error) {
        kaa_context_destroy(context);
        *context_p = NULL;
    } else {
        *context_p = context;
    }

    return error;
}