maidsafe-archive · mmoadeli · Jan 30, 2015 · Jan 31, 2015
diff --git a/src/maidsafe/vault/cache_handler/dispatcher.h b/src/maidsafe/vault/cache_handler/dispatcher.h
@@ -37,11 +37,6 @@ namespace detail {
 template <typename RequestorIdType>
 struct GetCacheResponseMessage {};
 
-template <>
-struct GetCacheResponseMessage<Requestor<nfs::SourcePersona<nfs::Persona::kMpidNode>>> {
-  typedef nfs::GetCachedResponseFromCacheHandlerToMpidNode Type;
-};
-
 template <>
 struct GetCacheResponseMessage<Requestor<nfs::SourcePersona<nfs::Persona::kDataGetter>>> {
   typedef nfs::GetCachedResponseFromCacheHandlerToDataGetter Type;

diff --git a/src/maidsafe/vault/cache_handler/operation_handlers.cc b/src/maidsafe/vault/cache_handler/operation_handlers.cc
@@ -29,34 +29,6 @@ class CacheHandlerService;
 
 namespace detail {
 
-template <>
-bool DoCacheOperation(
-    CacheHandlerService* service,
-    const nfs::GetResponseFromDataManagerToMpidNode& message,
-    const typename nfs::GetResponseFromDataManagerToMpidNode::Sender& /*sender*/,
-    const typename nfs::GetResponseFromDataManagerToMpidNode::Receiver& /*receiver*/) {
-  if (!message.contents->content)
-    return false;
-  auto data_name(detail::GetNameVariant(message.contents->name));
-  detail::PutToCacheVisitor put_to_cache(service, NonEmptyString(message.contents->content->data));
-  boost::apply_visitor(put_to_cache, data_name);
-  return true;
-}
-
-template <>
-bool DoCacheOperation(
-    CacheHandlerService* service,
-    const nfs::GetCachedResponseFromCacheHandlerToMpidNode& message,
-    const typename nfs::GetCachedResponseFromCacheHandlerToMpidNode::Sender& /*sender*/,
-    const typename nfs::GetCachedResponseFromCacheHandlerToMpidNode::Receiver& /*receiver*/) {
-  if (!message.contents->content)
-    return false;
-  auto data_name(detail::GetNameVariant(message.contents->name));
-  PutToCacheVisitor put_to_cache(service, NonEmptyString(message.contents->content->data));
-  boost::apply_visitor(put_to_cache, data_name);
-  return true;
-}
-
 template <>
 bool DoCacheOperation(
     CacheHandlerService* service,
@@ -99,20 +71,6 @@ bool DoCacheOperation(
   return boost::apply_visitor(get_from_cache, data_name);
 }
 
-template <>
-bool DoCacheOperation(
-    CacheHandlerService* service,
-    const nfs::GetRequestFromMpidNodeToDataManager& message,
-    const typename nfs::GetRequestFromMpidNodeToDataManager::Sender& sender,
-    const typename nfs::GetRequestFromMpidNodeToDataManager::Receiver& /*receiver*/) {
-  typedef nfs::GetRequestFromMpidNodeToDataManager::SourcePersona SourcePersonaType;
-  auto data_name(detail::GetNameVariant(*message.contents));
-  detail::Requestor<SourcePersonaType> requestor(sender.data);
-  detail::GetFromCacheVisitor<detail::Requestor<SourcePersonaType>>
-      get_from_cache(service, requestor, message.id);
-  return boost::apply_visitor(get_from_cache, data_name);
-}
-
 }  // namespace detail
 
 }  // namespace vault

diff --git a/src/maidsafe/vault/cache_handler/operation_handlers.h b/src/maidsafe/vault/cache_handler/operation_handlers.h
@@ -67,20 +67,6 @@ bool DoCacheOperation(CacheHandlerService* /*service*/, const MessageType& /*mes
   return false;
 }
 
-template <>
-bool DoCacheOperation(
-    CacheHandlerService* service,
-    const nfs::GetResponseFromDataManagerToMpidNode& message,
-    const typename nfs::GetResponseFromDataManagerToMpidNode::Sender& sender,
-    const typename nfs::GetResponseFromDataManagerToMpidNode::Receiver& receiver);
-
-template <>
-bool DoCacheOperation(
-    CacheHandlerService* service,
-    const nfs::GetCachedResponseFromCacheHandlerToMpidNode& message,
-    const typename nfs::GetCachedResponseFromCacheHandlerToMpidNode::Sender& sender,
-    const typename nfs::GetCachedResponseFromCacheHandlerToMpidNode::Receiver& receiver);
-
 template <>
 bool DoCacheOperation(
     CacheHandlerService* service,
@@ -102,13 +88,6 @@ bool DoCacheOperation(
     const typename nfs::GetRequestFromDataGetterToDataManager::Sender& sender,
     const typename nfs::GetRequestFromDataGetterToDataManager::Receiver& receiver);
 
-template <>
-bool DoCacheOperation(
-    CacheHandlerService* service,
-    const nfs::GetRequestFromMpidNodeToDataManager& message,
-    const typename nfs::GetRequestFromMpidNodeToDataManager::Sender& sender,
-    const typename nfs::GetRequestFromMpidNodeToDataManager::Receiver& receiver);
-
 }  // namespace detail
 
 template <typename MessageType>

diff --git a/src/maidsafe/vault/cache_handler/service.cc b/src/maidsafe/vault/cache_handler/service.cc
@@ -47,32 +47,6 @@ CacheHandlerService::CacheHandlerService(routing::Routing& routing,
   routing_.kNodeId();
 }
 
-template <>
-CacheHandlerService::HandleMessageReturnType
-CacheHandlerService::HandleMessage(
-    const nfs::GetResponseFromDataManagerToMpidNode& message,
-    const typename nfs::GetResponseFromDataManagerToMpidNode::Sender& sender,
-    const typename nfs::GetResponseFromDataManagerToMpidNode::Receiver& receiver) {
-  typedef nfs::GetResponseFromDataManagerToMpidNode MessageType;
-  return CacheOperationHandlerWrapper<MessageType>(
-             this, [this](const MessageType& message, const MessageType::Sender& sender) {
-                      return this->ValidateSender(message, sender);
-                   })(message, sender, receiver);
-}
-
-template <>
-CacheHandlerService::HandleMessageReturnType
-CacheHandlerService::HandleMessage(
-    const nfs::GetCachedResponseFromCacheHandlerToMpidNode& message,
-    const typename nfs::GetCachedResponseFromCacheHandlerToMpidNode::Sender& sender,
-    const typename nfs::GetCachedResponseFromCacheHandlerToMpidNode::Receiver& receiver) {
-  typedef nfs::GetCachedResponseFromCacheHandlerToMpidNode MessageType;
-  return CacheOperationHandlerWrapper<MessageType>(
-             this, [this](const MessageType& message, const MessageType::Sender& sender) {
-                      return this->ValidateSender(message, sender);
-                   })(message, sender, receiver);
-}
-
 template <>
 CacheHandlerService::HandleMessageReturnType
 CacheHandlerService::HandleMessage(
@@ -99,19 +73,6 @@ CacheHandlerService::HandleMessage(
                    })(message, sender, receiver);
 }
 
-template <>
-CacheHandlerService::HandleMessageReturnType
-CacheHandlerService::HandleMessage(
-    const nfs::GetRequestFromMpidNodeToDataManager& message,
-    const typename nfs::GetRequestFromMpidNodeToDataManager::Sender& sender,
-    const typename nfs::GetRequestFromMpidNodeToDataManager::Receiver& receiver) {
-  typedef nfs::GetRequestFromMpidNodeToDataManager MessageType;
-  return CacheOperationHandlerWrapper<MessageType>(
-             this, [this](const MessageType& message, const MessageType::Sender& sender) {
-                      return this->ValidateSender(message, sender);
-                   })(message, sender, receiver);
-}
-
 template <>
 CacheHandlerService::HandleMessageReturnType
 CacheHandlerService::HandleMessage(

diff --git a/src/maidsafe/vault/cache_handler/service.h b/src/maidsafe/vault/cache_handler/service.h
@@ -116,20 +116,6 @@ bool CacheHandlerService::ValidateSender(const MessageType& /*message*/,
   return true;
 }
 
-template <>
-CacheHandlerService::HandleMessageReturnType
-CacheHandlerService::HandleMessage(
-    const nfs::GetResponseFromDataManagerToMpidNode& message,
-    const typename nfs::GetResponseFromDataManagerToMpidNode::Sender& sender,
-    const typename nfs::GetResponseFromDataManagerToMpidNode::Receiver& receiver);
-
-template <>
-CacheHandlerService::HandleMessageReturnType
-CacheHandlerService::HandleMessage(
-    const nfs::GetCachedResponseFromCacheHandlerToMpidNode& message,
-    const typename nfs::GetCachedResponseFromCacheHandlerToMpidNode::Sender& sender,
-    const typename nfs::GetCachedResponseFromCacheHandlerToMpidNode::Receiver& receiver);
-
 template <>
 CacheHandlerService::HandleMessageReturnType
 CacheHandlerService::HandleMessage(
@@ -144,13 +130,6 @@ CacheHandlerService::HandleMessage(
     const typename nfs::GetCachedResponseFromCacheHandlerToDataGetter::Sender& sender,
     const typename nfs::GetCachedResponseFromCacheHandlerToDataGetter::Receiver& receiver);
 
-template <>
-CacheHandlerService::HandleMessageReturnType
-CacheHandlerService::HandleMessage(
-    const nfs::GetRequestFromMpidNodeToDataManager& message,
-    const typename nfs::GetRequestFromMpidNodeToDataManager::Sender& sender,
-    const typename nfs::GetRequestFromMpidNodeToDataManager::Receiver& receiver);
-
 template <>
 CacheHandlerService::HandleMessageReturnType
 CacheHandlerService::HandleMessage(

diff --git a/src/maidsafe/vault/data_manager/dispatcher.h b/src/maidsafe/vault/data_manager/dispatcher.h
@@ -163,16 +163,6 @@ namespace detail {
 template <typename RequestorIdType>
 struct GetResponseMessage {};
 
-template <>
-struct GetResponseMessage<Requestor<nfs::SourcePersona<nfs::Persona::kMpidNode>>> {
-  typedef nfs::GetResponseFromDataManagerToMpidNode Type;
-};
-
-template <>
-struct GetResponseMessage<PartialRequestor<nfs::SourcePersona<nfs::Persona::kMpidNode>>> {
-  typedef nfs::GetResponseFromDataManagerToMpidNodePartial Type;
-};
-
 template <>
 struct GetResponseMessage<Requestor<nfs::SourcePersona<nfs::Persona::kDataGetter>>> {
   typedef nfs::GetResponseFromDataManagerToDataGetter Type;

diff --git a/src/maidsafe/vault/data_manager/service.cc b/src/maidsafe/vault/data_manager/service.cc
@@ -131,33 +131,6 @@ void DataManagerService::HandleMessage(
 
 // ==================== Get / IntegrityCheck implementation ========================================
 
-template<>
-void DataManagerService::HandleMessage(
-    const nfs::GetRequestFromMpidNodeToDataManager& message,
-    const typename nfs::GetRequestFromMpidNodeToDataManager::Sender& sender,
-    const typename nfs::GetRequestFromMpidNodeToDataManager::Receiver& receiver) {
-  typedef nfs::GetRequestFromMpidNodeToDataManager MessageType;
-  OperationHandlerWrapper<DataManagerService, MessageType>(
-      accumulator_, [this](const MessageType &message, const MessageType::Sender &sender) {
-                      return this->ValidateSender(message, sender);
-                    },
-      Accumulator<Messages>::AddRequestChecker(RequiredRequests(message)),
-      this, accumulator_mutex_)(message, sender, receiver);
-}
-
-template <>
-void DataManagerService::HandleMessage(
-    const nfs::GetRequestFromMpidNodePartialToDataManager& message,
-    const typename nfs::GetRequestFromMpidNodePartialToDataManager::Sender& sender,
-    const typename nfs::GetRequestFromMpidNodePartialToDataManager::Receiver& /*receiver*/) {
-  auto data_name(detail::GetNameVariant(*message.contents));
-  typedef nfs::GetRequestFromMpidNodePartialToDataManager::SourcePersona SourceType;
-  detail::PartialRequestor<SourceType> requestor(sender);
-  detail::GetRequestVisitor<DataManagerService, detail::PartialRequestor<SourceType>>
-          get_request_visitor(this, requestor, message.id);
-  boost::apply_visitor(get_request_visitor, data_name);
-}
-
 template<>
 void DataManagerService::HandleMessage(
     const nfs::GetRequestFromDataGetterToDataManager& message,

diff --git a/src/maidsafe/vault/data_manager/service.h b/src/maidsafe/vault/data_manager/service.h
@@ -324,26 +324,12 @@ void DataManagerService::HandleMessage(
     const typename PutFailureFromPmidManagerToDataManager::Sender& sender,
     const typename PutFailureFromPmidManagerToDataManager::Receiver& receiver);
 
-template <>
-void DataManagerService::HandleMessage(
-    const nfs::GetRequestFromMpidNodeToDataManager& message,
-    const typename nfs::GetRequestFromMpidNodeToDataManager::Sender& sender,
-    const typename nfs::GetRequestFromMpidNodeToDataManager::Receiver& receiver);
-
-// Special case for relay messages
-template <>
-void DataManagerService::HandleMessage(
-    const nfs::GetRequestFromMpidNodePartialToDataManager& message,
-    const typename nfs::GetRequestFromMpidNodePartialToDataManager::Sender& sender,
-    const typename nfs::GetRequestFromMpidNodePartialToDataManager::Receiver& receiver);
-
 template <>
 void DataManagerService::HandleMessage(
     const nfs::GetRequestFromDataGetterToDataManager& message,
     const typename nfs::GetRequestFromDataGetterToDataManager::Sender& sender,
     const typename nfs::GetRequestFromDataGetterToDataManager::Receiver& receiver);
 
-
 // Special case for relay messages
 template <>
 void DataManagerService::HandleMessage(

diff --git a/src/maidsafe/vault/data_manager/tests/service_test.cc b/src/maidsafe/vault/data_manager/tests/service_test.cc
@@ -288,14 +288,14 @@ TEST_F(DataManagerServiceTest, BEH_Put) {
 }
 
 TEST_F(DataManagerServiceTest, BEH_SyncPut) {
-    ImmutableData data(NonEmptyString(RandomString(kTestChunkSize)));
-    DataManager::Key key(data.name());
-    auto group_source(CreateGroupSource(data.name()));
-    ActionDataManagerPut action_put(kTestChunkSize, nfs::MessageId(RandomInt32()));
-    auto group_unresolved_action(
-        CreateGroupUnresolvedAction<DataManager::UnresolvedPut>(key, action_put, group_source));
-    SendSync<DataManager::UnresolvedPut>(group_unresolved_action, group_source);
-    EXPECT_NO_THROW(Get(key));
+  ImmutableData data(NonEmptyString(RandomString(kTestChunkSize)));
+  DataManager::Key key(data.name());
+  auto group_source(CreateGroupSource(data.name()));
+  ActionDataManagerPut action_put(kTestChunkSize, nfs::MessageId(RandomInt32()));
+  auto group_unresolved_action(
+      CreateGroupUnresolvedAction<DataManager::UnresolvedPut>(key, action_put, group_source));
+  SendSync<DataManager::UnresolvedPut>(group_unresolved_action, group_source);
+  EXPECT_NO_THROW(Get(key));
 }
 
 TEST_F(DataManagerServiceTest, BEH_Delete) {

diff --git a/src/maidsafe/vault/demultiplexer.cc b/src/maidsafe/vault/demultiplexer.cc
@@ -41,10 +41,6 @@ void Demultiplexer::HandleMessage(const routing::SingleToGroupRelayMessage& rout
         return data_manager_service_.HandleMessage(
             nfs::GetRequestFromDataGetterPartialToDataManager(wrapper_tuple),
                 routing_message.sender, routing_message.receiver);
-      } else if (source_persona.data == nfs::Persona::kMpidNode) {
-        return data_manager_service_.HandleMessage(
-            nfs::GetRequestFromMpidNodePartialToDataManager(wrapper_tuple), routing_message.sender,
-                routing_message.receiver);
       }
       // This assert will happen if vault starts sending messages except Get() triggred
       // by routing's request for public key before having positive health.

diff --git a/src/maidsafe/vault/mpid_manager/action_put_message.cc b/src/maidsafe/vault/mpid_manager/action_put_message.cc
@@ -24,30 +24,34 @@ namespace maidsafe {
 namespace vault {
 
 ActionMpidManagerPutMessage::ActionMpidManagerPutMessage(
-    const nfs_vault::MpidMessage& message) : kMessage(message) {}
+    const nfs_vault::MpidMessage& message, nfs::MessageId message_id)
+        : kMessageAndId(MessageAndId(message, message_id)) {}
 
 ActionMpidManagerPutMessage::ActionMpidManagerPutMessage(const std::string& serialised_action)
-  : kMessage([&serialised_action]()->std::string {
+  : kMessageAndId([&serialised_action]()->MessageAndId {
             protobuf::ActionMpidManagerPutMessage proto;
             if (!proto.ParseFromString(serialised_action))
               BOOST_THROW_EXCEPTION(MakeError(CommonErrors::parsing_error));
-            return proto.serialised_message ();
+            return MessageAndId(nfs_vault::MpidMessage(proto.serialised_message()),
+                                nfs::MessageId(proto.message_id()));
           }()) {}
 
 ActionMpidManagerPutMessage::ActionMpidManagerPutMessage(
-    const ActionMpidManagerPutMessage& other) : kMessage(other.kMessage) {}
+    const ActionMpidManagerPutMessage& other) : kMessageAndId(other.kMessageAndId) {}
 
 ActionMpidManagerPutMessage::ActionMpidManagerPutMessage(ActionMpidManagerPutMessage&& other)
-    : kMessage(std::move(other.kMessage)) {}
+    : kMessageAndId(std::move(other.kMessageAndId)) {}
 
 std::string ActionMpidManagerPutMessage::Serialise() const {
   protobuf::ActionMpidManagerPutMessage proto;
-  proto.set_serialised_message(kMessage.Serialise());
+  proto.set_serialised_message(kMessageAndId.message.Serialise());
+  proto.set_message_id(kMessageAndId.id.data);
   return proto.SerializeAsString();
 }
 
 bool operator==(const ActionMpidManagerPutMessage& lhs, const ActionMpidManagerPutMessage& rhs) {
-  return lhs.kMessage == rhs.kMessage;
+  return (lhs.kMessageAndId.message == rhs.kMessageAndId.message) &&
+         (lhs.kMessageAndId.id == rhs.kMessageAndId.id);
 }
 
 bool operator!=(const ActionMpidManagerPutMessage& lhs, const ActionMpidManagerPutMessage& rhs) {

diff --git a/src/maidsafe/vault/mpid_manager/action_put_message.h b/src/maidsafe/vault/mpid_manager/action_put_message.h
@@ -34,7 +34,8 @@ namespace maidsafe {
 namespace vault {
 
 struct ActionMpidManagerPutMessage {
-  explicit ActionMpidManagerPutMessage(const nfs_vault::MpidMessage& alert);
+  explicit ActionMpidManagerPutMessage(const nfs_vault::MpidMessage& message,
+                                       nfs::MessageId message_id);
   explicit ActionMpidManagerPutMessage(const std::string& serialised_action);
   ActionMpidManagerPutMessage(const ActionMpidManagerPutMessage& other);
   ActionMpidManagerPutMessage(ActionMpidManagerPutMessage&& other);
@@ -44,7 +45,22 @@ struct ActionMpidManagerPutMessage {
   std::string Serialise() const;
 
   static const nfs::MessageAction kActionId = nfs::MessageAction::kSendMessageRequest;
-  const nfs_vault::MpidMessage kMessage;
+
+  struct MessageAndId {
+    MessageAndId(const nfs_vault::MpidMessage& message_in, nfs::MessageId id_in)
+        : message(message_in), id(id_in) {}
+
+    MessageAndId(const MessageAndId& other)
+        : message(other.message), id(other.id) {}
+
+    MessageAndId(MessageAndId&& other)
+        : message(std::move(other.message)), id(std::move(other.id)) {}
+
+    nfs_vault::MpidMessage message;
+    nfs::MessageId id;
+  };
+
+  MessageAndId kMessageAndId;
 };
 
 bool operator==(const ActionMpidManagerPutMessage& lhs, const ActionMpidManagerPutMessage& rhs);

diff --git a/src/maidsafe/vault/mpid_manager/action_put_message.proto b/src/maidsafe/vault/mpid_manager/action_put_message.proto
@@ -22,4 +22,5 @@ package maidsafe.vault.protobuf;
 
 message ActionMpidManagerPutMessage {
   required bytes serialised_message = 1;
+  required int32 message_id = 2;
 }