diff --git a/Modules/CppRestSdk/include/mitkIRESTManager.h b/Modules/CppRestSdk/include/mitkIRESTManager.h
index 40dbd2afaa..cd6d73b3a1 100644
--- a/Modules/CppRestSdk/include/mitkIRESTManager.h
+++ b/Modules/CppRestSdk/include/mitkIRESTManager.h
@@ -1,31 +1,32 @@
 #ifndef mitkIRESTManager_h
 #define mitkIRESTManager_h
 
 #include "cpprest/uri.h"
 #include "cpprest/json.h"
 #include <MitkCoreExports.h>
 #include <mitkServiceInterface.h>
 #include <mitkIRESTObserver.h>
 
 namespace mitk
 {
   class IRESTManager
   {
   public:
     virtual ~IRESTManager();
 
     enum RequestType
     {
       get,
       post,
       put
     };
     virtual void sendRequest(RequestType type) = 0;
     virtual void receiveRequest(web::uri uri, IRESTObserver *observer) = 0;
     virtual web::json::value handle(web::uri, web::json::value) = 0;
+    virtual void handleDeleteClient() = 0;
   };
 } // namespace mitk
 
 MITK_DECLARE_SERVICE_INTERFACE(mitk::IRESTManager, "org.mitk.IRESTManager")
 
 #endif
diff --git a/Modules/CppRestSdk/include/mitkIRESTObserver.h b/Modules/CppRestSdk/include/mitkIRESTObserver.h
index e60f96de34..3fd32d4acc 100644
--- a/Modules/CppRestSdk/include/mitkIRESTObserver.h
+++ b/Modules/CppRestSdk/include/mitkIRESTObserver.h
@@ -1,18 +1,19 @@
 #ifndef mitkIRESTObserver_h
 #define mitkIRESTObserver_h
 
 #include "cpprest/json.h"
 
 namespace mitk
 {
   class IRESTObserver
   {
   public:
+    virtual ~IRESTObserver();
     virtual web::json::value notify(web::json::value data) = 0;
 
 
   private:
   };
 }
 
 #endif // !mitkIRESTObserver
diff --git a/Modules/CppRestSdk/include/mitkRESTManager.h b/Modules/CppRestSdk/include/mitkRESTManager.h
index 20d659a6de..3475d14be4 100644
--- a/Modules/CppRestSdk/include/mitkRESTManager.h
+++ b/Modules/CppRestSdk/include/mitkRESTManager.h
@@ -1,30 +1,32 @@
 #ifndef mitkRESTManager_h
 #define mitkRESTManager_h
 
 #include <mitkIRESTManager.h>
 #include <mitkRESTClientMicroService.h>
 #include <mitkRESTServerMicroService.h>
 #include <mitkIRESTObserver.h>
 
 namespace mitk
 {
   class RESTManager : public IRESTManager
   {
   public:
     RESTManager();
     ~RESTManager() override;
 
     //calls RESTClient
     void sendRequest(RequestType type) override;
     //calls RESTServer
     void receiveRequest(web::uri uri, IRESTObserver *observer) override;
 
     web::json::value handle(web::uri, web::json::value) override;
 
+    virtual void handleDeleteClient() override;
+
   private:
     std::map<int, RESTClientMicroService*> m_ClientMap; // Map with port client pairs
     std::map<int, RESTServerMicroService*> m_ServerMap; // Map with port server pairs
     std::map<std::pair<int, utility::string_t>, IRESTObserver*> m_Observer; //Map with all observers
   };
 } // namespace mitk
 #endif // !mitkRESTManager_h
