[Bug] Host*Connection classes had redundant callback layer.
[Cause] N/A
[Solution] Make Host*Connection objects aware of ZonesManager.
Remove unneeded callbacks.
[Verification] For both with and without Dbus:
* Build
* Run tests
* Make sure, that vasum-cli works
Change-Id: I8fd76d279731efdf201e797f2ef7600aed355aaa
#include "logger/logger.hpp"
#include "config/manager.hpp"
+#include "zones-manager.hpp"
namespace vasum {
// Can happen if glib loop is busy or not present.
// TODO: this should be in host's configuration file
const unsigned int NAME_ACQUIRED_TIMEOUT = 5 * 1000;
+const std::string EMPTY_CALLER = "";
} // namespace
-HostDbusConnection::HostDbusConnection()
+HostDbusConnection::HostDbusConnection(ZonesManager* zonesManagerPtr)
: mNameAcquired(false)
, mNameLost(false)
+ , mZonesManagerPtr(zonesManagerPtr)
{
LOGT("Connecting to host system DBUS");
mDbusConnection = dbus::DbusConnection::createSystem();
mProxyCallCallback = callback;
}
-void HostDbusConnection::setGetZoneConnectionsCallback(const GetZoneConnectionsCallback& callback)
-{
- mGetZoneConnectionsCallback = callback;
-}
-
-void HostDbusConnection::setGetZoneIdsCallback(const GetZoneIdsCallback& callback)
-{
- mGetZoneIdsCallback = callback;
-}
-
-void HostDbusConnection::setGetActiveZoneIdCallback(const GetActiveZoneIdCallback& callback)
-{
- mGetActiveZoneIdCallback = callback;
-}
-
-void HostDbusConnection::setGetZoneInfoCallback(const GetZoneInfoCallback& callback)
-{
- mGetZoneInfoCallback = callback;
-}
-
-void HostDbusConnection::setSetNetdevAttrsCallback(const SetNetdevAttrsCallback& callback)
-{
- mSetNetdevAttrsCallback = callback;
-}
-
-void HostDbusConnection::setGetNetdevAttrsCallback(const GetNetdevAttrsCallback& callback)
-{
- mGetNetdevAttrsCallback = callback;
-}
-
-void HostDbusConnection::setGetNetdevListCallback(const GetNetdevListCallback& callback)
-{
- mGetNetdevListCallback = callback;
-}
-
-void HostDbusConnection::setCreateNetdevVethCallback(const CreateNetdevVethCallback& callback)
-{
- mCreateNetdevVethCallback = callback;
-}
-
-void HostDbusConnection::setCreateNetdevMacvlanCallback(const CreateNetdevMacvlanCallback& callback)
-{
- mCreateNetdevMacvlanCallback = callback;
-}
-
-void HostDbusConnection::setCreateNetdevPhysCallback(const CreateNetdevPhysCallback& callback)
-{
- mCreateNetdevPhysCallback = callback;
-}
-
-void HostDbusConnection::setDestroyNetdevCallback(const DestroyNetdevCallback& callback)
-{
- mDestroyNetdevCallback = callback;
-}
-
-void HostDbusConnection::setDeleteNetdevIpAddressCallback(const DeleteNetdevIpAddressCallback& callback)
-{
- mDeleteNetdevIpAddressCallback = callback;
-}
-
-void HostDbusConnection::setDeclareFileCallback(const DeclareFileCallback& callback)
-{
- mDeclareFileCallback = callback;
-}
-
-void HostDbusConnection::setDeclareMountCallback(const DeclareMountCallback& callback)
-{
- mDeclareMountCallback = callback;
-}
-
-void HostDbusConnection::setDeclareLinkCallback(const DeclareLinkCallback& callback)
-{
- mDeclareLinkCallback = callback;
-}
-
-void HostDbusConnection::setGetDeclarationsCallback(const GetDeclarationsCallback& callback)
-{
- mGetDeclarationsCallback = callback;
-}
-
-void HostDbusConnection::setRemoveDeclarationCallback(const RemoveDeclarationCallback& callback)
-{
- mRemoveDeclarationCallback = callback;
-}
-
-void HostDbusConnection::setSetActiveZoneCallback(const SetActiveZoneCallback& callback)
-{
- mSetActiveZoneCallback = callback;
-}
-
-void HostDbusConnection::setCreateZoneCallback(const CreateZoneCallback& callback)
-{
- mCreateZoneCallback = callback;
-}
-
-void HostDbusConnection::setDestroyZoneCallback(const DestroyZoneCallback& callback)
-{
- mDestroyZoneCallback = callback;
-}
-
-void HostDbusConnection::setShutdownZoneCallback(const ShutdownZoneCallback& callback)
-{
- mShutdownZoneCallback = callback;
-}
-
-void HostDbusConnection::setStartZoneCallback(const StartZoneCallback& callback)
-{
- mStartZoneCallback = callback;
-}
-
-void HostDbusConnection::setLockZoneCallback(const LockZoneCallback& callback)
-{
- mLockZoneCallback = callback;
-}
-
-void HostDbusConnection::setUnlockZoneCallback(const UnlockZoneCallback& callback)
-{
- mUnlockZoneCallback = callback;
-}
-
-void HostDbusConnection::setGrantDeviceCallback(const GrantDeviceCallback& callback)
-{
- mGrantDeviceCallback = callback;
-}
-
-void HostDbusConnection::setRevokeDeviceCallback(const RevokeDeviceCallback& callback)
-{
- mRevokeDeviceCallback = callback;
-}
-
-void HostDbusConnection::setNotifyActiveZoneCallback(const NotifyActiveZoneCallback& callback)
-{
- mNotifyActiveZoneCallback = callback;
-}
-
-void HostDbusConnection::setSwitchToDefaultCallback(const SwitchToDefaultCallback& callback)
-{
- mSwitchToDefaultCallback = callback;
-}
-
-void HostDbusConnection::setFileMoveCallback(const FileMoveCallback& callback)
-{
- mFileMoveCallback = callback;
-}
-
void HostDbusConnection::onMessageCall(const std::string& objectPath,
const std::string& interface,
const std::string& methodName,
api::ZoneId zoneId;
config::loadFromGVariant(parameters, zoneId);
- if (mSetActiveZoneCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
- mSetActiveZoneCallback(zoneId, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
+ mZonesManagerPtr->handleSetActiveZoneCall(zoneId, rb);
return;
}
}
if (methodName == api::dbus::METHOD_GET_ZONE_ID_LIST) {
- if (mGetZoneIdsCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::ZoneIds>>(result);
- mGetZoneIdsCallback(rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::ZoneIds>>(result);
+ mZonesManagerPtr->handleGetZoneIdsCall(rb);
return;
}
if (methodName == api::dbus::METHOD_GET_ACTIVE_ZONE_ID) {
- if (mGetActiveZoneIdCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::ZoneId>>(result);
- mGetActiveZoneIdCallback(rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::ZoneId>>(result);
+ mZonesManagerPtr->handleGetActiveZoneIdCall(rb);
return;
}
api::ZoneId zoneId;
config::loadFromGVariant(parameters, zoneId);
- if (mGetZoneInfoCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::ZoneInfoOut>>(result);
- mGetZoneInfoCallback(zoneId, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::ZoneInfoOut>>(result);
+ mZonesManagerPtr->handleGetZoneInfoCall(zoneId, rb);
return;
}
api::SetNetDevAttrsIn data;
config::loadFromGVariant(parameters, data);
- if (mSetNetdevAttrsCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
- mSetNetdevAttrsCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
+ mZonesManagerPtr->handleSetNetdevAttrsCall(data, rb);
return;
}
api::GetNetDevAttrsIn data;
config::loadFromGVariant(parameters, data);
- if (mGetNetdevAttrsCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::GetNetDevAttrs>>(result);
- mGetNetdevAttrsCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::GetNetDevAttrs>>(result);
+ mZonesManagerPtr->handleGetNetdevAttrsCall(data, rb);
return;
}
api::ZoneId data;
config::loadFromGVariant(parameters, data);
- if (mGetNetdevListCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::NetDevList>>(result);
- mGetNetdevListCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::NetDevList>>(result);
+ mZonesManagerPtr->handleGetNetdevListCall(data, rb);
return;
}
api::CreateNetDevVethIn data;
config::loadFromGVariant(parameters, data);
- if (mCreateNetdevVethCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
- mCreateNetdevVethCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
+ mZonesManagerPtr->handleCreateNetdevVethCall(data, rb);
return;
}
api::CreateNetDevMacvlanIn data;
config::loadFromGVariant(parameters, data);
- if (mCreateNetdevMacvlanCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
- mCreateNetdevMacvlanCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
+ mZonesManagerPtr->handleCreateNetdevMacvlanCall(data, rb);
+ return;
}
if (methodName == api::dbus::METHOD_CREATE_NETDEV_PHYS) {
api::CreateNetDevPhysIn data;
config::loadFromGVariant(parameters, data);
- if (mCreateNetdevPhysCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
- mCreateNetdevPhysCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
+ mZonesManagerPtr->handleCreateNetdevPhysCall(data, rb);
+ return;
}
if (methodName == api::dbus::METHOD_DESTROY_NETDEV) {
api::DestroyNetDevIn data;
config::loadFromGVariant(parameters, data);
- if (mDestroyNetdevCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
- mDestroyNetdevCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
+ mZonesManagerPtr->handleDestroyNetdevCall(data, rb);
+ return;
}
if (methodName == api::dbus::METHOD_DELETE_NETDEV_IP_ADDRESS) {
api::DeleteNetdevIpAddressIn data;
config::loadFromGVariant(parameters, data);
- if (mDeleteNetdevIpAddressCallback) {
-
auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
- mDeleteNetdevIpAddressCallback(data, rb);
- }
+
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
+ mZonesManagerPtr->handleDeleteNetdevIpAddressCall(data, rb);
+ return;
}
if (methodName == api::dbus::METHOD_DECLARE_FILE) {
api::DeclareFileIn data;
config::loadFromGVariant(parameters, data);
- if (mDeclareFileCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Declaration>>(result);
- mDeclareFileCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Declaration>>(result);
+ mZonesManagerPtr->handleDeclareFileCall(data, rb);
return;
}
api::DeclareMountIn data;
config::loadFromGVariant(parameters, data);
- if (mDeclareMountCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Declaration>>(result);
- mDeclareMountCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Declaration>>(result);
+ mZonesManagerPtr->handleDeclareMountCall(data, rb);
return;
}
api::DeclareLinkIn data;
config::loadFromGVariant(parameters, data);
- if (mDeclareLinkCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Declaration>>(result);
- mDeclareLinkCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Declaration>>(result);
+ mZonesManagerPtr->handleDeclareLinkCall(data, rb);
return;
}
api::ZoneId data;
config::loadFromGVariant(parameters, data);
- if (mGetDeclarationsCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Declarations>>(result);
- mGetDeclarationsCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Declarations>>(result);
+ mZonesManagerPtr->handleGetDeclarationsCall(data, rb);
return;
}
api::RemoveDeclarationIn data;
config::loadFromGVariant(parameters, data);
- if (mRemoveDeclarationCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
- mRemoveDeclarationCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
+ mZonesManagerPtr->handleRemoveDeclarationCall(data, rb);
return;
}
api::CreateZoneIn data;
config::loadFromGVariant(parameters, data);
- if (mCreateZoneCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
- mCreateZoneCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
+ mZonesManagerPtr->handleCreateZoneCall(data, rb);
return;
}
api::ZoneId data;
config::loadFromGVariant(parameters, data);
- if (mDestroyZoneCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
- mDestroyZoneCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
+ mZonesManagerPtr->handleDestroyZoneCall(data, rb);
return;
}
api::ZoneId data;
config::loadFromGVariant(parameters, data);
- if (mShutdownZoneCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
- mShutdownZoneCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
+ mZonesManagerPtr->handleShutdownZoneCall(data, rb);
+ return;
}
if (methodName == api::dbus::METHOD_START_ZONE) {
api::ZoneId data;
config::loadFromGVariant(parameters, data);
- if (mStartZoneCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
- mStartZoneCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
+ mZonesManagerPtr->handleStartZoneCall(data, rb);
}
if (methodName == api::dbus::METHOD_LOCK_ZONE) {
api::ZoneId data;
config::loadFromGVariant(parameters, data);
- if (mLockZoneCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
- mLockZoneCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
+ mZonesManagerPtr->handleLockZoneCall(data, rb);
return;
}
api::ZoneId data;
config::loadFromGVariant(parameters, data);
- if (mUnlockZoneCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
- mUnlockZoneCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
+ mZonesManagerPtr->handleUnlockZoneCall(data, rb);
return;
}
api::GrantDeviceIn data;
config::loadFromGVariant(parameters, data);
- if (mGrantDeviceCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
- mGrantDeviceCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
+ mZonesManagerPtr->handleGrantDeviceCall(data, rb);
return;
}
api::RevokeDeviceIn data;
config::loadFromGVariant(parameters, data);
- if (mRevokeDeviceCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
- mRevokeDeviceCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
+ mZonesManagerPtr->handleRevokeDeviceCall(data, rb);
return;
}
api::NotifActiveZoneIn data;
config::loadFromGVariant(parameters, data);
- if (mNotifyActiveZoneCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
- mNotifyActiveZoneCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::Void>>(result);
+ mZonesManagerPtr->handleNotifyActiveZoneCall(EMPTY_CALLER, data, rb);
+ return;
}
if (methodName == api::dbus::METHOD_FILE_MOVE_REQUEST) {
api::FileMoveRequestIn data;
config::loadFromGVariant(parameters, data);
- if (mFileMoveCallback) {
- auto rb = std::make_shared<api::DbusMethodResultBuilder<api::FileMoveRequestStatus>>(result);
- mFileMoveCallback(data, rb);
- }
+ auto rb = std::make_shared<api::DbusMethodResultBuilder<api::FileMoveRequestStatus>>(result);
+ mZonesManagerPtr->handleFileMoveCall(EMPTY_CALLER, data, rb);
+ return;
}
}
}
if (signalName == api::dbus::SIGNAL_SWITCH_TO_DEFAULT) {
- if (mSwitchToDefaultCallback) {
- mSwitchToDefaultCallback();
- }
+ mZonesManagerPtr->handleSwitchToDefaultCall(EMPTY_CALLER);
}
}
namespace vasum {
+class ZonesManager;
class HostDbusConnection {
public:
- HostDbusConnection();
+ HostDbusConnection(ZonesManager* zm);
~HostDbusConnection();
// ------------- API --------------
GVariant* parameters,
dbus::MethodResultBuilder::Pointer result
)> ProxyCallCallback;
- typedef std::function<void(api::MethodResultBuilder::Pointer result
- )> GetZoneConnectionsCallback;
- typedef std::function<void(api::MethodResultBuilder::Pointer result
- )> GetZoneIdsCallback;
- typedef std::function<void(api::MethodResultBuilder::Pointer result
- )> GetActiveZoneIdCallback;
- typedef std::function<void(const api::ZoneId& dataIn,
- api::MethodResultBuilder::Pointer result
- )> GetZoneInfoCallback;
- typedef std::function<void(const api::SetNetDevAttrsIn& dataIn,
- api::MethodResultBuilder::Pointer result
- )> SetNetdevAttrsCallback;
- typedef std::function<void(const api::GetNetDevAttrsIn& dataIn,
- api::MethodResultBuilder::Pointer result
- )> GetNetdevAttrsCallback;
- typedef std::function<void(const api::ZoneId& dataIn,
- api::MethodResultBuilder::Pointer result
- )> GetNetdevListCallback;
- typedef std::function<void(const api::CreateNetDevVethIn& dataIn,
- api::MethodResultBuilder::Pointer result
- )> CreateNetdevVethCallback;
- typedef std::function<void(const api::CreateNetDevMacvlanIn& dataIn,
- api::MethodResultBuilder::Pointer result
- )> CreateNetdevMacvlanCallback;
- typedef std::function<void(const api::CreateNetDevPhysIn& dataIn,
- api::MethodResultBuilder::Pointer result
- )> CreateNetdevPhysCallback;
- typedef std::function<void(const api::DeleteNetdevIpAddressIn& dataIn,
- api::MethodResultBuilder::Pointer result
- )> DeleteNetdevIpAddressCallback;
- typedef std::function<void(const api::DestroyNetDevIn& dataIn,
- api::MethodResultBuilder::Pointer result
- )> DestroyNetdevCallback;
- typedef std::function<void(const api::DeclareFileIn& dataIn,
- api::MethodResultBuilder::Pointer result
- )> DeclareFileCallback;
- typedef std::function<void(const api::DeclareMountIn& dataIn,
- api::MethodResultBuilder::Pointer result
- )> DeclareMountCallback;
- typedef std::function<void(const api::DeclareLinkIn& dataIn,
- api::MethodResultBuilder::Pointer result
- )> DeclareLinkCallback;
- typedef std::function<void(const api::ZoneId& dataIn,
- api::MethodResultBuilder::Pointer result
- )> GetDeclarationsCallback;
- typedef std::function<void(const api::RemoveDeclarationIn& dataIn,
- api::MethodResultBuilder::Pointer result
- )> RemoveDeclarationCallback;
- typedef std::function<void(const api::ZoneId& dataIn,
- api::MethodResultBuilder::Pointer result
- )> SetActiveZoneCallback;
- typedef std::function<void(const api::CreateZoneIn& dataIn,
- api::MethodResultBuilder::Pointer result
- )> CreateZoneCallback;
- typedef std::function<void(const api::ZoneId& dataIn,
- api::MethodResultBuilder::Pointer result
- )> DestroyZoneCallback;
- typedef std::function<void(const api::ZoneId& dataIn,
- api::MethodResultBuilder::Pointer result
- )> ShutdownZoneCallback;
- typedef std::function<void(const api::ZoneId& dataIn,
- api::MethodResultBuilder::Pointer result
- )> StartZoneCallback;
- typedef std::function<void(const api::ZoneId& dataIn,
- api::MethodResultBuilder::Pointer result
- )> LockZoneCallback;
- typedef std::function<void(const api::ZoneId& dataIn,
- api::MethodResultBuilder::Pointer result
- )> UnlockZoneCallback;
- typedef std::function<void(const api::GrantDeviceIn& dataIn,
- api::MethodResultBuilder::Pointer result
- )> GrantDeviceCallback;
- typedef std::function<void(const api::RevokeDeviceIn& dataIn,
- api::MethodResultBuilder::Pointer result
- )> RevokeDeviceCallback;
- typedef std::function<void(const api::NotifActiveZoneIn& notify,
- api::MethodResultBuilder::Pointer result
- )> NotifyActiveZoneCallback;
- typedef std::function<void(const api::FileMoveRequestIn& request,
- api::MethodResultBuilder::Pointer result
- )> FileMoveCallback;
- typedef std::function<void()> SwitchToDefaultCallback;
-
/**
* Register proxy call callback
void setProxyCallCallback(const ProxyCallCallback& callback);
/**
- * Register get zone connections callback
- */
- void setGetZoneConnectionsCallback(const GetZoneConnectionsCallback& callback);
-
- /**
- * Send signal describing dbus address state change
- */
- void signalZoneConnectionState(const api::ConnectionState& state);
-
- /**
- * Register a callback called to get a list of zone ids
- */
- void setGetZoneIdsCallback(const GetZoneIdsCallback& callback);
-
- /**
- * Register a callback called to get the active zone id
- */
- void setGetActiveZoneIdCallback(const GetActiveZoneIdCallback& callback);
-
- /**
- * Register a callback called to get the zone informations
- */
- void setGetZoneInfoCallback(const GetZoneInfoCallback& callback);
-
- /**
- * Register a callback called to set network device attributes
- */
- void setSetNetdevAttrsCallback(const SetNetdevAttrsCallback& callback);
-
- /**
- * Register a callback called to get network device attributes
- */
- void setGetNetdevAttrsCallback(const GetNetdevAttrsCallback& callback);
-
- /**
- * Register a callback called to get network device list
- */
- void setGetNetdevListCallback(const GetNetdevListCallback& callback);
-
- /**
- * Register a callback called to create veth
- */
- void setCreateNetdevVethCallback(const CreateNetdevVethCallback& callback);
-
- /**
- * Register a callback called to create macvlan
- */
- void setCreateNetdevMacvlanCallback(const CreateNetdevMacvlanCallback& callback);
-
- /**
- * Register a callback called to create/move phys
- */
- void setCreateNetdevPhysCallback(const CreateNetdevPhysCallback& callback);
-
- /**
- * Register a callback called to destroy netdev
- */
- void setDestroyNetdevCallback(const DestroyNetdevCallback& callback);
-
- /**
- * Register a callback called to remove ip address from netdev
- */
- void setDeleteNetdevIpAddressCallback(const DeleteNetdevIpAddressCallback& callback);
-
- /**
- * Register a callback called to declare file
- */
- void setDeclareFileCallback(const DeclareFileCallback& callback);
-
- /**
- * Register a callback called to declare mount point
- */
- void setDeclareMountCallback(const DeclareMountCallback& callback);
-
- /**
- * Register a callback called to declare link
- */
- void setDeclareLinkCallback(const DeclareLinkCallback& callback);
-
- /**
- * Register a callback called to list declarations
- */
- void setGetDeclarationsCallback(const GetDeclarationsCallback& callback);
-
- /**
- * Register a callback called to remove declarartion
- */
- void setRemoveDeclarationCallback(const RemoveDeclarationCallback& callback);
-
- /**
- * Register a callback called to set the active zone
- */
- void setSetActiveZoneCallback(const SetActiveZoneCallback& callback);
-
- /**
- * Register a callback called to create new zone
- */
- void setCreateZoneCallback(const CreateZoneCallback& callback);
-
- /**
- * Register a callback called to destroy zone
- */
- void setDestroyZoneCallback(const DestroyZoneCallback& callback);
-
- /**
- * Register a callback called to shutdown zone
- */
- void setShutdownZoneCallback(const ShutdownZoneCallback& callback);
-
- /**
- * Register a callback called to start zone
- */
- void setStartZoneCallback(const StartZoneCallback& callback);
-
- /**
- * Register a callback called to lock zone
- */
- void setLockZoneCallback(const LockZoneCallback& callback);
-
- /**
- * Register a callback called to unlock zone
- */
- void setUnlockZoneCallback(const UnlockZoneCallback& callback);
-
- /**
- * Register a callback called to grant device
- */
- void setGrantDeviceCallback(const GrantDeviceCallback& callback);
-
- /**
- * Register a callback called to revoke device
- */
- void setRevokeDeviceCallback(const RevokeDeviceCallback& callback);
-
- /**
- * Register notification request callback
- */
- void setNotifyActiveZoneCallback(const NotifyActiveZoneCallback& callback);
-
- /**
- * Register switch to default request callback
- */
- void setSwitchToDefaultCallback(const SwitchToDefaultCallback& callback);
-
- /*
- * Register file move request callback
- */
- void setFileMoveCallback(const FileMoveCallback& callback);
-
- /**
* Send notification signal to this zone
*/
void sendNotification(const api::Notification& notify);
bool mNameLost;
dbus::DbusConnection::SubscriptionId mSubscriptionId;
ProxyCallCallback mProxyCallCallback;
- GetZoneConnectionsCallback mGetZoneConnectionsCallback;
- GetZoneIdsCallback mGetZoneIdsCallback;
- GetActiveZoneIdCallback mGetActiveZoneIdCallback;
- GetZoneInfoCallback mGetZoneInfoCallback;
- SetNetdevAttrsCallback mSetNetdevAttrsCallback;
- GetNetdevAttrsCallback mGetNetdevAttrsCallback;
- GetNetdevListCallback mGetNetdevListCallback;
- CreateNetdevVethCallback mCreateNetdevVethCallback;
- CreateNetdevMacvlanCallback mCreateNetdevMacvlanCallback;
- CreateNetdevPhysCallback mCreateNetdevPhysCallback;
- DestroyNetdevCallback mDestroyNetdevCallback;
- DeleteNetdevIpAddressCallback mDeleteNetdevIpAddressCallback;
- DeclareFileCallback mDeclareFileCallback;
- DeclareMountCallback mDeclareMountCallback;
- DeclareLinkCallback mDeclareLinkCallback;
- GetDeclarationsCallback mGetDeclarationsCallback;
- RemoveDeclarationCallback mRemoveDeclarationCallback;
- SetActiveZoneCallback mSetActiveZoneCallback;
- CreateZoneCallback mCreateZoneCallback;
- DestroyZoneCallback mDestroyZoneCallback;
- ShutdownZoneCallback mShutdownZoneCallback;
- StartZoneCallback mStartZoneCallback;
- LockZoneCallback mLockZoneCallback;
- UnlockZoneCallback mUnlockZoneCallback;
- GrantDeviceCallback mGrantDeviceCallback;
- RevokeDeviceCallback mRevokeDeviceCallback;
- NotifyActiveZoneCallback mNotifyActiveZoneCallback;
- SwitchToDefaultCallback mSwitchToDefaultCallback;
- FileMoveCallback mFileMoveCallback;
+ ZonesManager* mZonesManagerPtr;
void onNameAcquired();
void onNameLost();
#include "config.hpp"
+#include <functional>
+
#include "host-ipc-connection.hpp"
#include "host-ipc-definitions.hpp"
#include "exception.hpp"
#include "logger/logger.hpp"
+#include "zones-manager.hpp"
+
namespace vasum {
-HostIPCConnection::HostIPCConnection()
+HostIPCConnection::HostIPCConnection(ZonesManager* zonesManagerPtr)
+ : mZonesManagerPtr(zonesManagerPtr)
{
LOGT("Connecting to host IPC socket");
mService.reset(new ipc::Service(mDispatcher.getPoll(), HOST_IPC_SOCKET));
LOGT("Starting IPC");
mService->start();
LOGD("Connected");
+
+ using namespace std::placeholders;
+ setGetZoneIdsCallback(std::bind(&ZonesManager::handleGetZoneIdsCall,
+ mZonesManagerPtr, _1));
+
+ setGetActiveZoneIdCallback(std::bind(&ZonesManager::handleGetActiveZoneIdCall,
+ mZonesManagerPtr, _1));
+
+ setGetZoneInfoCallback(std::bind(&ZonesManager::handleGetZoneInfoCall,
+ mZonesManagerPtr, _1, _2));
+
+ setSetNetdevAttrsCallback(std::bind(&ZonesManager::handleSetNetdevAttrsCall,
+ mZonesManagerPtr, _1, _2));
+
+ setGetNetdevAttrsCallback(std::bind(&ZonesManager::handleGetNetdevAttrsCall,
+ mZonesManagerPtr, _1, _2));
+
+ setGetNetdevListCallback(std::bind(&ZonesManager::handleGetNetdevListCall,
+ mZonesManagerPtr, _1, _2));
+
+ setCreateNetdevVethCallback(std::bind(&ZonesManager::handleCreateNetdevVethCall,
+ mZonesManagerPtr, _1, _2));
+
+ setCreateNetdevMacvlanCallback(std::bind(&ZonesManager::handleCreateNetdevMacvlanCall,
+ mZonesManagerPtr, _1, _2));
+
+ setCreateNetdevPhysCallback(std::bind(&ZonesManager::handleCreateNetdevPhysCall,
+ mZonesManagerPtr, _1, _2));
+
+ setDestroyNetdevCallback(std::bind(&ZonesManager::handleDestroyNetdevCall,
+ mZonesManagerPtr, _1, _2));
+
+ setDeleteNetdevIpAddressCallback(std::bind(&ZonesManager::handleDeleteNetdevIpAddressCall,
+ mZonesManagerPtr, _1, _2));
+
+ setDeclareFileCallback(std::bind(&ZonesManager::handleDeclareFileCall,
+ mZonesManagerPtr, _1, _2));
+
+ setDeclareMountCallback(std::bind(&ZonesManager::handleDeclareMountCall,
+ mZonesManagerPtr, _1, _2));
+
+ setDeclareLinkCallback(std::bind(&ZonesManager::handleDeclareLinkCall,
+ mZonesManagerPtr, _1, _2));
+
+ setGetDeclarationsCallback(std::bind(&ZonesManager::handleGetDeclarationsCall,
+ mZonesManagerPtr, _1, _2));
+
+ setRemoveDeclarationCallback(std::bind(&ZonesManager::handleRemoveDeclarationCall,
+ mZonesManagerPtr, _1, _2));
+
+ setSetActiveZoneCallback(std::bind(&ZonesManager::handleSetActiveZoneCall,
+ mZonesManagerPtr, _1, _2));
+
+ setCreateZoneCallback(std::bind(&ZonesManager::handleCreateZoneCall,
+ mZonesManagerPtr, _1, _2));
+
+ setDestroyZoneCallback(std::bind(&ZonesManager::handleDestroyZoneCall,
+ mZonesManagerPtr, _1, _2));
+
+ setShutdownZoneCallback(std::bind(&ZonesManager::handleShutdownZoneCall,
+ mZonesManagerPtr, _1, _2));
+
+ setStartZoneCallback(std::bind(&ZonesManager::handleStartZoneCall,
+ mZonesManagerPtr, _1, _2));
+
+ setLockZoneCallback(std::bind(&ZonesManager::handleLockZoneCall,
+ mZonesManagerPtr, _1, _2));
+
+ setUnlockZoneCallback(std::bind(&ZonesManager::handleUnlockZoneCall,
+ mZonesManagerPtr, _1, _2));
+
+ setGrantDeviceCallback(std::bind(&ZonesManager::handleGrantDeviceCall,
+ mZonesManagerPtr, _1, _2));
+
+ setRevokeDeviceCallback(std::bind(&ZonesManager::handleRevokeDeviceCall,
+ mZonesManagerPtr, _1, _2));
+
+ setNotifyActiveZoneCallback(std::bind(&ZonesManager::handleNotifyActiveZoneCall,
+ mZonesManagerPtr, "", _1, _2));
+
+ setSwitchToDefaultCallback(std::bind(&ZonesManager::handleSwitchToDefaultCall,
+ mZonesManagerPtr, ""));
+
+ setFileMoveCallback(std::bind(&ZonesManager::handleFileMoveCall,
+ mZonesManagerPtr, "", _1, _2));
}
HostIPCConnection::~HostIPCConnection()
namespace vasum {
+class ZonesManager;
class HostIPCConnection {
public:
typedef typename IPCSignalWrapper<ArgIn>::type type;
};
- HostIPCConnection();
+ HostIPCConnection(ZonesManager* zm);
~HostIPCConnection();
- void setGetZoneConnectionsCallback(const Method<api::Connections>::type& callback);
+ void signalZoneConnectionState(const api::ConnectionState& connectionState);
+ void sendNotification(const api::Notification& notification);
+
+private:
void setGetZoneIdsCallback(const Method<api::ZoneIds>::type& callback);
+ void setGetZoneConnectionsCallback(const Method<api::Connections>::type& callback);
void setGetActiveZoneIdCallback(const Method<api::ZoneId>::type& callback);
void setGetZoneInfoCallback(const Method<const api::ZoneId, api::ZoneInfoOut>::type& callback);
void setSetNetdevAttrsCallback(const Method<const api::SetNetDevAttrsIn>::type& callback);
void setSwitchToDefaultCallback(const Signal<const api::Void>::type& callback);
void setFileMoveCallback(const Method<const api::FileMoveRequestIn,
api::FileMoveRequestStatus>::type& callback);
- void signalZoneConnectionState(const api::ConnectionState& connectionState);
- void sendNotification(const api::Notification& notification);
-private:
ipc::epoll::ThreadDispatcher mDispatcher;
std::unique_ptr<ipc::Service> mService;
+ ZonesManager* mZonesManagerPtr;
};
} // namespace vasum
} // namespace
-template<typename Connection>
-void ZonesManager::setHandlers(Connection& connection)
-{
- using namespace std::placeholders;
- connection.setGetZoneIdsCallback(bind(&ZonesManager::handleGetZoneIdsCall,
- this, _1));
-
- connection.setGetActiveZoneIdCallback(bind(&ZonesManager::handleGetActiveZoneIdCall,
- this, _1));
-
- connection.setGetZoneInfoCallback(bind(&ZonesManager::handleGetZoneInfoCall,
- this, _1, _2));
-
- connection.setSetNetdevAttrsCallback(bind(&ZonesManager::handleSetNetdevAttrsCall,
- this, _1, _2));
-
- connection.setGetNetdevAttrsCallback(bind(&ZonesManager::handleGetNetdevAttrsCall,
- this, _1, _2));
-
- connection.setGetNetdevListCallback(bind(&ZonesManager::handleGetNetdevListCall,
- this, _1, _2));
-
- connection.setCreateNetdevVethCallback(bind(&ZonesManager::handleCreateNetdevVethCall,
- this, _1, _2));
-
- connection.setCreateNetdevMacvlanCallback(bind(&ZonesManager::handleCreateNetdevMacvlanCall,
- this, _1, _2));
-
- connection.setCreateNetdevPhysCallback(bind(&ZonesManager::handleCreateNetdevPhysCall,
- this, _1, _2));
-
- connection.setDestroyNetdevCallback(bind(&ZonesManager::handleDestroyNetdevCall,
- this, _1, _2));
-
- connection.setDeleteNetdevIpAddressCallback(bind(&ZonesManager::handleDeleteNetdevIpAddressCall,
- this, _1, _2));
-
- connection.setDeclareFileCallback(bind(&ZonesManager::handleDeclareFileCall,
- this, _1, _2));
-
- connection.setDeclareMountCallback(bind(&ZonesManager::handleDeclareMountCall,
- this, _1, _2));
-
- connection.setDeclareLinkCallback(bind(&ZonesManager::handleDeclareLinkCall,
- this, _1, _2));
-
- connection.setGetDeclarationsCallback(bind(&ZonesManager::handleGetDeclarationsCall,
- this, _1, _2));
-
- connection.setRemoveDeclarationCallback(bind(&ZonesManager::handleRemoveDeclarationCall,
- this, _1, _2));
-
- connection.setSetActiveZoneCallback(bind(&ZonesManager::handleSetActiveZoneCall,
- this, _1, _2));
-
- connection.setCreateZoneCallback(bind(&ZonesManager::handleCreateZoneCall,
- this, _1, _2));
-
- connection.setDestroyZoneCallback(bind(&ZonesManager::handleDestroyZoneCall,
- this, _1, _2));
-
- connection.setShutdownZoneCallback(bind(&ZonesManager::handleShutdownZoneCall,
- this, _1, _2));
-
- connection.setStartZoneCallback(bind(&ZonesManager::handleStartZoneCall,
- this, _1, _2));
-
- connection.setLockZoneCallback(bind(&ZonesManager::handleLockZoneCall,
- this, _1, _2));
-
- connection.setUnlockZoneCallback(bind(&ZonesManager::handleUnlockZoneCall,
- this, _1, _2));
-
- connection.setGrantDeviceCallback(bind(&ZonesManager::handleGrantDeviceCall,
- this, _1, _2));
-
- connection.setRevokeDeviceCallback(bind(&ZonesManager::handleRevokeDeviceCall,
- this, _1, _2));
-
- connection.setNotifyActiveZoneCallback(bind(&ZonesManager::handleNotifyActiveZoneCall,
- this, "", _1, _2));
-
- connection.setSwitchToDefaultCallback(bind(&ZonesManager::handleSwitchToDefaultCall,
- this, ""));
-
- connection.setFileMoveCallback(bind(&ZonesManager::handleFileMoveCall,
- this, "", _1, _2));
-}
ZonesManager::ZonesManager(const std::string& configPath)
: mWorker(utils::Worker::create())
+ , mHostIPCConnection(this)
, mDetachOnExit(false)
+#ifdef DBUS_CONNECTION
+ , mHostDbusConnection(this)
+#endif
{
LOGD("Instantiating ZonesManager object...");
mDynamicConfig,
getVasumDbPrefix());
- setHandlers(mHostIPCConnection);
#ifdef DBUS_CONNECTION
using namespace std::placeholders;
mProxyCallPolicy.reset(new ProxyCallPolicy(mConfig.proxyCallRules));
mHostDbusConnection.setProxyCallCallback(bind(&ZonesManager::handleProxyCall,
this, HOST_ID, _1, _2, _3, _4, _5, _6, _7));
- setHandlers(mHostDbusConnection);
#endif //DBUS_CONNECTION
for (const auto& zoneId : mDynamicConfig.zoneIds) {
std::bind(&ZonesManager::switchingSequenceMonitorNotify,
this)));
}
-
-
}
ZonesManager::~ZonesManager()
#include "zone.hpp"
#include "zones-manager-config.hpp"
-#include "host-ipc-connection.hpp"
+#include "api/messages.hpp"
#include "input-monitor.hpp"
#include "utils/worker.hpp"
#include "api/method-result-builder.hpp"
+#include "host-ipc-connection.hpp"
#ifdef DBUS_CONNECTION
#include "host-dbus-connection.hpp"
#include "proxy-call-policy.hpp"
namespace vasum {
-
class ZonesManager final {
public:
*/
void setZonesDetachOnExit();
-private:
- typedef std::recursive_mutex Mutex;
- typedef std::unique_lock<Mutex> Lock;
-
- utils::Worker::Pointer mWorker;
- Mutex mMutex; // used to protect mZones
- ZonesManagerConfig mConfig; //TODO make it const
- ZonesManagerDynamicConfig mDynamicConfig;
-#ifdef DBUS_CONNECTION
- HostDbusConnection mHostDbusConnection;
-#endif //DBUS_CONNECTION
- HostIPCConnection mHostIPCConnection;
- // to hold InputMonitor pointer to monitor if zone switching sequence is recognized
- std::unique_ptr<InputMonitor> mSwitchingSequenceMonitor;
- // like set but keep insertion order
- // smart pointer is needed because Zone is not moveable (because of mutex)
- typedef std::vector<std::unique_ptr<Zone>> Zones;
- Zones mZones;
- std::string mActiveZoneId;
- bool mDetachOnExit;
-
- Zones::iterator findZone(const std::string& id);
- Zone& getZone(const std::string& id);
- Zones::iterator getRunningForegroundZoneIterator();
- Zones::iterator getNextToForegroundZoneIterator();
- void focusInternal(Zones::iterator iter);
-
- void saveDynamicConfig();
- void updateDefaultId();
- void refocus();
- void switchingSequenceMonitorNotify();
- void generateNewConfig(const std::string& id,
- const std::string& templatePath);
- std::string getTemplatePathForExistingZone(const std::string& id);
- int getVTForNewZone();
- void insertZone(const std::string& zoneId, const std::string& templatePath);
-
- // Zone's handlers---------------------------------------------------------
- void handleNotifyActiveZoneCall(const std::string& caller,
- const api::NotifActiveZoneIn& notif,
- api::MethodResultBuilder::Pointer result);
- void handleSwitchToDefaultCall(const std::string& caller);
- void handleFileMoveCall(const std::string& srcZoneId,
- const api::FileMoveRequestIn& request,
- api::MethodResultBuilder::Pointer result);
-#ifdef DBUS_CONNECTION
- std::unique_ptr<ProxyCallPolicy> mProxyCallPolicy;
- void handleProxyCall(const std::string& caller,
- const std::string& target,
- const std::string& targetBusName,
- const std::string& targetObjectPath,
- const std::string& targetInterface,
- const std::string& targetMethod,
- GVariant* parameters,
- dbus::MethodResultBuilder::Pointer result);
-#endif //DBUS_CONNECTION
// Handlers --------------------------------------------------------
void handleGetZoneIdsCall(api::MethodResultBuilder::Pointer result);
void handleGetActiveZoneIdCall(api::MethodResultBuilder::Pointer result);
void handleRevokeDeviceCall(const api::RevokeDeviceIn& data,
api::MethodResultBuilder::Pointer result);
- template<typename Connection>
- void setHandlers(Connection& connnection);
+ // Zone's handlers---------------------------------------------------------
+ void handleNotifyActiveZoneCall(const std::string& caller,
+ const api::NotifActiveZoneIn& notif,
+ api::MethodResultBuilder::Pointer result);
+ void handleSwitchToDefaultCall(const std::string& caller);
+ void handleFileMoveCall(const std::string& srcZoneId,
+ const api::FileMoveRequestIn& request,
+ api::MethodResultBuilder::Pointer result);
+
+private:
+ typedef std::recursive_mutex Mutex;
+ typedef std::unique_lock<Mutex> Lock;
+
+ utils::Worker::Pointer mWorker;
+ Mutex mMutex; // used to protect mZones
+ ZonesManagerConfig mConfig; //TODO make it const
+ ZonesManagerDynamicConfig mDynamicConfig;
+ HostIPCConnection mHostIPCConnection;
+ // to hold InputMonitor pointer to monitor if zone switching sequence is recognized
+ std::unique_ptr<InputMonitor> mSwitchingSequenceMonitor;
+ // like set but keep insertion order
+ // smart pointer is needed because Zone is not moveable (because of mutex)
+ typedef std::vector<std::unique_ptr<Zone>> Zones;
+ Zones mZones;
+ std::string mActiveZoneId;
+ bool mDetachOnExit;
+
+ Zones::iterator findZone(const std::string& id);
+ Zone& getZone(const std::string& id);
+ Zones::iterator getRunningForegroundZoneIterator();
+ Zones::iterator getNextToForegroundZoneIterator();
+ void focusInternal(Zones::iterator iter);
+
+ void saveDynamicConfig();
+ void updateDefaultId();
+ void refocus();
+ void switchingSequenceMonitorNotify();
+ void generateNewConfig(const std::string& id,
+ const std::string& templatePath);
+ std::string getTemplatePathForExistingZone(const std::string& id);
+ int getVTForNewZone();
+ void insertZone(const std::string& zoneId, const std::string& templatePath);
+
+#ifdef DBUS_CONNECTION
+ HostDbusConnection mHostDbusConnection;
+ std::unique_ptr<ProxyCallPolicy> mProxyCallPolicy;
+ void handleProxyCall(const std::string& caller,
+ const std::string& target,
+ const std::string& targetBusName,
+ const std::string& targetObjectPath,
+ const std::string& targetInterface,
+ const std::string& targetMethod,
+ GVariant* parameters,
+ dbus::MethodResultBuilder::Pointer result);
+#endif //DBUS_CONNECTION
};
#include "utils/latch.hpp"
#include "utils/scoped-dir.hpp"
#include "zones-manager.hpp"
+#include "host-ipc-connection.hpp"
#include "host-ipc-definitions.hpp"
#include "logger/logger.hpp"
projects / platform / core / security / vasum.git / commitdiff