danicoin/src/Transfers/TransfersSynchronizer.cpp

321 lines
9.7 KiB
C++
Raw Normal View History

// Copyright (c) 2011-2016 The Cryptonote developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "TransfersSynchronizer.h"
#include "TransfersConsumer.h"
2015-07-30 15:22:07 +00:00
#include "Common/StdInputStream.h"
#include "Common/StdOutputStream.h"
#include "Serialization/BinaryInputStreamSerializer.h"
#include "Serialization/BinaryOutputStreamSerializer.h"
2015-07-30 15:22:07 +00:00
using namespace Common;
using namespace Crypto;
2015-07-30 15:22:07 +00:00
namespace CryptoNote {
const uint32_t TRANSFERS_STORAGE_ARCHIVE_VERSION = 0;
2015-05-27 12:08:46 +00:00
TransfersSyncronizer::TransfersSyncronizer(const CryptoNote::Currency& currency, IBlockchainSynchronizer& sync, INode& node) :
m_currency(currency), m_sync(sync), m_node(node) {
}
TransfersSyncronizer::~TransfersSyncronizer() {
m_sync.stop();
for (const auto& kv : m_consumers) {
m_sync.removeConsumer(kv.second.get());
}
}
2015-12-09 13:19:03 +00:00
void TransfersSyncronizer::initTransactionPool(const std::unordered_set<Crypto::Hash>& uncommitedTransactions) {
for (auto it = m_consumers.begin(); it != m_consumers.end(); ++it) {
it->second->initTransactionPool(uncommitedTransactions);
}
}
ITransfersSubscription& TransfersSyncronizer::addSubscription(const AccountSubscription& acc) {
auto it = m_consumers.find(acc.keys.address.viewPublicKey);
if (it == m_consumers.end()) {
std::unique_ptr<TransfersConsumer> consumer(
new TransfersConsumer(m_currency, m_node, acc.keys.viewSecretKey));
2015-12-09 13:19:03 +00:00
m_sync.addConsumer(consumer.get());
2015-12-09 13:19:03 +00:00
consumer->addObserver(this);
it = m_consumers.insert(std::make_pair(acc.keys.address.viewPublicKey, std::move(consumer))).first;
}
return it->second->addSubscription(acc);
}
2015-07-30 15:22:07 +00:00
bool TransfersSyncronizer::removeSubscription(const AccountPublicAddress& acc) {
auto it = m_consumers.find(acc.viewPublicKey);
if (it == m_consumers.end())
return false;
if (it->second->removeSubscription(acc)) {
m_sync.removeConsumer(it->second.get());
m_consumers.erase(it);
2015-12-09 13:19:03 +00:00
m_subscribers.erase(acc.viewPublicKey);
}
return true;
}
2015-07-30 15:22:07 +00:00
void TransfersSyncronizer::getSubscriptions(std::vector<AccountPublicAddress>& subscriptions) {
for (const auto& kv : m_consumers) {
kv.second->getSubscriptions(subscriptions);
}
}
2015-07-30 15:22:07 +00:00
ITransfersSubscription* TransfersSyncronizer::getSubscription(const AccountPublicAddress& acc) {
auto it = m_consumers.find(acc.viewPublicKey);
2015-12-09 13:19:03 +00:00
return (it == m_consumers.end()) ? nullptr : it->second->getSubscription(acc);
}
std::vector<Crypto::Hash> TransfersSyncronizer::getViewKeyKnownBlocks(const Crypto::PublicKey& publicViewKey) {
auto it = m_consumers.find(publicViewKey);
if (it == m_consumers.end()) {
throw std::invalid_argument("Consumer not found");
}
return m_sync.getConsumerKnownBlocks(*it->second);
}
void TransfersSyncronizer::onBlocksAdded(IBlockchainConsumer* consumer, const std::vector<Crypto::Hash>& blockHashes) {
auto it = findSubscriberForConsumer(consumer);
if (it != m_subscribers.end()) {
it->second->notify(&ITransfersSynchronizerObserver::onBlocksAdded, it->first, blockHashes);
}
}
void TransfersSyncronizer::onBlockchainDetach(IBlockchainConsumer* consumer, uint32_t blockIndex) {
auto it = findSubscriberForConsumer(consumer);
if (it != m_subscribers.end()) {
it->second->notify(&ITransfersSynchronizerObserver::onBlockchainDetach, it->first, blockIndex);
}
}
void TransfersSyncronizer::onTransactionDeleteBegin(IBlockchainConsumer* consumer, Crypto::Hash transactionHash) {
auto it = findSubscriberForConsumer(consumer);
if (it != m_subscribers.end()) {
it->second->notify(&ITransfersSynchronizerObserver::onTransactionDeleteBegin, it->first, transactionHash);
}
}
void TransfersSyncronizer::onTransactionDeleteEnd(IBlockchainConsumer* consumer, Crypto::Hash transactionHash) {
auto it = findSubscriberForConsumer(consumer);
if (it != m_subscribers.end()) {
it->second->notify(&ITransfersSynchronizerObserver::onTransactionDeleteEnd, it->first, transactionHash);
}
}
void TransfersSyncronizer::onTransactionUpdated(IBlockchainConsumer* consumer, const Crypto::Hash& transactionHash,
const std::vector<ITransfersContainer*>& containers) {
auto it = findSubscriberForConsumer(consumer);
if (it != m_subscribers.end()) {
it->second->notify(&ITransfersSynchronizerObserver::onTransactionUpdated, it->first, transactionHash, containers);
}
}
void TransfersSyncronizer::subscribeConsumerNotifications(const Crypto::PublicKey& viewPublicKey, ITransfersSynchronizerObserver* observer) {
auto it = m_subscribers.find(viewPublicKey);
if (it != m_subscribers.end()) {
it->second->add(observer);
return;
}
auto insertedIt = m_subscribers.emplace(viewPublicKey, std::unique_ptr<SubscribersNotifier>(new SubscribersNotifier())).first;
insertedIt->second->add(observer);
}
void TransfersSyncronizer::unsubscribeConsumerNotifications(const Crypto::PublicKey& viewPublicKey, ITransfersSynchronizerObserver* observer) {
m_subscribers.at(viewPublicKey)->remove(observer);
}
void TransfersSyncronizer::save(std::ostream& os) {
m_sync.save(os);
2015-07-30 15:22:07 +00:00
StdOutputStream stream(os);
CryptoNote::BinaryOutputStreamSerializer s(stream);
s(const_cast<uint32_t&>(TRANSFERS_STORAGE_ARCHIVE_VERSION), "version");
size_t subscriptionCount = m_consumers.size();
s.beginArray(subscriptionCount, "consumers");
for (const auto& consumer : m_consumers) {
s.beginObject("");
s(const_cast<PublicKey&>(consumer.first), "view_key");
std::stringstream consumerState;
// synchronization state
m_sync.getConsumerState(consumer.second.get())->save(consumerState);
std::string blob = consumerState.str();
s(blob, "state");
2015-07-30 15:22:07 +00:00
std::vector<AccountPublicAddress> subscriptions;
consumer.second->getSubscriptions(subscriptions);
size_t subCount = subscriptions.size();
s.beginArray(subCount, "subscriptions");
for (auto& addr : subscriptions) {
auto sub = consumer.second->getSubscription(addr);
if (sub != nullptr) {
s.beginObject("");
std::stringstream subState;
assert(sub);
sub->getContainer().save(subState);
// store data block
std::string blob = subState.str();
s(addr, "address");
s(blob, "state");
s.endObject();
}
}
s.endArray();
s.endObject();
}
}
namespace {
std::string getObjectState(IStreamSerializable& obj) {
std::stringstream stream;
obj.save(stream);
return stream.str();
}
void setObjectState(IStreamSerializable& obj, const std::string& state) {
std::stringstream stream(state);
obj.load(stream);
}
}
void TransfersSyncronizer::load(std::istream& is) {
m_sync.load(is);
2015-07-30 15:22:07 +00:00
StdInputStream inputStream(is);
CryptoNote::BinaryInputStreamSerializer s(inputStream);
uint32_t version = 0;
s(version, "version");
if (version > TRANSFERS_STORAGE_ARCHIVE_VERSION) {
throw std::runtime_error("TransfersSyncronizer version mismatch");
}
struct ConsumerState {
PublicKey viewKey;
std::string state;
2015-07-30 15:22:07 +00:00
std::vector<std::pair<AccountPublicAddress, std::string>> subscriptionStates;
};
std::vector<ConsumerState> updatedStates;
try {
size_t subscriptionCount = 0;
s.beginArray(subscriptionCount, "consumers");
while (subscriptionCount--) {
s.beginObject("");
PublicKey viewKey;
s(viewKey, "view_key");
std::string blob;
s(blob, "state");
auto subIter = m_consumers.find(viewKey);
if (subIter != m_consumers.end()) {
auto consumerState = m_sync.getConsumerState(subIter->second.get());
assert(consumerState);
{
// store previous state
auto prevConsumerState = getObjectState(*consumerState);
// load consumer state
setObjectState(*consumerState, blob);
updatedStates.push_back(ConsumerState{ viewKey, std::move(prevConsumerState) });
}
// load subscriptions
size_t subCount = 0;
s.beginArray(subCount, "subscriptions");
while (subCount--) {
s.beginObject("");
2015-07-30 15:22:07 +00:00
AccountPublicAddress acc;
std::string state;
s(acc, "address");
s(state, "state");
auto sub = subIter->second->getSubscription(acc);
if (sub != nullptr) {
auto prevState = getObjectState(sub->getContainer());
setObjectState(sub->getContainer(), state);
updatedStates.back().subscriptionStates.push_back(std::make_pair(acc, prevState));
}
s.endObject();
}
s.endArray();
}
}
s.endObject();
s.endArray();
} catch (...) {
// rollback state
for (const auto& consumerState : updatedStates) {
auto consumer = m_consumers.find(consumerState.viewKey)->second.get();
setObjectState(*m_sync.getConsumerState(consumer), consumerState.state);
for (const auto& sub : consumerState.subscriptionStates) {
setObjectState(consumer->getSubscription(sub.first)->getContainer(), sub.second);
}
}
throw;
}
}
2015-12-09 13:19:03 +00:00
bool TransfersSyncronizer::findViewKeyForConsumer(IBlockchainConsumer* consumer, Crypto::PublicKey& viewKey) const {
//since we have only couple of consumers linear complexity is fine
auto it = std::find_if(m_consumers.begin(), m_consumers.end(), [consumer] (const ConsumersContainer::value_type& subscription) {
return subscription.second.get() == consumer;
});
if (it == m_consumers.end()) {
return false;
}
viewKey = it->first;
return true;
}
TransfersSyncronizer::SubscribersContainer::const_iterator TransfersSyncronizer::findSubscriberForConsumer(IBlockchainConsumer* consumer) const {
Crypto::PublicKey viewKey;
if (findViewKeyForConsumer(consumer, viewKey)) {
auto it = m_subscribers.find(viewKey);
if (it != m_subscribers.end()) {
return it;
}
}
return m_subscribers.end();
}
}