Using VineWrapper for ServerChannel

Signed-off-by: hyunho <hhstark.kang@samsung.com>

diff --git a/cion/CMakeLists.txt b/cion/CMakeLists.txt
index 087a3e924749e0881dadef54b33877b7b89ae9ba..3dfacdb23e6ebb58dda09fb8ba55bfc2a691db6e 100644 (file)
--- a/cion/CMakeLists.txt
+++ b/cion/CMakeLists.txt
@@ -55,6 +55,5 @@ INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/common/
     DESTINATION ${INCLUDE_INSTALL_DIR}/cion/common/
     FILES_MATCHING PATTERN "*.hh")
 
-INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/vine/
-    DESTINATION ${INCLUDE_INSTALL_DIR}/cion/vine/
-    FILES_MATCHING PATTERN "*.hh")
\ No newline at end of file
+INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/vine/vine_interfaces.hh
+    DESTINATION ${INCLUDE_INSTALL_DIR}/cion/vine/)
\ No newline at end of file

diff --git a/cion/channel/server_channel.cc b/cion/channel/server_channel.cc
index 65db06983578a999be4c424ac3f6b7547e83acf4..3681f5e61381adfcc13c22f54df3de789c5ae9ac 100644 (file)
--- a/cion/channel/server_channel.cc
+++ b/cion/channel/server_channel.cc
@@ -43,39 +43,132 @@ namespace cion {
 namespace channel {
 
 ServerChannel::ServerChannel(std::string service_name) {
-  vine_initialize();
-  vine_session_h session;
-  vine_session_create(&session);
   int channel_id = IDGenerator::GetInst().GenChannelId();
   impl_ = std::unique_ptr<Impl>(new Impl(this, service_name, channel_id));
-  impl_->session_ = session;
-  impl_->event_receiver_ = std::make_shared<EventReceiver>(session);
-
-  vine_dp_create(impl_->session_, VINE_DP_TYPE_SERVER, &impl_->server_dp_);
-  LOG(INFO) << "create dp done";
-  vine_dp_set_accepted_cb(impl_->server_dp_, [] (
-      vine_dp_h dp, vine_dp_h client_dp, void *user_data) -> void {
-    ServerChannel* channel = static_cast<ServerChannel*>(user_data);
-    LOG(INFO) << "accpeted " << channel->impl_->my_peer_info_->GetUUID();
-    channel->impl_->HandlingRecvData(client_dp, user_data);
-    channel->impl_->Send(cmd::CionCmd::PeerInfo, client_dp,
-              channel->impl_->my_peer_info_->Serialize());
-  }, this);
-
-  LOG(INFO) << "accepted callback add done";
-  vine_dp_set_port(impl_->server_dp_, 0);
-
-  vine_service_create(&impl_->service_);
-  vine_service_set_type(impl_->service_, CION_SERVICE_TYPE);
-  vine_service_set_name(impl_->service_, service_name.c_str());
+  impl_->session_ = std::make_shared<VineSession>();
+  impl_->event_receiver_ =
+      std::make_shared<EventReceiver>(impl_->session_->GetRawSession());
+}
+
+void ServerChannel::OnDiscovered(VineService service, std::string ip) {
+}
+
+void ServerChannel::OnOpened(VineDpPtr dp) {
+  LOG(INFO) << "OnOpened " << dp->GetRawDp();
+  if (impl_->service_ == nullptr) {
+    impl_->service_ = std::make_shared<VineService>(impl_->session_,
+      CION_SERVICE_TYPE, impl_->service_name_, dp->GetPort(), "");
+    impl_->service_->Register();
+  }
+}
+
+void ServerChannel::OnReceived(VineDpPtr dp, std::vector<unsigned char> data) {
+  LOG(INFO) << "OnReceived " << dp->GetRawDp();
+  ChannelJob<ServerChannel> job(this, std::make_shared<tizen_base::Parcel>(
+    data.data(), data.size()), dp->GetRawDp());
+  impl_->queue_.Push(job);
+
+  g_idle_add_full(G_PRIORITY_HIGH,
+    [](gpointer data) -> gboolean {
+      ServerChannel* channel = static_cast<ServerChannel*>(data);
+      ChannelJob<ServerChannel> job;
+      channel->impl_->queue_.TryAndPop(job);
+
+      unsigned int cmd;
+      uint32_t size;
+      std::shared_ptr<tizen_base::Parcel> parcel = job.GetParcel();
+      parcel->ReadUInt32(&cmd);
+      LOG(INFO) << "CMD " << cmd;
+      switch (cmd) {
+        case cmd::CionCmd::PeerInfo:
+        {
+          LOG(INFO) << "ConnectionRequested";
+          parcel->ReadUInt32(&size);
+          unsigned char* peerinfo_data =
+              (unsigned char*)calloc(size, sizeof(unsigned char));
+          parcel->Read(peerinfo_data, size);
+
+          std::shared_ptr<PeerInfo> req_peer =
+              std::dynamic_pointer_cast<PeerInfo>(
+                  std::make_shared<ServerPeerInfo>(
+                    peerinfo_data, size, job.GetClientDp()));
+          free(peerinfo_data);
+
+          bool re = channel->OnConnectionRequest(req_peer);
+          if (re) {
+            ConnectionResult result(ConnectionResult::OK);
+            channel->OnConnectionResult(req_peer, result);
+            channel->impl_->Send(cmd::CionCmd::Accept, job.GetClientDp(),
+                channel->impl_->my_peer_info_->Serialize());
+            channel->impl_->peerlist_.push_back(req_peer);
+          } else {
+            channel->impl_->Send(cmd::CionCmd::Reject, job.GetClientDp(),
+                channel->impl_->my_peer_info_->Serialize());
+          }
+          break;
+        }
+
+        case cmd::CionCmd::PayloadAsync:
+        {
+          LOG(INFO) << "PayloadReceived from client";
+          parcel->ReadUInt32(&size);
+          unsigned char* payload_data =
+              (unsigned char*)calloc(size, sizeof(unsigned char));
+          parcel->Read(payload_data, size);
+
+          for (std::shared_ptr<PeerInfo> peer : channel->impl_->peerlist_) {
+            std::shared_ptr<ServerPeerInfo> speer =
+                std::dynamic_pointer_cast<ServerPeerInfo>(peer);
+            if (speer->GetClientDp() == job.GetClientDp()) {
+              auto pl = FactoryManager::GetInst().CreatePayload(
+                  std::vector<char>(payload_data, payload_data + size));
+              channel->OnPayloadReceived(pl, peer);
+              break;
+            }
+          }
+          free(payload_data);
+          break;
+        }
+
+        case cmd::CionCmd::DataSync:
+        {
+          LOG(INFO) << "DataSync from client";
+          parcel->ReadUInt32(&size);
+          unsigned char* sync_data =
+              (unsigned char*)calloc(size, sizeof(unsigned char));
+          parcel->Read(sync_data, size);
+
+          for (std::shared_ptr<PeerInfo> peer : channel->impl_->peerlist_) {
+            std::shared_ptr<ServerPeerInfo> speer =
+                std::dynamic_pointer_cast<ServerPeerInfo>(peer);
+            if (speer->GetClientDp() == job.GetClientDp()) {
+              std::vector<char> result = channel->OnDataReceived(
+                  std::vector<char>(sync_data, sync_data + size), peer);
+              channel->impl_->Send(cmd::CionCmd::DataSyncReply,
+                  speer->GetClientDp(), result);
+              break;
+            }
+          }
+          free(sync_data);
+          break;
+        }
+      }
+      return G_SOURCE_REMOVE;
+    }, this, nullptr);
+}
+
+void ServerChannel::OnTerminated(VineDpPtr dp) {
+}
+
+void ServerChannel::OnAccepted(VineDpPtr dp) {
+  LOG(INFO) << "OnAccepted ?? " << dp->GetRawDp();
+  impl_->accepted_dp_list_.push_back(dp);
+  dp->SetDpReceivedEventHandler(this);
+  impl_->Send(cmd::CionCmd::PeerInfo, dp->GetRawDp(),
+              impl_->my_peer_info_->Serialize());
 }
 
 ServerChannel::~ServerChannel() {
-  vine_dp_destroy(impl_->server_dp_);
-  vine_session_unregister(impl_->session_);
-  vine_service_destroy(impl_->service_);
-  vine_session_destroy(impl_->session_);
-  vine_deinitialize();
 }
 
 ServerChannel::Impl::~Impl() {
@@ -87,7 +180,6 @@ ServerChannel::Impl::Impl(
   my_peer_info_ = std::make_shared<PeerInfo>();
 }
 
-
 void ServerChannel::Impl::Send(cmd::CionCmd cmd, vine_dp_h client_dp,
       std::vector<char> raw) {
   tizen_base::Parcel parcel;
@@ -95,9 +187,8 @@ void ServerChannel::Impl::Send(cmd::CionCmd cmd, vine_dp_h client_dp,
   parcel.WriteUInt32(raw.size());
   parcel.Write(raw.data(), raw.size());
 
-  auto* p = reinterpret_cast<unsigned char*>(
-      const_cast<uint8_t*>(parcel.GetRaw().data()));
-  vine_dp_send(client_dp, p, parcel.GetRaw().size());
+  VineDp dp(client_dp, false);
+  dp.SendDataAsync(parcel.GetRaw());
   LOG(INFO) << "send " << parcel.GetRaw().size();
 }
 
@@ -108,150 +199,35 @@ void ServerChannel::Impl::Send(cmd::CionCmd cmd, vine_dp_h client_dp,
   parcel.WriteUInt32(raw.size());
   parcel.Write(raw.data(), raw.size());
 
-  auto* p = reinterpret_cast<unsigned char*>(
-      const_cast<uint8_t*>(parcel.GetRaw().data()));
-  vine_dp_send(client_dp, p, parcel.GetRaw().size());
+  VineDp dp(client_dp, false);
+  dp.SendDataAsync(parcel.GetRaw());
   LOG(WARNING) << "send " << parcel.GetRaw().size();
 }
 
-void ServerChannel::Impl::HandlingRecvData(
-    vine_dp_h client_dp, void* user_data) {
-  vine_dp_set_received_cb(client_dp,
-      [](vine_dp_h client_dp, size_t received_len, void *user_data) {
-    ServerChannel* channel = static_cast<ServerChannel*>(user_data);
-    unsigned char* data =
-      (unsigned char*)calloc(received_len, sizeof(unsigned char));
-
-    size_t bytes;
-    vine_dp_recv(client_dp, data, received_len, &bytes);
-    LOG(INFO) << "HandlingRecvData received_len bytes "
-        << received_len << ", " << bytes;
-
-    ChannelJob<ServerChannel> job(
-        channel, std::make_shared<tizen_base::Parcel>(data, bytes), client_dp);
-    channel->impl_->queue_.Push(job);
-    free(data);
-
-    g_idle_add_full(G_PRIORITY_HIGH,
-      [](gpointer data) -> gboolean {
-        ServerChannel* channel = static_cast<ServerChannel*>(data);
-        ChannelJob<ServerChannel> job;
-        channel->impl_->queue_.TryAndPop(job);
-
-        unsigned int cmd;
-        uint32_t size;
-        std::shared_ptr<tizen_base::Parcel> parcel = job.GetParcel();
-        parcel->ReadUInt32(&cmd);
-        LOG(INFO) << "CMD " << cmd;
-        switch (cmd) {
-          case cmd::CionCmd::PeerInfo:
-          {
-            LOG(INFO) << "ConnectionRequested";
-            parcel->ReadUInt32(&size);
-            unsigned char* peerinfo_data =
-                (unsigned char*)calloc(size, sizeof(unsigned char));
-            parcel->Read(peerinfo_data, size);
-
-            std::shared_ptr<PeerInfo> req_peer =
-                std::dynamic_pointer_cast<PeerInfo>(
-                    std::make_shared<ServerPeerInfo>(
-                      peerinfo_data, size, job.GetClientDp()));
-            free(peerinfo_data);
-
-            bool re = channel->OnConnectionRequest(req_peer);
-            if (re) {
-              ConnectionResult result(ConnectionResult::OK);
-              channel->OnConnectionResult(req_peer, result);
-              channel->impl_->Send(cmd::CionCmd::Accept, job.GetClientDp(),
-                  channel->impl_->my_peer_info_->Serialize());
-              channel->impl_->peerlist_.push_back(req_peer);
-            } else {
-              channel->impl_->Send(cmd::CionCmd::Reject, job.GetClientDp(),
-                  channel->impl_->my_peer_info_->Serialize());
-            }
-            break;
-          }
-
-          case cmd::CionCmd::PayloadAsync:
-          {
-            LOG(INFO) << "PayloadReceived from client";
-            parcel->ReadUInt32(&size);
-            unsigned char* payload_data =
-                (unsigned char*)calloc(size, sizeof(unsigned char));
-            parcel->Read(payload_data, size);
-
-            for (std::shared_ptr<PeerInfo> peer : channel->impl_->peerlist_) {
-              std::shared_ptr<ServerPeerInfo> speer =
-                  std::dynamic_pointer_cast<ServerPeerInfo>(peer);
-              if (speer->GetClientDp() == job.GetClientDp()) {
-                auto pl = FactoryManager::GetInst().CreatePayload(
-                    std::vector<char>(payload_data, payload_data + size));
-                channel->OnPayloadReceived(pl, peer);
-                break;
-              }
-            }
-            free(payload_data);
-            break;
-          }
-
-          case cmd::CionCmd::DataSync:
-          {
-            LOG(INFO) << "DataSync from client";
-            parcel->ReadUInt32(&size);
-            unsigned char* sync_data =
-                (unsigned char*)calloc(size, sizeof(unsigned char));
-            parcel->Read(sync_data, size);
-
-            for (std::shared_ptr<PeerInfo> peer : channel->impl_->peerlist_) {
-              std::shared_ptr<ServerPeerInfo> speer =
-                  std::dynamic_pointer_cast<ServerPeerInfo>(peer);
-              if (speer->GetClientDp() == job.GetClientDp()) {
-                std::vector<char> result = channel->OnDataReceived(
-                    std::vector<char>(sync_data, sync_data + size), peer);
-                channel->impl_->Send(cmd::CionCmd::DataSyncReply,
-                    speer->GetClientDp(), result);
-                break;
-              }
-            }
-            free(sync_data);
-            break;
-          }
-        }
-        return G_SOURCE_REMOVE;
-      }, channel, nullptr);
-  }, user_data);
-}
-
 void ServerChannel::Listen() {
-  LOG(INFO) << "Start listening !!";
-  vine_dp_open(impl_->server_dp_,
-    [] (vine_dp_h dp, vine_error_e result, void *user_data) -> void {
-      LOG(INFO) << "Listen Opened !!! " << result;
-      int port;
-      ServerChannel* channel = static_cast<ServerChannel*>(user_data);
-      vine_dp_get_port(dp, &port);
-
-      vine_service_set_port(channel->impl_->service_, port);
-      vine_session_set_registered_cb(channel->impl_->session_, [] (
-          vine_session_h session, const char* service_name,
-          vine_error_e error, void* user_data) -> void {
-        LOG(INFO) << "session registered";
-      }, nullptr);
-      vine_session_register(channel->impl_->session_,
-          channel->impl_->service_, nullptr);
-    }, this);
+  LOG(INFO) << "Listen !!";
+  impl_->server_dp_ = std::make_shared<VineServerDp>(impl_->session_);
+  impl_->server_dp_->SetDpAcceptedEventHandler(this);
+  impl_->server_dp_->SetDpOpenedEventHandler(this);
+  impl_->server_dp_->Open();
 }
 
 void ServerChannel::Stop() {
   LOG(INFO) << "Stop listening !!";
-  vine_dp_close(impl_->server_dp_);
+  impl_->server_dp_->Close();
 }
 
 void ServerChannel::Disconnect(std::shared_ptr<PeerInfo> peer) {
   LOG(INFO) << "Disconnect !!";
   std::shared_ptr<ServerPeerInfo> speer =
       std::dynamic_pointer_cast<ServerPeerInfo>(peer);
-  vine_dp_close(speer->GetClientDp());
+  for (VineDpPtr ptr : impl_->accepted_dp_list_) {
+    if (ptr->GetRawDp() == speer->GetClientDp()) {
+      ptr->Close();
+      impl_->accepted_dp_list_.remove(ptr);
+    }
+    vine_dp_close(speer->GetClientDp());
+  }
 }
 
 void ServerChannel::SendPayloadAsync(IPayload* data) {

diff --git a/cion/channel/server_channel.hh b/cion/channel/server_channel.hh
index e0c1546f030ad3483a9fc933ce8df56fcebfdf23..381bb19bec9358bb9b2dc1e6320424293c547b82 100644 (file)
--- a/cion/channel/server_channel.hh
+++ b/cion/channel/server_channel.hh
@@ -28,14 +28,17 @@
 #include "cion/channel/connection_result.hh"
 #include "cion/common/ipayload.hh"
 #include "cion/channel/server_peer_info.hh"
+#include "cion/vine/vine_interfaces.hh"
 
 
 namespace cion {
 namespace channel {
 
-class ServerChannel {
+class ServerChannel : public IVineBrowser, IVineDpOpenedEventHandler,
+    IVineDpReceivedEventHandler, IVineDpTerminatedEventHandler,
+    IVineDpAcceptedEventHandler {
  public:
-  ServerChannel(std::string service_name);
+  explicit ServerChannel(std::string service_name);
   virtual ~ServerChannel();
   void Listen();
   void Stop();
@@ -45,6 +48,12 @@ class ServerChannel {
   std::list<std::shared_ptr<PeerInfo>> GetConnectedPeerList();
   void SetSecurity(SecurityInfo sec);
 
+  void OnDiscovered(VineService service, std::string ip) override;
+  void OnOpened(VineDpPtr dp) override;
+  void OnReceived(VineDpPtr dp, std::vector<unsigned char> data) override;
+  void OnTerminated(VineDpPtr dp) override;
+  void OnAccepted(VineDpPtr dp) override;
+
  protected:
   virtual std::vector<char> OnDataReceived(const std::vector<char>& data,
       std::shared_ptr<PeerInfo> peer) = 0;

diff --git a/cion/channel/server_channel_implementation.hh b/cion/channel/server_channel_implementation.hh
index 46a45df8d26c9849f22d5451d283dfac6f764b1a..a974985010630918f49dcc247e01a472af8f80b0 100644 (file)
--- a/cion/channel/server_channel_implementation.hh
+++ b/cion/channel/server_channel_implementation.hh
@@ -30,6 +30,9 @@
 #include "cion/channel/shared_queue.hh"
 #include "cion/channel/channel_job.hh"
 #include "cion/common/cion_cmd.hh"
+#include "cion/vine/vine_session.hh"
+#include "cion/vine/vine_server_dp.hh"
+#include "cion/vine/vine_service.hh"
 
 namespace cion {
 namespace channel {
@@ -55,11 +58,13 @@ class ServerChannel::Impl {
   int channel_id_;
   std::list<std::shared_ptr<PeerInfo>> peerlist_;
   std::shared_ptr<PeerInfo> my_peer_info_;
-  vine_session_h session_ = nullptr;
-  vine_service_h service_ = nullptr;
-  vine_dp_h server_dp_ = nullptr;
   std::shared_ptr<EventReceiver> event_receiver_ = nullptr;
   SharedQueue<ChannelJob<ServerChannel>> queue_;
+  std::shared_ptr<VineSession> session_ = nullptr;
+  std::shared_ptr<VineServerDp> server_dp_ = nullptr;
+  std::shared_ptr<VineService> service_ = nullptr;
+  std::list<VineDpPtr> accepted_dp_list_;
+
 };
 
 }  // namespace channel

diff --git a/cion/vine/vine_service.cc b/cion/vine/vine_service.cc
index c963dd4a769e1b48162c338504fff37bf3af9901..a5fdb5e8ebd5579a47ad20344a89c0f5e538430b 100644 (file)
--- a/cion/vine/vine_service.cc
+++ b/cion/vine/vine_service.cc
@@ -28,10 +28,10 @@
 
 namespace cion {
 
-VineService::VineService(const std::string& type, const std::string& name,
-    int port, std::string iface_name)
-    : service_(nullptr), session_(std::make_shared<VineSession>()),
-      iface_name_(std::move(iface_name)) {
+VineService::VineService(std::shared_ptr<VineSession> session,
+    const std::string& type, const std::string& name, int port,
+    std::string iface_name)
+    : service_(nullptr), session_(session), iface_name_(std::move(iface_name)) {
   int ret = vine_session_set_registered_cb(session_->GetRawSession(),
       [](vine_session_h session, const char* service_name, vine_error_e error,
           void* user_data) {

diff --git a/cion/vine/vine_service.hh b/cion/vine/vine_service.hh
index 8264552e0bfbad5b98cc915db5dd4889c06dacb0..9a1b01a33fb50a53a9dc33f4184e39d9a9d0d26f 100644 (file)
--- a/cion/vine/vine_service.hh
+++ b/cion/vine/vine_service.hh
@@ -30,7 +30,8 @@ class VineSession;
 
 class VineService {
  public:
-  explicit VineService(const std::string& type, const std::string& name,
+  explicit VineService(std::shared_ptr<VineSession> session,
+      const std::string& type, const std::string& name,
       int port, std::string iface_name);
   explicit VineService(vine_service_h service);
   VineService(const VineService& other);