diff --git a/Modules/CppRestSdk/src/mitkCppRestSdkActivator.cpp b/Modules/CppRestSdk/src/mitkCppRestSdkActivator.cpp
index 0b403132fe..68027499fc 100644
--- a/Modules/CppRestSdk/src/mitkCppRestSdkActivator.cpp
+++ b/Modules/CppRestSdk/src/mitkCppRestSdkActivator.cpp
@@ -1,34 +1,36 @@
 #include "mitkCppRestSdkActivator.h"
 
 #include <usGetModuleContext.h>
 #include<usModule.h> 
 #include<usModuleActivator.h> 
 #include<usModuleContext.h> 
 #include<usModuleEvent.h> 
 #include<usModuleInitialization.h> 
 #include<usModuleResource.h> 
 #include<usModuleResourceStream.h> 
 #include<usModuleSettings.h> 
 #include<usServiceTracker.h>
 
 
 
 
 void MitkCppRestSdkActivator::Load(us::ModuleContext *context)
 {
   //Registration of the RESTManagerMicroservice
   m_RESTManager.reset(new mitk::RESTManager);
   context->RegisterService<mitk::IRESTManager>(m_RESTManager.get());
 
   //Test use of the RESTManagerMicroservice, later done in Module
  
   m_Test.TestRESTServer();
   m_Test2.TestRESTServer();
+
+  m_Test.~RestTest();
 }
 
 void MitkCppRestSdkActivator::Unload(us::ModuleContext *) 
 {
 
 }
 
 US_EXPORT_MODULE_ACTIVATOR(MitkCppRestSdkActivator)
diff --git a/Modules/CppRestSdk/src/mitkIRESTObserver.cpp b/Modules/CppRestSdk/src/mitkIRESTObserver.cpp
index aa533dc40c..f2c1de13fc 100644
--- a/Modules/CppRestSdk/src/mitkIRESTObserver.cpp
+++ b/Modules/CppRestSdk/src/mitkIRESTObserver.cpp
@@ -1 +1,20 @@
-#include "mitkIRESTObserver.h"
\ No newline at end of file
+#include "mitkIRESTObserver.h"
+#include <mitkCommon.h>
+#include <mitkIRESTManager.h>
+#include <usGetModuleContext.h>
+#include <usModule.h>
+#include <usServiceTracker.h>
+mitk::IRESTObserver::~IRESTObserver() 
+{
+  us::ModuleContext *context = us::GetModuleContext();
+  auto managerRef = context->GetServiceReference<IRESTManager>();
+  if (managerRef)
+  {
+    auto managerService = context->GetService(managerRef);
+    if (managerService)
+    {
+      managerService->handleDeleteClient();
+    }
+  }
+  MITK_INFO << "virtual destructor was called";
+}
diff --git a/Modules/CppRestSdk/src/mitkRESTManager.cpp b/Modules/CppRestSdk/src/mitkRESTManager.cpp
index c945f57d30..d6ea95658f 100644
--- a/Modules/CppRestSdk/src/mitkRESTManager.cpp
+++ b/Modules/CppRestSdk/src/mitkRESTManager.cpp
@@ -1,93 +1,100 @@
 #include "mitkRESTManager.h"
 #include <mitkCommon.h>
 
 mitk::RESTManager::RESTManager() {}
 
 mitk::RESTManager::~RESTManager() {}
 
 void mitk::RESTManager::sendRequest(RequestType type)
 {
   switch (type)
   {
     case get:
       // Call get in mitkRESTClientMicroService
       break;
     case post:
       // Call post in mitkRESTClientMicroService
       break;
     case put:
       // Call put in mitkRESTClientMicroService
       break;
   }
 }
 
 void mitk::RESTManager::receiveRequest(web::uri uri, mitk::IRESTObserver *observer)
 {
   // New instance of RESTServerMicroservice in m_ServerMap, key is port of the request
   int port = uri.port();
 
   // Checking if port is free to add a new Server
   if (m_ServerMap.count(port) == 0)
   {
     // new observer has to be added
     std::pair<int, utility::string_t> key(uri.port(), uri.path());
     m_Observer[key] = observer;
 
     // testing if entry has been added to observer map
     utility::string_t uristringt = uri.path();
     std::string uristring(uristringt.begin(), uristringt.end());
     MITK_INFO << uristring << " : Number of elements in map: " << m_Observer.count(key);
 
     // creating server instance
     RESTServerMicroService *server = new RESTServerMicroService(uri.authority());
     // add reference to server instance to map
     m_ServerMap[port] = server;
 
     // info output
     utility::string_t host = uri.authority().to_string();
     std::string hoststring(host.begin(), host.end());
     MITK_INFO << "new server" << hoststring << " at port" << port;
   }
   // If there is already a server under this port
   else
   {
     // Same host, means new observer but not a new server instance
     if (m_ServerMap[port]->GetUri() == uri.authority())
     {
       // new observer has to be added
       std::pair<int, utility::string_t> key(uri.port(), uri.path());
       m_Observer[key] = observer;
 
       // testing if entry has been added to map
       utility::string_t uristringt = uri.to_string();
       std::string uristring(uristringt.begin(), uristringt.end());
       MITK_INFO << uristring << " : Number of elements in map: " << m_Observer.count(key);
 
       // info output
       MITK_INFO << "started listening, no new server instance has been created";
     }
     // Error, since another server can't be added under this port
     else
     {
       MITK_ERROR << "there is already another server listening under this port";
     }
   }
 }
 
 
 web::json::value mitk::RESTManager::handle(web::uri uri, web::json::value data)
 {
   // Checking if is there is a observer for the port and path
   std::pair<int, utility::string_t> key(uri.port(), uri.path());
   if (m_Observer.count(key) != 0)
   {
     MITK_INFO << "Manager: Data send to observer";
     return m_Observer[key]->notify(data);
   }
   //No map under this port, delete Server Object to release port for other servers
   else
   {
     MITK_WARN << "No Observer can handle the data";
     return NULL;
   }
 }
