Fix Protocol and Interface Validators (#1879)

Signed-off-by: Akvinikym <[email protected]>

Author: Akvinikym

irohad/main/application.cpp

@@ -28,8 +28,9 @@
 #include "multi_sig_transactions/transport/mst_transport_stub.hpp"
 #include "torii/impl/command_service_impl.hpp"
 #include "torii/impl/status_bus_impl.hpp"
-#include "validators/default_proto_validator.hpp"
 #include "validators/field_validator.hpp"
+#include "validators/protobuf/proto_query_validator.hpp"
+#include "validators/protobuf/proto_transaction_validator.hpp"
 
 using namespace iroha;
 using namespace iroha::ametsuchi;
@@ -192,21 +193,43 @@ void Irohad::initNetworkClient() {
 }
 
 void Irohad::initFactories() {
+  // transaction factories
   transaction_batch_factory_ =
       std::make_shared<shared_model::interface::TransactionBatchFactoryImpl>();
+
   std::unique_ptr<shared_model::validation::AbstractValidator<
       shared_model::interface::Transaction>>
-      transaction_validator = std::make_unique<
-          shared_model::validation::
-              DefaultOptionalSignedProtoTransactionValidator>();
+      transaction_validator =
+          std::make_unique<shared_model::validation::
+                               DefaultOptionalSignedTransactionValidator>();
+  std::unique_ptr<
+      shared_model::validation::AbstractValidator<iroha::protocol::Transaction>>
+      proto_transaction_validator = std::make_unique<
+          shared_model::validation::ProtoTransactionValidator>();
   transaction_factory =
       std::make_shared<shared_model::proto::ProtoTransportFactory<
           shared_model::interface::Transaction,
-          shared_model::proto::Transaction>>(std::move(transaction_validator));
+          shared_model::proto::Transaction>>(
+          std::move(transaction_validator),
+          std::move(proto_transaction_validator));
 
+  // query factories
   query_response_factory_ =
       std::make_shared<shared_model::proto::ProtoQueryResponseFactory>();
 
+  std::unique_ptr<shared_model::validation::AbstractValidator<
+      shared_model::interface::Query>>
+      query_validator = std::make_unique<
+          shared_model::validation::DefaultSignedQueryValidator>();
+  std::unique_ptr<
+      shared_model::validation::AbstractValidator<iroha::protocol::Query>>
+      proto_query_validator =
+          std::make_unique<shared_model::validation::ProtoQueryValidator>();
+  query_factory = std::make_shared<
+      shared_model::proto::ProtoTransportFactory<shared_model::interface::Query,
+                                                 shared_model::proto::Query>>(
+      std::move(query_validator), std::move(proto_query_validator));
+
   log_->info("[Init] => factories");
 }
 
@@ -382,7 +405,8 @@ void Irohad::initQueryService() {
   auto query_processor = std::make_shared<QueryProcessorImpl>(
       storage, storage, pending_txs_storage_, query_response_factory_);
 
-  query_service = std::make_shared<::torii::QueryService>(query_processor);
+  query_service =
+      std::make_shared<::torii::QueryService>(query_processor, query_factory);
 
   log_->info("[Init] => query service");
 }

irohad/main/application.hpp

@@ -49,7 +49,6 @@ namespace iroha {
 
 class Irohad {
  public:
-
   using RunResult = iroha::expected::Result<void, std::string>;
 
   /**
@@ -65,8 +64,8 @@ class Irohad {
    * @param proposal_delay - maximum waiting time util emitting new proposal
    * @param vote_delay - waiting time before sending vote to next peer
    * @param keypair - public and private keys for crypto signer
-   * @param opt_mst_gossip_params - parameters for Gossip MST propagation (optional).
-   * If not provided, disables mst processing support
+   * @param opt_mst_gossip_params - parameters for Gossip MST propagation
+   * (optional). If not provided, disables mst processing support
    *
    * TODO mboldyrev 03.11.2018 IR-1844 Refactor the constructor.
    */
@@ -223,6 +222,12 @@ class Irohad {
       iroha::protocol::Transaction>>
       transaction_factory;
 
+  // query factory
+  std::shared_ptr<shared_model::interface::AbstractTransportFactory<
+      shared_model::interface::Query,
+      iroha::protocol::Query>>
+      query_factory;
+
   // query response factory
   std::shared_ptr<shared_model::interface::QueryResponseFactory>
       query_response_factory_;

irohad/torii/impl/query_service.cpp

@@ -4,16 +4,21 @@
  */
 
 #include "torii/query_service.hpp"
+
 #include "backend/protobuf/query_responses/proto_block_query_response.hpp"
 #include "backend/protobuf/query_responses/proto_query_response.hpp"
 #include "cryptography/default_hash_provider.hpp"
+#include "interfaces/iroha_internal/abstract_transport_factory.hpp"
 #include "validators/default_validator.hpp"
 
 namespace torii {
 
   QueryService::QueryService(
-      std::shared_ptr<iroha::torii::QueryProcessor> query_processor)
-      : query_processor_(query_processor), log_(logger::log("Query Service")) {}
+      std::shared_ptr<iroha::torii::QueryProcessor> query_processor,
+      std::shared_ptr<QueryFactoryType> query_factory)
+      : query_processor_{std::move(query_processor)},
+        query_factory_{std::move(query_factory)},
+        log_{logger::log("Query Service")} {}
 
   void QueryService::Find(iroha::protocol::Query const &request,
                           iroha::protocol::QueryResponse &response) {
@@ -28,30 +33,24 @@ namespace torii {
       return;
     }
 
-    shared_model::proto::TransportBuilder<
-        shared_model::proto::Query,
-        shared_model::validation::DefaultSignedQueryValidator>()
-        .build(request)
-        .match(
-            [this, &hash, &response](
-                const iroha::expected::Value<shared_model::proto::Query>
-                    &query) {
-              // Send query to iroha
-              auto result_response =
-                  static_cast<shared_model::proto::QueryResponse &>(
-                      *query_processor_->queryHandle(query.value))
-                      .getTransport();
-              response.CopyFrom(result_response);
-              cache_.addItem(hash, response);
-            },
-            [&hash,
-             &response](const iroha::expected::Error<std::string> &error) {
-              response.set_query_hash(hash.hex());
-              response.mutable_error_response()->set_reason(
-                  iroha::protocol::ErrorResponse::STATELESS_INVALID);
-              response.mutable_error_response()->set_message(
-                  std::move(error.error));
-            });
+    query_factory_->build(request).match(
+        [this, &hash, &response](
+            const iroha::expected::Value<
+                std::unique_ptr<shared_model::interface::Query>> &query) {
+          // Send query to iroha
+          response = static_cast<shared_model::proto::QueryResponse &>(
+                         *query_processor_->queryHandle(*query.value))
+                         .getTransport();
+          cache_.addItem(hash, response);
+        },
+        [&hash, &response](
+            const iroha::expected::Error<QueryFactoryType::Error> &error) {
+          response.set_query_hash(hash.hex());
+          response.mutable_error_response()->set_reason(
+              iroha::protocol::ErrorResponse::STATELESS_INVALID);
+          response.mutable_error_response()->set_message(
+              std::move(error.error.error));
+        });
   }
 
   grpc::Status QueryService::Find(grpc::ServerContext *context,

irohad/torii/query_service.hpp

@@ -1,18 +1,7 @@
-/*
-Copyright 2017 Soramitsu Co., Ltd.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
 
 #ifndef TORII_QUERY_SERVICE_HPP
 #define TORII_QUERY_SERVICE_HPP
@@ -30,6 +19,13 @@ limitations under the License.
 
 #include "logger/logger.hpp"
 
+namespace shared_model {
+  namespace interface {
+    template <typename Interface, typename Transport>
+    class AbstractTransportFactory;
+  }
+}  // namespace shared_model
+
 namespace torii {
   /**
    * Actual implementation of async QueryService.
@@ -38,7 +34,13 @@ namespace torii {
    */
   class QueryService : public iroha::protocol::QueryService::Service {
    public:
-    QueryService(std::shared_ptr<iroha::torii::QueryProcessor> query_processor);
+    using QueryFactoryType =
+        shared_model::interface::AbstractTransportFactory<
+            shared_model::interface::Query,
+            iroha::protocol::Query>;
+
+    QueryService(std::shared_ptr<iroha::torii::QueryProcessor> query_processor,
+                 std::shared_ptr<QueryFactoryType> query_factory);
 
     QueryService(const QueryService &) = delete;
     QueryService &operator=(const QueryService &) = delete;
@@ -63,6 +65,7 @@ namespace torii {
 
    private:
     std::shared_ptr<iroha::torii::QueryProcessor> query_processor_;
+    std::shared_ptr<QueryFactoryType> query_factory_;
 
     iroha::cache::Cache<shared_model::crypto::Hash,
                         iroha::protocol::QueryResponse,

shared_model/backend/protobuf/proto_transport_factory.hpp

@@ -8,6 +8,8 @@
 
 #include "interfaces/iroha_internal/abstract_transport_factory.hpp"
 
+#include "backend/protobuf/util.hpp"
+#include "cryptography/hash_providers/sha3_256.hpp"
 #include "validators/abstract_validator.hpp"
 
 namespace shared_model {
@@ -23,23 +25,37 @@ namespace shared_model {
           typename Proto::TransportType>::Error;
       using ValidatorType = std::unique_ptr<
           shared_model::validation::AbstractValidator<Interface>>;
+      using ProtoValidatorType =
+          std::unique_ptr<shared_model::validation::AbstractValidator<
+              typename Proto::TransportType>>;
 
-      explicit ProtoTransportFactory(ValidatorType validator)
-          : validator_(std::move(validator)) {}
+      ProtoTransportFactory(ValidatorType interface_validator,
+                            ProtoValidatorType proto_validator)
+          : interface_validator_(std::move(interface_validator)),
+            proto_validator_{std::move(proto_validator)} {}
 
       iroha::expected::Result<std::unique_ptr<Interface>, Error> build(
           typename Proto::TransportType m) const override {
+        if (auto answer = proto_validator_->validate(m)) {
+          return iroha::expected::makeError(Error{
+              HashProvider::makeHash(makeBlob(m.payload())), answer.reason()});
+        }
+
         std::unique_ptr<Interface> result =
             std::make_unique<Proto>(std::move(m));
-        if (auto answer = validator_->validate(*result)) {
+        if (auto answer = interface_validator_->validate(*result)) {
           return iroha::expected::makeError(
               Error{result->hash(), answer.reason()});
         }
+
         return iroha::expected::makeValue(std::move(result));
       }
 
      private:
-      ValidatorType validator_;
+      using HashProvider = shared_model::crypto::Sha3_256;
+
+      ValidatorType interface_validator_;
+      ProtoValidatorType proto_validator_;
     };
 
   }  // namespace proto

shared_model/validators/default_proto_validator.hpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef IROHA_PROTO_QUERY_VALIDATOR_HPP
+#define IROHA_PROTO_QUERY_VALIDATOR_HPP
+
+#include "validators/abstract_validator.hpp"
+
+#include "queries.pb.h"
+
+namespace shared_model {
+  namespace validation {
+
+    class ProtoQueryValidator
+        : public AbstractValidator<iroha::protocol::Query> {
+     private:
+      Answer validateProtoQuery(const iroha::protocol::Query &qry) const {
+        Answer answer;
+        if (qry.payload().query_case()
+            == iroha::protocol::Query_Payload::QUERY_NOT_SET) {
+          ReasonsGroupType reason;
+          reason.first = "Undefined";
+          reason.second.emplace_back("query is undefined");
+          answer.addReason(std::move(reason));
+        }
+        return answer;
+      }
+
+     public:
+      Answer validate(const iroha::protocol::Query &query) const override {
+        return validateProtoQuery(query);
+      }
+    };
+
+  }  // namespace validation
+}  // namespace shared_model
+
+#endif  // IROHA_PROTO_QUERY_VALIDATOR_HPP

shared_model/validators/protobuf/proto_query_validator.hpp

@@ -6,16 +6,15 @@
 #ifndef IROHA_PROTO_TRANSACTION_VALIDATOR_HPP
 #define IROHA_PROTO_TRANSACTION_VALIDATOR_HPP
 
-#include "validators/transaction_validator.hpp"
+#include "validators/abstract_validator.hpp"
 
-#include "backend/protobuf/transaction.hpp"
+#include "transaction.pb.h"
 
 namespace shared_model {
   namespace validation {
 
-    template <typename FieldValidator, typename CommandValidator>
     class ProtoTransactionValidator
-        : public TransactionValidator<FieldValidator, CommandValidator> {
+        : public AbstractValidator<iroha::protocol::Transaction> {
      private:
       Answer validateProtoTx(
           const iroha::protocol::Transaction &transaction) const {
@@ -70,18 +69,8 @@ namespace shared_model {
       }
 
      public:
-      using TransactionValidator<FieldValidator,
-                                 CommandValidator>::TransactionValidator;
-      Answer validate(const interface::Transaction &tx) const override {
-        // validate proto-backend of transaction
-        auto proto_validation_answer = validateProtoTx(
-            static_cast<const proto::Transaction &>(tx).getTransport());
-        if (proto_validation_answer.hasErrors()) {
-          return proto_validation_answer;
-        }
-
-        return TransactionValidator<FieldValidator, CommandValidator>::validate(
-            tx);
+      Answer validate(const iroha::protocol::Transaction &tx) const override {
+        return validateProtoTx(tx);
       };
     };
   }  // namespace validation