LCOV - code coverage report
Current view: top level - irohad/main/impl - consensus_init.cpp (source / functions) Hit Total Coverage
Test: coverage_cleared.info Lines: 31 33 93.9 %
Date: 2018-12-05 17:11:35 Functions: 12 12 100.0 %

          Line data    Source code
       1             : /**
       2             :  * Copyright Soramitsu Co., Ltd. 2018 All Rights Reserved.
       3             :  * http://soramitsu.co.jp
       4             :  *
       5             :  * Licensed under the Apache License, Version 2.0 (the "License");
       6             :  * you may not use this file except in compliance with the License.
       7             :  * You may obtain a copy of the License at
       8             :  *
       9             :  *        http://www.apache.org/licenses/LICENSE-2.0
      10             :  *
      11             :  * Unless required by applicable law or agreed to in writing, software
      12             :  * distributed under the License is distributed on an "AS IS" BASIS,
      13             :  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      14             :  * See the License for the specific language governing permissions and
      15             :  * limitations under the License.
      16             :  */
      17             : 
      18             : #include "main/impl/consensus_init.hpp"
      19             : #include "consensus/yac/impl/peer_orderer_impl.hpp"
      20             : #include "consensus/yac/impl/timer_impl.hpp"
      21             : #include "consensus/yac/impl/yac_crypto_provider_impl.hpp"
      22             : #include "consensus/yac/impl/yac_gate_impl.hpp"
      23             : #include "consensus/yac/impl/yac_hash_provider_impl.hpp"
      24             : #include "consensus/yac/storage/yac_proposal_storage.hpp"
      25             : #include "consensus/yac/transport/impl/network_impl.hpp"
      26             : 
      27             : namespace iroha {
      28             :   namespace consensus {
      29             :     namespace yac {
      30             : 
      31             :       auto YacInit::createPeerOrderer(
      32             :           std::shared_ptr<ametsuchi::PeerQueryFactory> peer_query_factory) {
      33         245 :         return std::make_shared<PeerOrdererImpl>(peer_query_factory);
      34             :       }
      35             : 
      36             :       auto YacInit::createNetwork(
      37             :           std::shared_ptr<
      38             :               iroha::network::AsyncGrpcClient<google::protobuf::Empty>>
      39             :               async_call) {
      40         245 :         consensus_network = std::make_shared<NetworkImpl>(async_call);
      41         245 :         return consensus_network;
      42             :       }
      43             : 
      44             :       auto YacInit::createCryptoProvider(
      45             :           const shared_model::crypto::Keypair &keypair,
      46             :           std::shared_ptr<shared_model::interface::CommonObjectsFactory>
      47             :               common_objects_factory) {
      48         245 :         auto crypto = std::make_shared<CryptoProviderImpl>(
      49         245 :             keypair, std::move(common_objects_factory));
      50             : 
      51         245 :         return crypto;
      52         245 :       }
      53             : 
      54             :       auto YacInit::createTimer(std::chrono::milliseconds delay_milliseconds) {
      55             :         return std::make_shared<TimerImpl>([delay_milliseconds] {
      56             :           // static factory with a single thread
      57             :           //
      58             :           // observe_on_new_thread -- coordination which creates new thread with
      59             :           // observe_on strategy -- all subsequent operations will be performed
      60             :           // on this thread.
      61             :           //
      62             :           // scheduler owns a timeline that is exposed by the now() method.
      63             :           // scheduler is also a factory for workers in that timeline.
      64             :           //
      65             :           // coordination is a factory for coordinators and has a scheduler.
      66             :           //
      67             :           // coordinator has a worker, and is a factory for coordinated
      68             :           // observables, subscribers and schedulable functions.
      69             :           //
      70             :           // A new thread scheduler is created
      71             :           // by calling .create_coordinator().get_scheduler()
      72             :           //
      73             :           // static allows to reuse the same thread in subsequent calls to this
      74             :           // lambda
      75           2 :           static rxcpp::observe_on_one_worker coordination(
      76           1 :               rxcpp::observe_on_new_thread()
      77           1 :                   .create_coordinator()
      78           1 :                   .get_scheduler());
      79           2 :           return rxcpp::observable<>::timer(
      80           2 :               std::chrono::milliseconds(delay_milliseconds), coordination);
      81           0 :         });
      82             :       }
      83             : 
      84             :       auto YacInit::createHashProvider() {
      85         245 :         return std::make_shared<YacHashProviderImpl>();
      86             :       }
      87             : 
      88             :       std::shared_ptr<consensus::yac::Yac> YacInit::createYac(
      89             :           ClusterOrdering initial_order,
      90             :           const shared_model::crypto::Keypair &keypair,
      91             :           std::chrono::milliseconds delay_milliseconds,
      92             :           std::shared_ptr<
      93             :               iroha::network::AsyncGrpcClient<google::protobuf::Empty>>
      94             :               async_call,
      95             :           std::shared_ptr<shared_model::interface::CommonObjectsFactory>
      96             :               common_objects_factory) {
      97         245 :         return Yac::create(
      98         245 :             YacVoteStorage(),
      99         245 :             createNetwork(std::move(async_call)),
     100         245 :             createCryptoProvider(keypair, std::move(common_objects_factory)),
     101         245 :             createTimer(delay_milliseconds),
     102             :             initial_order);
     103           0 :       }
     104             : 
     105             :       std::shared_ptr<YacGate> YacInit::initConsensusGate(
     106             :           std::shared_ptr<ametsuchi::PeerQueryFactory> peer_query_factory,
     107             :           std::shared_ptr<simulator::BlockCreator> block_creator,
     108             :           std::shared_ptr<network::BlockLoader> block_loader,
     109             :           const shared_model::crypto::Keypair &keypair,
     110             :           std::shared_ptr<consensus::ConsensusResultCache>
     111             :               consensus_result_cache,
     112             :           std::chrono::milliseconds vote_delay_milliseconds,
     113             :           std::shared_ptr<
     114             :               iroha::network::AsyncGrpcClient<google::protobuf::Empty>>
     115             :               async_call,
     116             :           std::shared_ptr<shared_model::interface::CommonObjectsFactory>
     117             :               common_objects_factory) {
     118         245 :         auto peer_orderer = createPeerOrderer(peer_query_factory);
     119             : 
     120         245 :         auto yac = createYac(peer_orderer->getInitialOrdering().value(),
     121         245 :                              keypair,
     122         245 :                              vote_delay_milliseconds,
     123         245 :                              std::move(async_call),
     124         245 :                              std::move(common_objects_factory));
     125         245 :         consensus_network->subscribe(yac);
     126             : 
     127         245 :         auto hash_provider = createHashProvider();
     128         245 :         return std::make_shared<YacGateImpl>(std::move(yac),
     129         245 :                                              std::move(peer_orderer),
     130             :                                              hash_provider,
     131             :                                              block_creator,
     132             :                                              block_loader,
     133         245 :                                              std::move(consensus_result_cache));
     134         245 :       }
     135             :     }  // namespace yac
     136             :   }    // namespace consensus
     137             : }  // namespace iroha

Generated by: LCOV version 1.13