+
+void mitk::RESTManager::handleDeleteClient()
+{
+  MITK_INFO << "Handle delete client";
+  //TODO implement
+}
+
diff --git a/Modules/CppRestSdk/src/mitkRESTServerMicroService.cpp b/Modules/CppRestSdk/src/mitkRESTServerMicroService.cpp
index 7f8e6a7a6c..e45ad4617c 100644
--- a/Modules/CppRestSdk/src/mitkRESTServerMicroService.cpp
+++ b/Modules/CppRestSdk/src/mitkRESTServerMicroService.cpp
@@ -1,68 +1,69 @@
 #include "mitkRESTServerMicroService.h"
 #include <mitkCommon.h>
 #include <usGetModuleContext.h>
 #include <usModule.h>
 
 mitk::RESTServerMicroService::RESTServerMicroService(web::uri uri) : m_Listener(uri)
 {
   m_Uri = uri;
   m_Listener.support(MitkRESTMethods::GET, std::bind(&RESTServerMicroService::HandleGet, this, std::placeholders::_1));
   openListener();
 }
 
 mitk::RESTServerMicroService::~RESTServerMicroService()
 {
   closeListener();
 }
 
 pplx::task<void> mitk::RESTServerMicroService::openListener()
 {
   return m_Listener.open();
 }
 
 pplx::task<void> mitk::RESTServerMicroService::closeListener()
 {
   return m_Listener.close();
 }
 
 web::uri mitk::RESTServerMicroService::GetUri() 
 {
   return m_Uri;
 }
 
 void mitk::RESTServerMicroService::HandleGet(MitkRequest request)
 {
   int port = m_Listener.uri().port();
  //getting exact request uri has to be a parameter in handle function
   web::uri_builder build(m_Listener.uri());
   build.append(request.absolute_uri());
   utility::string_t uriStringT = build.to_uri().to_string();
 
   std::string uriString(uriStringT.begin(), uriStringT.end());
   MITK_INFO << "Test for Server at port " << port << " Exact request uri: " << uriString;
   
   web::json::value content;
   us::ModuleContext *context = us::GetModuleContext();
 
   auto managerRef = context->GetServiceReference<IRESTManager>();
   if (managerRef)
   {
     auto managerService = context->GetService(managerRef);
     if (managerService)
     {
-      //TODO extract actual json from request body
       web::json::value data = request.extract_json().get();
       MITK_INFO << "Server: Data send to manager";
       content = managerService->handle(build.to_uri(), data);
       MITK_INFO << "server: Data received from manager";
     }
   }
   if (content!=NULL)
   {
+    //content handled by observer
     request.reply(MitkRestStatusCodes::OK, content);
   }
   else
   {
+    //no observer to handle data
     request.reply(MitkRestStatusCodes::NotFound);
   }
 }
\ No newline at end of file