#include <host-dbus-definitions.hpp>
#include <container-dbus-definitions.hpp>
-#include <memory>
#include <cstring>
#include <cassert>
namespace {
-const string SCCLIENT_SUCCESS_MSG;
-const string SCCLIENT_EXCEPTION_MSG = "unspecified exception";
+const DbusInterfaceInfo HOST_INTERFACE(api::host::BUS_NAME,
+ api::host::OBJECT_PATH,
+ api::host::INTERFACE);
+const DbusInterfaceInfo CONTAINER_INTERFACE(api::container::BUS_NAME,
+ api::container::OBJECT_PATH,
+ api::container::INTERFACE);
-const DbusInterfaceInfo hostDbusInterfaceInfo(api::host::BUS_NAME,
- api::host::OBJECT_PATH,
- api::host::INTERFACE);
-const DbusInterfaceInfo domainDbusInterfaceInfo(api::container::BUS_NAME,
- api::container::OBJECT_PATH,
- api::container::INTERFACE);
-
-template<typename T> struct fake_dependency: public std::false_type {};
-
-unique_ptr<ScopedGlibLoop> loop;
+unique_ptr<ScopedGlibLoop> gGlibLoop;
void toDict(GVariant* in, ScArrayString* keys, ScArrayString* values)
{
*values = outv;
}
-template<typename T>
-void toBasic(GVariant* in, T str)
-{
- static_assert(fake_dependency<T>::value, "Must use specialization");
- assert(!"Must use specialization");
-}
-
-template<>
void toBasic(GVariant* in, char** str)
{
assert(in);
ScStatus toStatus(const std::exception& ex)
{
if (typeid(DbusCustomException) == typeid(ex)) {
- return SCCLIENT_DBUS_CUSTOM_EXCEPTION;
+ return SCCLIENT_CUSTOM_ERROR;
} else if (typeid(DbusIOException) == typeid(ex)) {
- return SCCLIENT_DBUS_IO_EXCEPTION;
+ return SCCLIENT_IO_ERROR;
} else if (typeid(DbusOperationException) == typeid(ex)) {
- return SCCLIENT_DBUS_OPERATION_EXCEPTION;
+ return SCCLIENT_OPERATION_FAILED;
} else if (typeid(DbusInvalidArgumentException) == typeid(ex)) {
- return SCCLIENT_DBUS_INVALID_ARGUMENT_EXCEPTION;
+ return SCCLIENT_INVALID_ARGUMENT;
} else if (typeid(DbusException) == typeid(ex)) {
- return SCCLIENT_DBUS_EXCEPTION;
+ return SCCLIENT_OTHER_ERROR;
}
- return SCCLIENT_RUNTIME_EXCEPTION;
+ return SCCLIENT_OTHER_ERROR;
}
} //namespace
-ScStatus Client::sc_start() noexcept
+ScStatus Client::sc_start_glib_loop() noexcept
{
try {
- if (!loop) {
- loop.reset(new ScopedGlibLoop());
+ if (!gGlibLoop) {
+ gGlibLoop.reset(new ScopedGlibLoop());
}
- } catch (const exception& ex) {
- return toStatus(ex);
- } catch (...) {
- return SCCLIENT_EXCEPTION;
+ } catch (const exception&) {
+ return SCCLIENT_OTHER_ERROR;
}
return SCCLIENT_SUCCESS;
}
-ScStatus Client::sc_stop() noexcept
+ScStatus Client::sc_stop_glib_loop() noexcept
{
try {
- if (loop) {
- loop.reset();
- }
- } catch (const exception& ex) {
- return toStatus(ex);
- } catch (...) {
- return SCCLIENT_EXCEPTION;
+ gGlibLoop.reset();
+ } catch (const exception&) {
+ return SCCLIENT_OTHER_ERROR;
}
return SCCLIENT_SUCCESS;
}
-Client::Status::Status(ScStatus status)
- : mScStatus(status)
+Client::Status::Status()
+ : mScStatus(SCCLIENT_SUCCESS), mMsg()
{
- switch (status) {
- case SCCLIENT_EXCEPTION:
- mMsg = SCCLIENT_EXCEPTION_MSG;
- break;
- case SCCLIENT_SUCCESS:
- mMsg = SCCLIENT_SUCCESS_MSG;
- break;
- default:
- assert(!"Logic error. You must specify a message.");
- mMsg = std::string();
- }
}
Client::Status::Status(ScStatus status, const std::string& msg)
}
Client::Client() noexcept
- : mStatus(SCCLIENT_SUCCESS)
{
}
{
try {
mConnection = DbusConnection::createSystem();
- mStatus = Status(SCCLIENT_SUCCESS);
+ mStatus = Status();
} catch (const exception& ex) {
mStatus = Status(toStatus(ex), ex.what());
- } catch (...) {
- mStatus = Status(SCCLIENT_EXCEPTION);
}
return sc_get_status();
}
{
try {
mConnection = DbusConnection::create(address);
- mStatus = Status(SCCLIENT_SUCCESS);
+ mStatus = Status();
} catch (const exception& ex) {
mStatus = Status(toStatus(ex), ex.what());
- } catch (...) {
- mStatus = Status(SCCLIENT_EXCEPTION);
}
return sc_get_status();
}
if (args_out != NULL) {
*args_out = ret.release();
}
- mStatus = Status(SCCLIENT_SUCCESS);
+ mStatus = Status();
} catch (const exception& ex) {
mStatus = Status(toStatus(ex), ex.what());
- } catch (...) {
- mStatus = Status(SCCLIENT_EXCEPTION);
}
return sc_get_status();
}
};
try {
mConnection->signalSubscribe(onSignal, info.busName);
- mStatus = Status(SCCLIENT_SUCCESS);
+ mStatus = Status();
} catch (const std::exception& ex) {
mStatus = Status(toStatus(ex), ex.what());
- } catch (...) {
- mStatus = Status(SCCLIENT_EXCEPTION);
}
return sc_get_status();
}
assert(values);
GVariant* out;
- ScStatus ret = callMethod(hostDbusInterfaceInfo,
+ ScStatus ret = callMethod(HOST_INTERFACE,
api::host::METHOD_GET_CONTAINER_DBUSES,
NULL,
"(a{ss})",
assert(array);
GVariant* out;
- ScStatus ret = callMethod(hostDbusInterfaceInfo,
+ ScStatus ret = callMethod(HOST_INTERFACE,
api::host::METHOD_GET_CONTAINER_ID_LIST,
NULL,
"(as)",
assert(id);
GVariant* out;
- ScStatus ret = callMethod(hostDbusInterfaceInfo,
+ ScStatus ret = callMethod(HOST_INTERFACE,
api::host::METHOD_GET_ACTIVE_CONTAINER_ID,
NULL,
"(s)",
assert(id);
GVariant* args_in = g_variant_new("(s)", id);
- return callMethod(hostDbusInterfaceInfo, api::host::METHOD_SET_ACTIVE_CONTAINER, args_in);
+ return callMethod(HOST_INTERFACE, api::host::METHOD_SET_ACTIVE_CONTAINER, args_in);
}
ScStatus Client::sc_container_dbus_state(ScContainerDbusStateCallback containerDbusStateCallback)
containerDbusStateCallback(container, dbusAddress);
};
- return signalSubscribe(hostDbusInterfaceInfo,
+ return signalSubscribe(HOST_INTERFACE,
api::host::SIGNAL_CONTAINER_DBUS_STATE,
onSigal);
}
assert(message);
GVariant* args_in = g_variant_new("(ss)", application, message);
- return callMethod(domainDbusInterfaceInfo,
+ return callMethod(CONTAINER_INTERFACE,
api::container::METHOD_NOTIFY_ACTIVE_CONTAINER,
args_in);
}
notificationCallback(container, application, message);
};
- return signalSubscribe(domainDbusInterfaceInfo, api::container::SIGNAL_NOTIFICATION, onSigal);
+ return signalSubscribe(CONTAINER_INTERFACE, api::container::SIGNAL_NOTIFICATION, onSigal);
}
private:
typedef std::function<void(GVariant* parameters)> SignalCallback;
struct Status {
- Status(ScStatus status);
+ Status();
Status(ScStatus status, const std::string& msg);
ScStatus mScStatus;
std::string mMsg;
/**
* Create client with system dbus address.
*
- * @return Status of this function call.
+ * @return status of this function call
*/
ScStatus createSystem() noexcept;
/**
* Create client.
*
- * @param address Dbus socket address.
- * @return Status of this function call.
+ * @param address Dbus socket address
+ * @return status of this function call
*/
ScStatus create(const std::string& address) noexcept;
*/
ScStatus sc_notification(ScNotificationCallback notificationCallback) noexcept;
/**
- * @see ::sc_start
+ * @see ::sc_start_glib_loop
*/
- static ScStatus sc_start() noexcept;
+ static ScStatus sc_start_glib_loop() noexcept;
/**
- * @see ::sc_stop
+ * @see ::sc_stop_glib_loop
*/
- static ScStatus sc_stop() noexcept;
+ static ScStatus sc_stop_glib_loop() noexcept;
};
#endif /* SECURITY_CONTAINERS_CLIENT_IMPL_HPP */
#include "security-containers-client.h"
#include "security-containers-client-impl.hpp"
-#include <cstdarg>
#include <cassert>
#ifndef API
namespace {
-typedef Client* ClientPtr;
-
-ClientPtr getClient(ScClient client)
+Client& getClient(ScClient client)
{
assert(client);
- return reinterpret_cast<ClientPtr>(client);
+ return *reinterpret_cast<Client*>(client);
}
} // namespace
/* external */
-API ScStatus sc_start()
+API ScStatus sc_start_glib_loop()
{
- return Client::sc_start();
+ return Client::sc_start_glib_loop();
}
-API ScStatus sc_stop()
+API ScStatus sc_stop_glib_loop()
{
- return Client::sc_stop();
+ return Client::sc_stop_glib_loop();
}
-API ScStatus sc_get_client(ScClient* client, ScClientType type, ...)
+API ScClient sc_client_create()
{
- const char* address = NULL;
- va_list vl;
- va_start(vl, type);
- if (type == SCCLIENT_CUSTOM_TYPE) {
- address = va_arg(vl, const char*);
- assert(address);
- }
- va_end(vl);
-
- assert(client);
Client* clientPtr = new(nothrow) Client();
- *client = reinterpret_cast<ScClient>(clientPtr);
- if (clientPtr == NULL) {
- return SCCLIENT_NOT_ENOUGH_MEMORY;
- }
+ return reinterpret_cast<ScClient>(clientPtr);
+}
- ScStatus status;
- switch (type) {
- case SCCLIENT_CUSTOM_TYPE:
- status = clientPtr->create(address);
- break;
- case SCCLIENT_SYSTEM_TYPE:
- status = clientPtr->createSystem();
- break;
- default:
- assert(!"Logic error. No such ScClient type");
- status = SCCLIENT_EXCEPTION;
- }
- return status;
+API ScStatus sc_connect(ScClient client)
+{
+ return getClient(client).createSystem();
}
-API int sc_is_failed(ScStatus status)
+API ScStatus sc_connect_custom(ScClient client, const char* address)
{
- return status != SCCLIENT_SUCCESS ? 1 : 0;
+ return getClient(client).create(address);
}
API void sc_array_string_free(ScArrayString astring)
API void sc_client_free(ScClient client)
{
if (client != NULL) {
- delete getClient(client);
+ delete &getClient(client);
}
}
API const char* sc_get_status_message(ScClient client)
{
- return getClient(client)->sc_get_status_message();
+ return getClient(client).sc_get_status_message();
}
API ScStatus sc_get_status(ScClient client)
{
- return getClient(client)->sc_get_status();
+ return getClient(client).sc_get_status();
}
API ScStatus sc_get_container_dbuses(ScClient client, ScArrayString* keys, ScArrayString* values)
{
- return getClient(client)->sc_get_container_dbuses(keys, values);
+ return getClient(client).sc_get_container_dbuses(keys, values);
}
API ScStatus sc_get_container_ids(ScClient client, ScArrayString* array)
{
- return getClient(client)->sc_get_container_ids(array);
+ return getClient(client).sc_get_container_ids(array);
}
API ScStatus sc_get_active_container_id(ScClient client, ScString* id)
{
- return getClient(client)->sc_get_active_container_id(id);
+ return getClient(client).sc_get_active_container_id(id);
}
API ScStatus sc_set_active_container(ScClient client, const char* id)
{
- return getClient(client)->sc_set_active_container(id);
+ return getClient(client).sc_set_active_container(id);
}
API ScStatus sc_container_dbus_state(ScClient client,
ScContainerDbusStateCallback containerDbusStateCallback)
{
- return getClient(client)->sc_container_dbus_state(containerDbusStateCallback);
+ return getClient(client).sc_container_dbus_state(containerDbusStateCallback);
}
API ScStatus sc_notify_active_container(ScClient client,
const char* application,
const char* message)
{
- return getClient(client)->sc_notify_active_container(application, message);
+ return getClient(client).sc_notify_active_container(application, message);
}
API ScStatus sc_notification(ScClient client, ScNotificationCallback notificationCallback)
{
- return getClient(client)->sc_notification(notificationCallback);
+ return getClient(client).sc_notification(notificationCallback);
}
* Completion status of communication function.
*/
typedef enum {
- SCCLIENT_DBUS_CUSTOM_EXCEPTION,
- SCCLIENT_DBUS_IO_EXCEPTION,
- SCCLIENT_DBUS_OPERATION_EXCEPTION,
- SCCLIENT_DBUS_INVALID_ARGUMENT_EXCEPTION,
- SCCLIENT_DBUS_EXCEPTION,
- SCCLIENT_NOT_ENOUGH_MEMORY,
- SCCLIENT_RUNTIME_EXCEPTION,
- SCCLIENT_EXCEPTION,
- SCCLIENT_SUCCESS
+ SCCLIENT_CUSTOM_ERROR, ///< User specified error
+ SCCLIENT_IO_ERROR, ///< Input/Output error
+ SCCLIENT_OPERATION_FAILED, ///< Operation failed
+ SCCLIENT_INVALID_ARGUMENT, ///< Invalid argument
+ SCCLIENT_OTHER_ERROR, ///< Other error
+ SCCLIENT_SUCCESS ///< Success
} ScStatus;
-typedef enum {
- SCCLIENT_SYSTEM_TYPE,
- SCCLIENT_CUSTOM_TYPE
-} ScClientType;
-
/**
- * Initialize communication resources.
+ * Start glib loop.
+ *
+ * Do not call this function if the application creates glib loop itself.
+ * Otherwise call it before any other function from this library.
+ *
+ * @return status of this function call
*/
-ScStatus sc_start();
+ScStatus sc_start_glib_loop();
/**
- * Release communication resources.
+ * Stop glib loop.
*
- * @return Status of this function call.
+ * @return status of this function call
*/
-ScStatus sc_stop();
+ScStatus sc_stop_glib_loop();
/**
- * Create a security-containers-server's client.
+ * Create a new security-containers-server's client.
*
- * After calling this function a connection to security-containers-server is established.
- *
- * @param[out] client security-containers-server's client who will be returned.
- * Client can be broken. To check this you must call sc_is_failed().
- * Broken client can't be used to communicate with security-containers-server.
- * @param[in] type Type of client.
- * @param[in] @optional address Dbus socket address (significant only for type SCCLIENT_CUSTOM_TYPE).
- * @return Status of this function call.
+ * @return created client
*/
-ScStatus sc_get_client(ScClient* client, ScClientType type, /* const char* address */ ...);
+ScClient sc_client_create();
/**
* Release client resources.
*
- * @param client security-containers-server's client.
+ * @param client security-containers-server's client
*/
void sc_client_free(ScClient client);
/**
+ * Get status code of last security-containers-server communication.
+ *
+ * @param client security-containers-server's client
+ * @return status of this function call
+ */
+ScStatus sc_get_status(ScClient client);
+
+/**
* Get status message of the last security-containers-server communication.
*
- * @param client security-containers-server's client.
- * @return Last status message from security-containers-server communication.
+ * @param client security-containers-server's client
+ * @return last status message from security-containers-server communication
*/
const char* sc_get_status_message(ScClient client);
/**
- * Get status code of last security-containers-server communication.
+ * Connect client to the security-containers-server.
*
- * @param client security-containers-server's client.
- * @return Status of this function call.
+ * @param client security-containers-server's client
+ * @return status of this function call
*/
-ScStatus sc_get_status(ScClient client);
+ScStatus sc_connect(ScClient client);
/**
- * Check if security-containers-server communication function fail.
+ * Connect client to the security-containers-server via custom address.
*
- * @param status Value returned by security-containers-server communication function.
- * @return 0 if succeeded otherwise 1.
+ * @param client security-containers-server's client
+ * @param address dbus address
+ * @return status of this function call
*/
-int sc_is_failed(ScStatus status);
+ScStatus sc_connect_custom(ScClient client, const char* address);
/**
* Release ScArrayString.
*
- * @param astring ScArrayString.
+ * @param astring ScArrayString
*/
void sc_array_string_free(ScArrayString astring);
/**
* Release ScString.
*
- * @param string ScString.
+ * @param string ScString
*/
void sc_string_free(ScString string);
/**
* Get dbus address of each container.
*
- * @param[in] client security-containers-server's client.
- * @param[out] keys Array of containers name.
- * @param[out] values Array of containers dbus address.
- * @return Status of this function call.
- * @post keys[i] corresponds to values[i].
+ * @param[in] client security-containers-server's client
+ * @param[out] keys array of containers name
+ * @param[out] values array of containers dbus address
+ * @return status of this function call
+ * @post keys[i] corresponds to values[i]
*/
ScStatus sc_get_container_dbuses(ScClient client, ScArrayString* keys, ScArrayString* values);
/**
* Get containers name.
*
- * @param[in] client security-containers-server's client.
- * @param[out] array Array of containers name.
- * @return Status of this function call.
+ * @param[in] client security-containers-server's client
+ * @param[out] array array of containers name
+ * @return status of this function call
*/
ScStatus sc_get_container_ids(ScClient client, ScArrayString* array);
/**
* Get active container name.
*
- * @param[in] client security-containers-server's client.
- * @param[out] id Active container name.
- * @return Status of this function call.
+ * @param[in] client security-containers-server's client
+ * @param[out] id active container name
+ * @return status of this function call
*/
ScStatus sc_get_active_container_id(ScClient client, ScString* id);
/**
* Set active container.
*
- * @param client security-containers-server's client.
- * @param id Container name.
- * @return Status of this function call.
+ * @param client security-containers-server's client
+ * @param id container name
+ * @return status of this function call
*/
ScStatus sc_set_active_container(ScClient client, const char* id);
*
* The callback function will be invoked on a different thread
*
- * @param client security-containers-server's client.
- * @param containerDbusStateCallback Callback function.
- * @return Status of this function call.
+ * @param client security-containers-server's client
+ * @param containerDbusStateCallback callback function
+ * @return status of this function call
*/
ScStatus sc_container_dbus_state(ScClient client,
ScContainerDbusStateCallback containerDbusStateCallback);
/**
* Send message to active container.
*
- * @param client security-containers-server's client.
- * @param application Application name.
- * @param message Message.
- * @return Status of this function call.
+ * @param client security-containers-server's client
+ * @param application application name
+ * @param message message
+ * @return status of this function call
*/
ScStatus sc_notify_active_container(ScClient client, const char* application, const char* message);
*
* The callback function will be invoked on a different thread.
*
- * @param client security-containers-server's client.
- * @param notificationCallback Callback function.
- * @return Status of this function call.
+ * @param client security-containers-server's client
+ * @param notificationCallback callback function
+ * @return status of this function call
*/
ScStatus sc_notification(ScClient client, ScNotificationCallback notificationCallback);
#ifdef __cplusplus
#include "utils/glib-loop.hpp"
#include "utils/callback-wrapper.hpp"
+#include <atomic>
+#include <cassert>
#include <glib-object.h>
namespace security_containers {
namespace utils {
+namespace {
+std::atomic_bool gLoopPresent(false);
+}
+
ScopedGlibLoop::ScopedGlibLoop()
: mLoop(g_main_loop_new(NULL, FALSE), g_main_loop_unref)
{
+ if (gLoopPresent.exchange(true)) {
+ // only one loop per process
+ assert(0 && "Loop is already running");
+ }
#if !GLIB_CHECK_VERSION(2,36,0)
g_type_init();
#endif
//stop loop and wait
g_main_loop_quit(mLoop.get());
mLoopThread.join();
+ gLoopPresent = false;
}
void Glib::addTimerEvent(const unsigned int intervalMs,
def terminatedBySignal(self, bin, signum):
self.error("\n=========== FAILED ===========\n")
- signame = {2:"SIGINT", 9:"SIGKILL", 11:"SIGSEGV", 15:"SIGTERM"}
+ signame = { 2: "SIGINT (Interrupt)",
+ 3: "SIGQUIT (Quit)",
+ 5: "SIGTRAP (Trace trap)",
+ 6: "SIGABRT (Abort)",
+ 8: "SIGFPE (Floating-point exception)",
+ 9: "SIGKILL (Kill)",
+ 11: "SIGSEGV (Segmentation fault)",
+ 15: "SIGTERM (Termination)"}
siginfo = signame.get(signum, 'signal ' + str(signum))
self.error('Terminated by ' + siginfo)
- if signum == 11: # SIGSEGV
+ if signum in [5, 6, 8, 11]:
self.error("\nUse following command to launch debugger:")
self.error(self.__indentChar + "sc_launch_test.py --gdb " + bin)
const std::string TEST_DBUS_CONFIG_PATH =
SC_TEST_CONFIG_INSTALL_DIR "/client/ut-client/test-dbus-daemon.conf";
+struct Loop {
+ Loop() { sc_start_glib_loop(); };
+ ~Loop() { sc_stop_glib_loop(); };
+};
+
struct Fixture {
- Fixture() { sc_start(); };
- ~Fixture() { sc_stop(); };
+ Loop loop;
+ ContainersManager cm;
+
+ Fixture(): cm(TEST_DBUS_CONFIG_PATH)
+ {
+ cm.startAll();
+ };
};
const int EVENT_TIMEOUT = 5000; ///< ms
ScArrayString values,
std::map<std::string, std::string>& ret)
{
- char** iKeys;
- char** iValues;
+ ScArrayString iKeys;
+ ScArrayString iValues;
for (iKeys = keys, iValues = values; *iKeys && *iValues; iKeys++, iValues++) {
ret.insert(std::make_pair(*iKeys, *iValues));
}
void convertArrayToSet(ScArrayString values, std::set<std::string>& ret)
{
- for (char** iValues = values; *iValues; iValues++) {
+ for (ScArrayString iValues = values; *iValues; iValues++) {
ret.insert(*iValues);
}
}
BOOST_AUTO_TEST_CASE(NotRunningServerTest)
{
- ScClient client;
- ScStatus status = sc_get_client(&client,
- SCCLIENT_CUSTOM_TYPE,
- EXPECTED_DBUSES_STARTED.begin()->second.c_str());
- BOOST_CHECK(sc_is_failed(status));
+ cm.stopAll();
+
+ ScClient client = sc_client_create();
+ ScStatus status = sc_connect_custom(client,
+ EXPECTED_DBUSES_STARTED.begin()->second.c_str());
+ BOOST_CHECK_EQUAL(SCCLIENT_IO_ERROR, status);
sc_client_free(client);
}
BOOST_AUTO_TEST_CASE(GetContainerDbusesTest)
{
- std::unique_ptr<ContainersManager> cm;
- BOOST_REQUIRE_NO_THROW(cm.reset(new ContainersManager(TEST_DBUS_CONFIG_PATH)));
- cm->startAll();
- ScClient client;
- ScStatus status = sc_get_client(&client, SCCLIENT_SYSTEM_TYPE);
- BOOST_REQUIRE(!sc_is_failed(status));
+ ScClient client = sc_client_create();
+ ScStatus status = sc_connect(client);
+ BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
ScArrayString keys, values;
status = sc_get_container_dbuses(client, &keys, &values);
- BOOST_REQUIRE(!sc_is_failed(status));
+ BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
BOOST_CHECK_EQUAL(getArrayStringLength(keys, EXPECTED_DBUSES_STARTED.size() + 1),
EXPECTED_DBUSES_STARTED.size());
sc_array_string_free(keys);
sc_array_string_free(values);
sc_client_free(client);
- BOOST_WARN_NO_THROW(cm.reset());
}
BOOST_AUTO_TEST_CASE(GetContainerIdsTest)
{
- std::unique_ptr<ContainersManager> cm;
- BOOST_REQUIRE_NO_THROW(cm.reset(new ContainersManager(TEST_DBUS_CONFIG_PATH)));
- cm->startAll();
- ScClient client;
- ScStatus status = sc_get_client(&client, SCCLIENT_SYSTEM_TYPE);
- BOOST_REQUIRE(!sc_is_failed(status));
+ ScClient client = sc_client_create();
+ ScStatus status = sc_connect(client);
+ BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
ScArrayString values;
status = sc_get_container_ids(client, &values);
- BOOST_REQUIRE(!sc_is_failed(status));
+ BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
BOOST_CHECK_EQUAL(getArrayStringLength(values, EXPECTED_DBUSES_STARTED.size() + 1),
EXPECTED_DBUSES_STARTED.size());
}
sc_array_string_free(values);
sc_client_free(client);
-
- BOOST_WARN_NO_THROW(cm.reset());
}
BOOST_AUTO_TEST_CASE(GetActiveContainerIdTest)
{
- std::unique_ptr<ContainersManager> cm;
- BOOST_REQUIRE_NO_THROW(cm.reset(new ContainersManager(TEST_DBUS_CONFIG_PATH)));
- cm->startAll();
-
- ScClient client;
- ScStatus status = sc_get_client(&client, SCCLIENT_SYSTEM_TYPE);
- BOOST_REQUIRE(!sc_is_failed(status));
+ ScClient client = sc_client_create();
+ ScStatus status = sc_connect(client);
+ BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
ScString container;
status = sc_get_active_container_id(client, &container);
- BOOST_REQUIRE(!sc_is_failed(status));
+ BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
- BOOST_CHECK_EQUAL(container, cm->getRunningForegroundContainerId());
+ BOOST_CHECK_EQUAL(container, cm.getRunningForegroundContainerId());
sc_string_free(container);
sc_client_free(client);
-
- BOOST_WARN_NO_THROW(cm.reset());
}
BOOST_AUTO_TEST_CASE(SetActiveContainerTest)
{
- std::string newActiveContainerId = "ut-containers-manager-console2-dbus";
+ const std::string newActiveContainerId = "ut-containers-manager-console2-dbus";
- std::unique_ptr<ContainersManager> cm;
- BOOST_REQUIRE_NO_THROW(cm.reset(new ContainersManager(TEST_DBUS_CONFIG_PATH)));
- cm->startAll();
- BOOST_REQUIRE_NE(newActiveContainerId, cm->getRunningForegroundContainerId());
+ BOOST_REQUIRE_NE(newActiveContainerId, cm.getRunningForegroundContainerId());
- ScClient client;
- ScStatus status = sc_get_client(&client, SCCLIENT_SYSTEM_TYPE);
- BOOST_REQUIRE(!sc_is_failed(status));
+ ScClient client = sc_client_create();
+ ScStatus status = sc_connect(client);
+ BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
status = sc_set_active_container(client, newActiveContainerId.c_str());
- BOOST_REQUIRE(!sc_is_failed(status));
- BOOST_CHECK_EQUAL(newActiveContainerId, cm->getRunningForegroundContainerId());
+ BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
+ BOOST_CHECK_EQUAL(newActiveContainerId, cm.getRunningForegroundContainerId());
sc_client_free(client);
- BOOST_WARN_NO_THROW(cm.reset());
}
BOOST_AUTO_TEST_CASE(NotificationTest)
{
- std::string activeContainerId = "ut-containers-manager-console1-dbus";
- std::unique_ptr<ContainersManager> cm;
- BOOST_REQUIRE_NO_THROW(cm.reset(new ContainersManager(TEST_DBUS_CONFIG_PATH)));
- cm->startAll();
-
std::map<std::string, ScClient> clients;
for (const auto& it : EXPECTED_DBUSES_STARTED) {
- ScClient client;
- ScStatus status = sc_get_client(&client, SCCLIENT_CUSTOM_TYPE, it.second.c_str());
- BOOST_REQUIRE(!sc_is_failed(status));
+ ScClient client = sc_client_create();
+ ScStatus status = sc_connect_custom(client, it.second.c_str());
+ BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
clients[it.first] = client;
}
for (auto& client : clients) {
ScStatus status = sc_notification(client.second, NotificationTestCallback);
- BOOST_REQUIRE(!sc_is_failed(status));
+ BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
}
for (auto& client : clients) {
ScStatus status = sc_notify_active_container(client.second, "app", "msg");
- BOOST_REQUIRE(!sc_is_failed(status));
+ BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
}
BOOST_CHECK(signalReceivedLatch.waitForN(clients.size() - 1, EVENT_TIMEOUT));
for (auto& client : clients) {
sc_client_free(client.second);
}
- BOOST_WARN_NO_THROW(cm.reset());
}
BOOST_AUTO_TEST_SUITE_END()
projects / platform / core / security / vasum.git / commitdiff