void KaaClient::syncTopicSubscriptions() {
#ifdef KAA_USE_NOTIFICATIONS
notificationManager_->sync();
#else
throw KaaException("Failed to get synchronized . Notification subsystem is disabled");
#endif
}
void KaaClient::setAttachStatusListener(IAttachStatusListenerPtr listener) {
#ifdef KAA_USE_EVENTS
return registrationManager_->setAttachStatusListener(listener);
#else
throw KaaException("Failed to set listerner's status. Event subsystem is disabled");
#endif
}
void KaaClient::subscribeToTopic(const std::string& id, bool forceSync) {
#ifdef KAA_USE_NOTIFICATIONS
notificationManager_->subscribeToTopic(id, forceSync);
#else
throw KaaException("Failed to subscribe to topics. Notification subsystem is disabled");
#endif
}
void KaaClient::unsubscribeFromTopics(const std::list<std::string>& idList, bool forceSync) {
#ifdef KAA_USE_NOTIFICATIONS
notificationManager_->unsubscribeFromTopics(idList, forceSync);
#else
throw KaaException("Failed to unsubscribe to topics. Notification subsystem is disabled");
#endif
}
void KaaClient::addNotificationListener(INotificationListener& listener) {
#ifdef KAA_USE_NOTIFICATIONS
notificationManager_->addNotificationListener(listener);
#else
throw KaaException("Failed to add notification listener. Notification subsystem is disabled");
#endif
}
void KaaClient::removeNotificationListener(const std::string& topidId, INotificationListener& listener) {
#ifdef KAA_USE_NOTIFICATIONS
notificationManager_->removeNotificationListener(topidId, listener);
#else
throw KaaException("Failed to remove notification listener. Notification subsystem is disabled");
#endif
}
void KaaClient::removeTopicListListener(INotificationTopicListListener& listener) {
#ifdef KAA_USE_NOTIFICATIONS
notificationManager_->removeTopicListListener(listener);
#else
throw KaaException("Failed to remove topic list listeners. Notification subsystem is disabled");
#endif
}
Topics KaaClient::getTopics() {
#ifdef KAA_USE_NOTIFICATIONS
return notificationManager_->getTopics();
#else
throw KaaException("Failed to get topics. Notification subsystem is disabled");
#endif
}
const KaaRootConfiguration& KaaClient::getConfiguration() {
#ifdef KAA_USE_CONFIGURATION
return configurationManager_->getConfiguration();
#else
throw KaaException("Failed to subscribe to get configuration. Configuration subsystem is disabled");
#endif
}
void KaaClient::removeConfigurationListener(IConfigurationReceiver &receiver) {
#ifdef KAA_USE_CONFIGURATION
configurationManager_->unsubscribeFromConfigurationChanges(receiver);
#else
throw KaaException("Failed to unsubscribe from configuration changes. Configuration subsystem is disabled");
#endif
}
void KaaClient::setConfigurationStorage(IConfigurationStoragePtr storage) {
#ifdef KAA_USE_CONFIGURATION
configurationPersistenceManager_->setConfigurationStorage(storage);
#else
throw KaaException("Failed to set configuration storage. Configuration subsystem is disabled");
#endif
}
std::int32_t EventManager::findEventListeners(const std::list<std::string>& eventFQNs, IFetchEventListenersPtr listener)
{
if (eventFQNs.empty() || !listener) {
KAA_LOG_WARN("Failed to add event listeners request: bad input data");
throw KaaException("Bad event listeners data");
}
std::int32_t requestId = UuidGenerator::generateRandomInt();
std::shared_ptr<EventListenersInfo> info(new EventListenersInfo);
info->eventFQNs_ = eventFQNs;
info->listener_ = listener;
{
KAA_MUTEX_LOCKING("eventListenersGuard_");
KAA_MUTEX_UNIQUE_DECLARE(eventListenersLock, eventListenersGuard_);
KAA_MUTEX_LOCKED("eventListenersGuard_");
eventListenersRequests_.insert(std::make_pair(requestId, info));
KAA_MUTEX_UNLOCKED("eventListenersGuard_");
}
KAA_LOG_TRACE("Added event listeners resolving request");
doSync();
return requestId;
}
bool KaaClient::isAttachedToUser() {
#ifdef KAA_USE_EVENTS
return registrationManager_->isAttachedToUser();
#else
throw KaaException("Failed to set listerner's status. Event subsystem is disabled");
#endif
}
ICommonRecord::fields_type CommonRecord::getField(const keys_type &field_name) const
{
if (!hasField(field_name)) {
throw KaaException(boost::format("Field with name %1% was not found in record") % field_name);
}
auto it = fields_.find(field_name);
return it->second;
}
void ConfigurationManager::addReceiver(IConfigurationReceiver &receiver)
{
if (!configurationReceivers_.addCallback(&receiver,
std::bind(&IConfigurationReceiver::onConfigurationUpdated,
&receiver, std::placeholders::_1))) {
throw KaaException("Failed to add a configuration changes subscriber. Already subscribed");
}
}
EventFamilyFactory& KaaClient::getEventFamilyFactory()
{
#ifdef KAA_USE_EVENTS
return *eventFamilyFactory_;
#else
throw KaaException("Failed to retrieve EventFamilyFactory. Event subsystem is disabled");
#endif
}
void CommonRecord::removeField(const keys_type &field_name)
{
if (!hasField(field_name)) {
throw KaaException(boost::format("Field with name %1% was not found in record") % field_name);
} else {
fields_.erase(field_name);
}
}
std::shared_ptr<IKaaClient> Kaa::newClient(IKaaClientPlatformContextPtr context
, IKaaClientStateListenerPtr listener)
{
if (!context) {
throw KaaException("Kaa client platform context is null");
}
return std::shared_ptr<IKaaClient>(new KaaClient(context, listener));
}
void KaaClient::attachUser(const std::string& userExternalId, const std::string& userAccessToken
, const std::string& userVerifierToken, IUserAttachCallbackPtr listener) {
#ifdef KAA_USE_EVENTS
return registrationManager_->attachUser(userExternalId, userAccessToken, userVerifierToken, listener);
#else
throw KaaException("Failed to attach user. Event subsystem is disabled");
#endif
}
void KaaClient::detachEndpoint(const std::string& endpointKeyHash
, IDetachEndpointCallbackPtr listener) {
#ifdef KAA_USE_EVENTS
return registrationManager_->detachEndpoint(endpointKeyHash, listener);
#else
throw KaaException("Failed to detach endpoint. Event subsystem is disabled");
#endif
}
void KaaClient::attachEndpoint(const std::string& endpointAccessToken
, IAttachEndpointCallbackPtr listener) {
#ifdef KAA_USE_EVENTS
return registrationManager_->attachEndpoint(endpointAccessToken, listener);
#else
throw KaaException("Failed to attach endpoint. Event subsystem is disabled");
#endif
}
void EndpointObjectHash::calculateHash(const std::uint8_t* data, std::uint32_t dataSize)
{
if (!data && dataSize != 0) {
throw KaaException("empty raw data or null size");
}
Botan::SHA_160 sha;
const auto& result = sha.process(data, dataSize);
hashDigest_.assign(result.begin(), result.end());
}
void BootstrapManager::setTransport(IBootstrapTransport* transport)
{
KAA_R_MUTEX_UNIQUE_DECLARE(lock, guard_);
bootstrapTransport_ = dynamic_cast<BootstrapTransport*>(transport);
if (bootstrapTransport_ != nullptr) {
return;
}
throw KaaException("Bad bootstrap transport");
}
void LogCollector::setUploadStrategy(ILogUploadStrategyPtr strategy)
{
if (!strategy) {
KAA_LOG_ERROR("Failed to set log upload strategy: bad data");
throw KaaException("Bad log upload strategy");
}
KAA_LOG_INFO("New log upload strategy was set");
uploadStrategy_ = strategy;
}
void KaaClient::setFailoverStrategy(IFailoverStrategyPtr strategy) {
if (!strategy) {
KAA_LOG_ERROR("Failed to set failover strategy: bad data");
throw KaaException("Bad failover strategy");
}
KAA_LOG_INFO("New failover strategy was set");
failoverStrategy_ = strategy;
channelManager_->setFailoverStrategy(failoverStrategy_);
}
void CommonRecord::setField(const keys_type &field_name, fields_type value)
{
if (hasField(field_name)) {
fields_[field_name] = value;
} else {
auto res = fields_.insert(std::make_pair(field_name, value));
if (!res.second) {
throw KaaException(boost::format("Failed to insert field \"%1%\" into record") % field_name);
}
}
}
void AvroByteArrayConverter<T>::fromByteArray(const std::uint8_t* data, const std::uint32_t& dataSize, T& datum)
{
if ((data && !dataSize) || (dataSize && !data)) {
throw KaaException("invalid data to decode");
}
std::unique_ptr<avro::InputStream> in = avro::memoryInputStream(data, dataSize);
decoder_->init(*in);
avro::decode(*decoder_, datum);
}
std::shared_ptr<ConfigurationSyncRequest> ConfigurationTransport::createConfigurationRequest()
{
if (!clientStatus_ || !hashContainer_) {
throw KaaException("Can not generate ConfigurationSyncRequest: configuration transport is not initialized");
}
std::shared_ptr<ConfigurationSyncRequest> request(new ConfigurationSyncRequest);
request->appStateSeqNumber = clientStatus_->getConfigurationSequenceNumber();
request->configurationHash.set_bytes(hashContainer_->getConfigurationHash());
request->resyncOnly.set_bool(true); // Only full resyncs are currently supported
return request;
}
void KaaChannelManager::onServerFailed(ITransportConnectionInfoPtr connectionInfo) {
if (isShutdown_) {
KAA_LOG_WARN("Can't update server. Channel manager is down");
return;
}
if (!connectionInfo) {
KAA_LOG_WARN("Failed to process server failure: bad input data")
throw KaaException("empty connection info pointer");
}
if (connectionInfo->isFailedState()) {
KAA_LOG_DEBUG("Connection already failed. Ignoring connection failover!");
return;
} else {
connectionInfo->setFailedState();
}
if (connectionInfo->getServerType() == ServerType::BOOTSTRAP) {
ITransportConnectionInfoPtr nextConnectionInfo = getNextBootstrapServer(connectionInfo->getTransportId(), false);
if (nextConnectionInfo) {
onTransportConnectionInfoUpdated(nextConnectionInfo);
} else {
FailoverStrategyDecision decision = failoverStrategy_->onFailover(Failover::BOOTSTRAP_SERVERS_NA);
switch (decision.getAction()) {
case FailoverStrategyAction::NOOP:
KAA_LOG_WARN("No operation is performed according to failover strategy decision.");
break;
case FailoverStrategyAction::RETRY:
{
std::size_t period = decision.getRetryPeriod();
KAA_LOG_WARN(boost::format("Attempt to reconnect to first bootstrap server will be made in %1% secs "
"according to failover strategy decision.") % period);
bsTransportId_ = connectionInfo->getTransportId();
retryTimer_.stop();
retryTimer_.start(period, [&]
{
onTransportConnectionInfoUpdated(getNextBootstrapServer(bsTransportId_, true));
});
break;
}
case FailoverStrategyAction::STOP_APP:
KAA_LOG_WARN("Stopping application according to failover strategy decision!");
exit(EXIT_FAILURE);
break;
default:
break;
}
}
} else {
bootstrapManager_.useNextOperationsServer(connectionInfo->getTransportId());
}
}
IPTransportInfo::IPTransportInfo(ITransportConnectionInfoPtr connectionInfo)
: GenericTransportInfo(connectionInfo->getServerType(), ProtocolMetaData())
{
if (!connectionInfo || connectionInfo->getConnectionInfo().empty()) {
KAA_LOG_ERROR("Failed to create IP transport data: bad input data");
throw KaaException("Bad connection data");
}
serverType_ = connectionInfo->getServerType();
connectionData_ = connectionInfo->getConnectionInfo();
accessPointId_ = connectionInfo->getAccessPointId();
protocolId_ = connectionInfo->getTransportId();
std::uint8_t *data = connectionData_.data();
std::int32_t publicKeyLength = boost::asio::detail::socket_ops::network_to_host_long(*((int32_t *)data));
data += sizeof(std::int32_t);
publicKey_ = PublicKey(data, publicKeyLength);
data += publicKeyLength;
std::int32_t hostLength = boost::asio::detail::socket_ops::network_to_host_long(*((int32_t *)data));
data += sizeof(std::int32_t);
host_.assign(data, data + hostLength);
data += hostLength;
port_ = boost::asio::detail::socket_ops::network_to_host_long(*((int32_t *)data));
std::ostringstream ss;
ss << "http://" << host_ << ":" << port_;
url_.assign(ss.str());
if ((3 * sizeof(std::int32_t) + publicKeyLength + hostLength) > connectionData_.size()) {
KAA_LOG_ERROR("Failed to create IP transport data: less size of input data than needed");
throw KaaException("Bad connection data");
}
KAA_LOG_TRACE(boost::format("Create IP transport data: host=%1%, port=%2%, publicKeyLength=%3%") % host_% port_ % publicKey_.size());
}
