server/host-connection.cpp

   1 /*
   2  *  Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Contact: Piotr Bartosiewicz <p.bartosiewi@partner.samsung.com>
   5  *
   6  *  Licensed under the Apache License, Version 2.0 (the "License");
   7  *  you may not use this file except in compliance with the License.
   8  *  You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License
  17  */
  18
  19 /**
  20  * @file
  21  * @author  Piotr Bartosiewicz (p.bartosiewi@partner.samsung.com)
  22  * @brief   Implementation of a class for communication with server
  23  */
  24
  25 #include "config.hpp"
  26
  27 #include "host-connection.hpp"
  28 #include "host-dbus-definitions.hpp"
  29 #include "exception.hpp"
  30 #include "api/dbus-method-result-builder.hpp"
  31 #include "api/messages.hpp"
  32
  33 #include "logger/logger.hpp"
  34 #include "config/manager.hpp"
  35
  36 namespace vasum {
  37
  38 namespace {
  39
  40 // Timeout in ms for waiting for dbus name.
  41 // Can happen if glib loop is busy or not present.
  42 // TODO: this should be in host's configuration file
  43 const unsigned int NAME_ACQUIRED_TIMEOUT = 5 * 1000;
  44
  45 } // namespace
  46
  47
  48 HostConnection::HostConnection()
  49     : mNameAcquired(false)
  50     , mNameLost(false)
  51 {
  52     LOGT("Connecting to host system DBUS");
  53     mDbusConnection = dbus::DbusConnection::createSystem();
  54
  55     LOGT("Setting DBUS name");
  56     mDbusConnection->setName(api::host::BUS_NAME,
  57                              std::bind(&HostConnection::onNameAcquired, this),
  58                              std::bind(&HostConnection::onNameLost, this));
  59
  60     if (!waitForName(NAME_ACQUIRED_TIMEOUT)) {
  61         LOGE("Could not acquire dbus name: " << api::host::BUS_NAME);
  62         throw HostConnectionException("Could not acquire dbus name: " + api::host::BUS_NAME);
  63     }
  64
  65     LOGT("Registering DBUS interface");
  66     using namespace std::placeholders;
  67     mDbusConnection->registerObject(api::host::OBJECT_PATH,
  68                                     api::host::DEFINITION,
  69                                     std::bind(&HostConnection::onMessageCall,
  70                                             this, _1, _2, _3, _4, _5));
  71
  72     LOGD("Connected");
  73 }
  74
  75 HostConnection::~HostConnection()
  76 {
  77 }
  78
  79 bool HostConnection::waitForName(const unsigned int timeoutMs)
  80 {
  81     std::unique_lock<std::mutex> lock(mNameMutex);
  82     mNameCondition.wait_for(lock,
  83                             std::chrono::milliseconds(timeoutMs),
  84     [this] {
  85         return mNameAcquired || mNameLost;
  86     });
  87
  88     return mNameAcquired;
  89 }
  90
  91 void HostConnection::onNameAcquired()
  92 {
  93     std::unique_lock<std::mutex> lock(mNameMutex);
  94     mNameAcquired = true;
  95     mNameCondition.notify_one();
  96 }
  97
  98 void HostConnection::onNameLost()
  99 {
 100     std::unique_lock<std::mutex> lock(mNameMutex);
 101     mNameLost = true;
 102     mNameCondition.notify_one();
 103
 104     if (mNameAcquired) {
 105         // TODO implement reconnecting
 106         LOGE("TODO Reconnect !!!");
 107     }
 108 }
 109
 110 void HostConnection::setProxyCallCallback(const ProxyCallCallback& callback)
 111 {
 112     mProxyCallCallback = callback;
 113 }
 114
 115 void HostConnection::setGetZoneDbusesCallback(const GetZoneDbusesCallback& callback)
 116 {
 117     mGetZoneDbusesCallback = callback;
 118 }
 119
 120 void HostConnection::setGetZoneIdsCallback(const GetZoneIdsCallback& callback)
 121 {
 122     mGetZoneIdsCallback = callback;
 123 }
 124
 125 void HostConnection::setGetActiveZoneIdCallback(const GetActiveZoneIdCallback& callback)
 126 {
 127     mGetActiveZoneIdCallback = callback;
 128 }
 129
 130 void HostConnection::setGetZoneInfoCallback(const GetZoneInfoCallback& callback)
 131 {
 132     mGetZoneInfoCallback = callback;
 133 }
 134
 135 void HostConnection::setSetNetdevAttrsCallback(const SetNetdevAttrsCallback& callback)
 136 {
 137     mSetNetdevAttrsCallback = callback;
 138 }
 139
 140 void HostConnection::setGetNetdevAttrsCallback(const GetNetdevAttrsCallback& callback)
 141 {
 142     mGetNetdevAttrsCallback = callback;
 143 }
 144
 145 void HostConnection::setGetNetdevListCallback(const GetNetdevListCallback& callback)
 146 {
 147     mGetNetdevListCallback = callback;
 148 }
 149
 150 void HostConnection::setCreateNetdevVethCallback(const CreateNetdevVethCallback& callback)
 151 {
 152     mCreateNetdevVethCallback = callback;
 153 }
 154
 155 void HostConnection::setCreateNetdevMacvlanCallback(const CreateNetdevMacvlanCallback& callback)
 156 {
 157     mCreateNetdevMacvlanCallback = callback;
 158 }
 159
 160 void HostConnection::setCreateNetdevPhysCallback(const CreateNetdevPhysCallback& callback)
 161 {
 162     mCreateNetdevPhysCallback = callback;
 163 }
 164
 165 void HostConnection::setDestroyNetdevCallback(const DestroyNetdevCallback& callback)
 166 {
 167     mDestroyNetdevCallback = callback;
 168 }
 169
 170 void HostConnection::setDeclareFileCallback(const DeclareFileCallback& callback)
 171 {
 172     mDeclareFileCallback = callback;
 173 }
 174
 175 void HostConnection::setDeclareMountCallback(const DeclareMountCallback& callback)
 176 {
 177     mDeclareMountCallback = callback;
 178 }
 179
 180 void HostConnection::setDeclareLinkCallback(const DeclareLinkCallback& callback)
 181 {
 182     mDeclareLinkCallback = callback;
 183 }
 184
 185 void HostConnection::setGetDeclarationsCallback(const GetDeclarationsCallback& callback)
 186 {
 187     mGetDeclarationsCallback = callback;
 188 }
 189
 190 void HostConnection::setRemoveDeclarationCallback(const RemoveDeclarationCallback& callback)
 191 {
 192     mRemoveDeclarationCallback =  callback;
 193 }
 194
 195 void HostConnection::setSetActiveZoneCallback(const SetActiveZoneCallback& callback)
 196 {
 197     mSetActiveZoneCallback = callback;
 198 }
 199
 200 void HostConnection::setCreateZoneCallback(const CreateZoneCallback& callback)
 201 {
 202     mCreateZoneCallback = callback;
 203 }
 204
 205 void HostConnection::setDestroyZoneCallback(const DestroyZoneCallback& callback)
 206 {
 207     mDestroyZoneCallback = callback;
 208 }
 209
 210 void HostConnection::setShutdownZoneCallback(const ShutdownZoneCallback& callback)
 211 {
 212     mShutdownZoneCallback = callback;
 213 }
 214
 215 void HostConnection::setStartZoneCallback(const StartZoneCallback& callback)
 216 {
 217     mStartZoneCallback = callback;
 218 }
 219
 220 void HostConnection::setLockZoneCallback(const LockZoneCallback& callback)
 221 {
 222     mLockZoneCallback = callback;
 223 }
 224
 225 void HostConnection::setUnlockZoneCallback(const UnlockZoneCallback& callback)
 226 {
 227     mUnlockZoneCallback = callback;
 228 }
 229
 230 void HostConnection::setGrantDeviceCallback(const GrantDeviceCallback& callback)
 231 {
 232     mGrantDeviceCallback = callback;
 233 }
 234
 235 void HostConnection::setRevokeDeviceCallback(const RevokeDeviceCallback& callback)
 236 {
 237     mRevokeDeviceCallback = callback;
 238 }
 239
 240
 241 void HostConnection::onMessageCall(const std::string& objectPath,
 242                                    const std::string& interface,
 243                                    const std::string& methodName,
 244                                    GVariant* parameters,
 245                                    dbus::MethodResultBuilder::Pointer result)
 246 {
 247     if (objectPath != api::host::OBJECT_PATH || interface != api::host::INTERFACE) {
 248         return;
 249     }
 250
 251     if (methodName == api::host::METHOD_SET_ACTIVE_ZONE) {
 252         api::ZoneId zoneId;
 253         config::loadFromGVariant(parameters, zoneId);
 254
 255         if (mSetActiveZoneCallback) {
 256             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
 257             mSetActiveZoneCallback(zoneId, rb);
 258         }
 259         return;
 260     }
 261
 262     if (methodName == api::host::METHOD_GET_ZONE_DBUSES) {
 263         if (mGetZoneDbusesCallback) {
 264             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Dbuses>>(result);
 265             mGetZoneDbusesCallback(rb);
 266         }
 267         return;
 268     }
 269
 270     if (methodName == api::METHOD_PROXY_CALL) {
 271         const gchar* target = NULL;
 272         const gchar* targetBusName = NULL;
 273         const gchar* targetObjectPath = NULL;
 274         const gchar* targetInterface = NULL;
 275         const gchar* targetMethod = NULL;
 276         GVariant* rawArgs = NULL;
 277         g_variant_get(parameters,
 278                       "(&s&s&s&s&sv)",
 279                       &target,
 280                       &targetBusName,
 281                       &targetObjectPath,
 282                       &targetInterface,
 283                       &targetMethod,
 284                       &rawArgs);
 285         dbus::GVariantPtr args(rawArgs, g_variant_unref);
 286
 287         if (mProxyCallCallback) {
 288             mProxyCallCallback(target,
 289                                targetBusName,
 290                                targetObjectPath,
 291                                targetInterface,
 292                                targetMethod,
 293                                args.get(),
 294                                result);
 295         }
 296         return;
 297     }
 298
 299     if (methodName == api::host::METHOD_GET_ZONE_ID_LIST) {
 300         if (mGetZoneIdsCallback) {
 301             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::ZoneIds>>(result);
 302             mGetZoneIdsCallback(rb);
 303         }
 304         return;
 305     }
 306
 307     if (methodName == api::host::METHOD_GET_ACTIVE_ZONE_ID) {
 308         if (mGetActiveZoneIdCallback) {
 309             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::ZoneId>>(result);
 310             mGetActiveZoneIdCallback(rb);
 311         }
 312         return;
 313     }
 314
 315     if (methodName == api::host::METHOD_GET_ZONE_INFO) {
 316         api::ZoneId zoneId;
 317         config::loadFromGVariant(parameters, zoneId);
 318
 319         if (mGetZoneInfoCallback) {
 320             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::ZoneInfoOut>>(result);
 321             mGetZoneInfoCallback(zoneId, rb);
 322         }
 323         return;
 324     }
 325
 326     if (methodName == api::host::METHOD_SET_NETDEV_ATTRS) {
 327         api::SetNetDevAttrsIn data;
 328         config::loadFromGVariant(parameters, data);
 329
 330         if (mSetNetdevAttrsCallback) {
 331             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
 332             mSetNetdevAttrsCallback(data, rb);
 333         }
 334         return;
 335     }
 336
 337     if (methodName == api::host::METHOD_GET_NETDEV_ATTRS) {
 338         api::GetNetDevAttrsIn data;
 339         config::loadFromGVariant(parameters, data);
 340
 341         if (mGetNetdevAttrsCallback) {
 342             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::GetNetDevAttrs>>(result);
 343             mGetNetdevAttrsCallback(data, rb);
 344         }
 345         return;
 346     }
 347
 348     if (methodName == api::host::METHOD_GET_NETDEV_LIST) {
 349         api::ZoneId data;
 350         config::loadFromGVariant(parameters, data);
 351
 352         if (mGetNetdevListCallback) {
 353             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::GetNetDevAttrs>>(result);
 354             mGetNetdevListCallback(data, rb);
 355         }
 356         return;
 357     }
 358
 359     if (methodName == api::host::METHOD_CREATE_NETDEV_VETH) {
 360         api::CreateNetDevVethIn data;
 361         config::loadFromGVariant(parameters, data);
 362
 363         if (mCreateNetdevVethCallback) {
 364             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
 365             mCreateNetdevVethCallback(data, rb);
 366         }
 367         return;
 368     }
 369
 370     if (methodName == api::host::METHOD_CREATE_NETDEV_MACVLAN) {
 371         api::CreateNetDevMacvlanIn data;
 372         config::loadFromGVariant(parameters, data);
 373
 374         if (mCreateNetdevMacvlanCallback) {
 375             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
 376             mCreateNetdevMacvlanCallback(data, rb);
 377         }
 378     }
 379
 380     if (methodName == api::host::METHOD_CREATE_NETDEV_PHYS) {
 381         api::CreateNetDevPhysIn data;
 382         config::loadFromGVariant(parameters, data);
 383
 384         if (mCreateNetdevPhysCallback) {
 385             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
 386             mCreateNetdevPhysCallback(data, rb);
 387         }
 388     }
 389
 390     if (methodName == api::host::METHOD_DESTROY_NETDEV) {
 391         api::DestroyNetDevIn data;
 392         config::loadFromGVariant(parameters, data);
 393
 394         if (mDestroyNetdevCallback) {
 395             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
 396             mDestroyNetdevCallback(data, rb);
 397         }
 398     }
 399
 400     if (methodName == api::host::METHOD_DECLARE_FILE) {
 401         api::DeclareFileIn data;
 402         config::loadFromGVariant(parameters, data);
 403
 404         if (mDeclareFileCallback) {
 405             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Declaration>>(result);
 406             mDeclareFileCallback(data, rb);
 407         }
 408         return;
 409     }
 410
 411     if (methodName == api::host::METHOD_DECLARE_MOUNT) {
 412         api::DeclareMountIn data;
 413         config::loadFromGVariant(parameters, data);
 414
 415         if (mDeclareMountCallback) {
 416             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Declaration>>(result);
 417             mDeclareMountCallback(data, rb);
 418         }
 419         return;
 420     }
 421
 422     if (methodName == api::host::METHOD_DECLARE_LINK) {
 423         api::DeclareLinkIn data;
 424         config::loadFromGVariant(parameters, data);
 425
 426         if (mDeclareLinkCallback) {
 427             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Declaration>>(result);
 428             mDeclareLinkCallback(data, rb);
 429         }
 430         return;
 431     }
 432
 433     if (methodName == api::host::METHOD_GET_DECLARATIONS) {
 434         api::ZoneId data;
 435         config::loadFromGVariant(parameters, data);
 436
 437         if (mGetDeclarationsCallback) {
 438             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Declarations>>(result);
 439             mGetDeclarationsCallback(data, rb);
 440         }
 441         return;
 442     }
 443
 444     if (methodName == api::host::METHOD_REMOVE_DECLARATION) {
 445         api::RemoveDeclarationIn data;
 446         config::loadFromGVariant(parameters, data);
 447
 448         if (mRemoveDeclarationCallback) {
 449             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
 450             mRemoveDeclarationCallback(data, rb);
 451         }
 452         return;
 453     }
 454
 455     if (methodName == api::host::METHOD_CREATE_ZONE) {
 456         api::CreateZoneIn data;
 457         config::loadFromGVariant(parameters, data);
 458
 459         if (mCreateZoneCallback) {
 460             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
 461             mCreateZoneCallback(data, rb);
 462         }
 463         return;
 464     }
 465
 466     if (methodName == api::host::METHOD_DESTROY_ZONE) {
 467         api::ZoneId data;
 468         config::loadFromGVariant(parameters, data);
 469
 470         if (mDestroyZoneCallback) {
 471             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
 472             mDestroyZoneCallback(data, rb);
 473         }
 474         return;
 475     }
 476
 477     if (methodName == api::host::METHOD_SHUTDOWN_ZONE) {
 478         api::ZoneId data;
 479         config::loadFromGVariant(parameters, data);
 480
 481         if (mShutdownZoneCallback) {
 482             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
 483             mShutdownZoneCallback(data, rb);
 484         }
 485     }
 486
 487     if (methodName == api::host::METHOD_START_ZONE) {
 488         api::ZoneId data;
 489         config::loadFromGVariant(parameters, data);
 490
 491         if (mStartZoneCallback) {
 492             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
 493             mStartZoneCallback(data, rb);
 494         }
 495     }
 496
 497     if (methodName == api::host::METHOD_LOCK_ZONE) {
 498         api::ZoneId data;
 499         config::loadFromGVariant(parameters, data);
 500
 501         if (mLockZoneCallback) {
 502             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
 503             mLockZoneCallback(data, rb);
 504         }
 505         return;
 506     }
 507
 508     if (methodName == api::host::METHOD_UNLOCK_ZONE) {
 509         api::ZoneId data;
 510         config::loadFromGVariant(parameters, data);
 511
 512         if (mUnlockZoneCallback) {
 513             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
 514             mUnlockZoneCallback(data, rb);
 515         }
 516         return;
 517     }
 518
 519     if (methodName == api::host::METHOD_GRANT_DEVICE) {
 520         api::GrantDeviceIn data;
 521         config::loadFromGVariant(parameters, data);
 522
 523         if (mGrantDeviceCallback) {
 524             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
 525             mGrantDeviceCallback(data, rb);
 526         }
 527         return;
 528     }
 529
 530     if (methodName == api::host::METHOD_REVOKE_DEVICE) {
 531         api::RevokeDeviceIn data;
 532         config::loadFromGVariant(parameters, data);
 533
 534         if (mRevokeDeviceCallback) {
 535             auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
 536             mRevokeDeviceCallback(data, rb);
 537         }
 538         return;
 539     }
 540 }
 541
 542 void HostConnection::proxyCallAsync(const std::string& busName,
 543                                     const std::string& objectPath,
 544                                     const std::string& interface,
 545                                     const std::string& method,
 546                                     GVariant* parameters,
 547                                     const dbus::DbusConnection::AsyncMethodCallCallback& callback)
 548 {
 549     mDbusConnection->callMethodAsync(busName,
 550                                      objectPath,
 551                                      interface,
 552                                      method,
 553                                      parameters,
 554                                      std::string(),
 555                                      callback);
 556 }
 557
 558 void HostConnection::signalZoneDbusState(const std::string& zoneId,
 559         const std::string& dbusAddress)
 560 {
 561     GVariant* parameters = g_variant_new("(ss)", zoneId.c_str(), dbusAddress.c_str());
 562     mDbusConnection->emitSignal(api::host::OBJECT_PATH,
 563                                 api::host::INTERFACE,
 564                                 api::host::SIGNAL_ZONE_DBUS_STATE,
 565                                 parameters);
 566 }
 567
 568
 569 } // namespace vasum