github.com/igggame/nebulas-go@v2.1.0+incompatible/nbre/core/neb_ipc/ipc_interface.cpp (about)

     1  // Copyright (C) 2018 go-nebulas authors
     2  //
     3  // This file is part of the go-nebulas library.
     4  //
     5  // the go-nebulas library is free software: you can redistribute it and/or
     6  // modify
     7  // it under the terms of the GNU General Public License as published by
     8  // the Free Software Foundation, either version 3 of the License, or
     9  // (at your option) any later version.
    10  //
    11  // the go-nebulas library is distributed in the hope that it will be useful,
    12  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    13  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    14  // GNU General Public License for more details.
    15  //
    16  // You should have received a copy of the GNU General Public License
    17  // along with the go-nebulas library.  If not, see
    18  // <http://www.gnu.org/licenses/>.
    19  //
    20  #include "core/neb_ipc/ipc_interface.h"
    21  #include "core/neb_ipc/server/ipc_callback_holder.h"
    22  #include "core/neb_ipc/server/ipc_server_endpoint.h"
    23  
    24  std::shared_ptr<neb::core::ipc_server_endpoint> _ipc;
    25  
    26  int start_nbre_ipc(const nbre_params_t params) {
    27    try {
    28      FLAGS_log_dir = params.m_nbre_log_dir;
    29      google::InitGoogleLogging("nbre-server");
    30  
    31      _ipc = std::make_shared<neb::core::ipc_server_endpoint>();
    32      LOG(INFO) << "ipc server construct";
    33      _ipc->init_params(params);
    34  
    35      if (_ipc->start()) {
    36        LOG(INFO) << "start nbre succ";
    37        return ipc_status_succ;
    38      } else {
    39        LOG(ERROR) << "start nbre failed";
    40        return ipc_status_fail;
    41      }
    42    } catch (const std::exception &e) {
    43      LOG(ERROR) << "start nbre got exception " << typeid(e).name() << ":"
    44                 << e.what();
    45      return ipc_status_exception;
    46    } catch (...) {
    47      LOG(ERROR) << "start nbre got unknown exception ";
    48      return ipc_status_exception;
    49    }
    50  }
    51  
    52  void nbre_ipc_shutdown() {
    53    _ipc->shutdown();
    54    _ipc.reset();
    55  }
    56  
    57  void set_recv_nbre_version_callback(nbre_version_callback_t func) {
    58    neb::core::ipc_callback_holder::instance().m_nbre_version_callback = func;
    59  }
    60  
    61  int ipc_nbre_version(void *holder, uint64_t height) {
    62    return _ipc->send_nbre_version_req(holder, height);
    63  }
    64  
    65  void set_recv_nbre_ir_list_callback(nbre_ir_list_callback_t func) {
    66    neb::core::ipc_callback_holder::instance().m_nbre_ir_list_callback = func;
    67  }
    68  
    69  int ipc_nbre_ir_list(void *holder) {
    70    return _ipc->send_nbre_ir_list_req(holder);
    71  }
    72  
    73  void set_recv_nbre_ir_versions_callback(nbre_ir_versions_callback_t func) {
    74    neb::core::ipc_callback_holder::instance().m_nbre_ir_versions_callback = func;
    75  }
    76  
    77  int ipc_nbre_ir_versions(void *holder, const char *ir_name) {
    78    return _ipc->send_nbre_ir_versions_req(holder, ir_name);
    79  }
    80  
    81  void set_recv_nbre_nr_handler_callback(nbre_nr_handler_callback_t func) {
    82    neb::core::ipc_callback_holder::instance().m_nbre_nr_handler_callback = func;
    83  }
    84  
    85  int ipc_nbre_nr_handler(void *holder, uint64_t start_block, uint64_t end_block,
    86                          uint64_t nr_version) {
    87    return _ipc->send_nbre_nr_handler_req(holder, start_block, end_block,
    88                                          nr_version);
    89  }
    90  
    91  void set_recv_nbre_nr_result_callback(nbre_nr_result_callback_t func) {
    92    neb::core::ipc_callback_holder::instance().m_nbre_nr_result_callback = func;
    93  }
    94  
    95  int ipc_nbre_nr_result(void *holder, const char *nr_handler) {
    96    return _ipc->send_nbre_nr_result_req(holder, nr_handler);
    97  }
    98  
    99  void set_recv_nbre_dip_reward_callback(nbre_dip_reward_callback_t func) {
   100    neb::core::ipc_callback_holder::instance().m_nbre_dip_reward_callback = func;
   101  }
   102  
   103  int ipc_nbre_dip_reward(void *holder, uint64_t height, uint64_t version) {
   104    return _ipc->send_nbre_dip_reward_req(holder, height);
   105  }