service_main.h

Go to the documentation of this file.

  /* Copyright 2006-2013 Savarese Software Research Corporation
   *
   * 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.savarese.com/software/ApacheLicense-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.
   */
  
  #ifndef __SSRC_WISP_UTILITY_SERVICE_MAIN_H
  #define __SSRC_WISP_UTILITY_SERVICE_MAIN_H
  
  #include <ssrc/wisp/service.h>
  #include <ssrc/wisp/utility/ServiceOptions.h>
  #include <ssrc/wisp/utility/ServiceMainOptions.h>
  
  #include <iostream>
  
  __BEGIN_NS_SSRC_WISP_UTILITY
  
  template<typename service_type, typename options_type>
  std::unique_ptr<service_type> new_service(const options_type & options) {
   return std::make_unique<service_type>(options.connection,
   options.name,
   options.capacity);
  }
  
  template<typename service_type, typename options_type, typename init_type>
  std::unique_ptr<service_type> new_service(const options_type & options,
   const init_type & initializer)
  {
   return std::make_unique<service_type>(initializer,
   options.connection,
   options.name,
   options.capacity);
  }
  
  template<typename service_type, typename options_type, bool has_initializer>
  struct ServiceFactory;
  
  template<typename service_type, typename options_type>
  struct ServiceFactory<service_type, options_type, false> {
   typedef std::unique_ptr<service_type> service_ptr;
   std::unique_ptr<service_type> operator()(const options_type & options) {
   return new_service<service_type>(options);
   }
  };
  
  template<typename service_type, typename options_type>
  struct ServiceFactory<service_type, options_type, true> {
   typedef std::unique_ptr<service_type> service_ptr;
   std::unique_ptr<service_type> operator()(const options_type & options) {
   return new_service<service_type>(options, options.initializer);
   }
  };
  
  struct ServiceMainOptionsProcessor {
   template<typename CustomOptions>
   static int process_options(const CustomOptions & options) {
   if(options.help) {
   std::cout << options.description << std::endl;
   return 0;
   } else if(options.wisp_version) {
   std::cout << "Wisp version: " << WISP_VERSION << std::endl;
   return 0;
   } else if(options.arg_error) {
   std::cerr << "Service option error: " << options.arg_error_msg
   << std::endl;
   return 1;
   }
  
   if(options.connection.empty()) {
   std::cerr << "Service error: You must specify a connection.\n";
   return 1;
   }
  
   if(options.locale.size() > 0)
   std::locale::global(std::locale(std::locale::classic(),
   options.locale.c_str(),
   std::locale::ctype));
   return -1;
   }
  };
  
  template<typename ProtocolProcessor,
   template <typename PP, typename...> class EH,
   typename CustomOptions,
   typename CustomOptionsProcessor,
   bool has_initializer>
  int service_main(int argc, char *argv[]) {
   using namespace NS_SSRC_WISP;
   using namespace NS_SSRC_WISP_SERVICE;
   using NS_SSRC_WISP_UTILITY::ServiceOptions;
  
   typedef ServiceOptions<CustomOptions> Options;
   typedef std::unique_ptr<Options> options_ptr;
   typedef std::unique_ptr<CustomOptionsProcessor> options_processor_ptr;
   typedef Service<EH<ProtocolProcessor> > service_type;
   typedef
   ServiceFactory<service_type, Options, has_initializer> service_factory;
  
   WISP_IMPORT_T(ProtocolProcessor, packing_traits);
  
   std::string service_name;
  
   try {
   options_processor_ptr options_processor(make_smart_ptr<options_processor_ptr>());
   options_ptr options(make_smart_ptr<options_ptr>(argc, argv));
   int exit_code = options_processor->process_options(*options);
  
   if(exit_code != -1) {
   return exit_code;
   } else {
   service_factory new_service;
   typename service_factory::service_ptr service = new_service(*options);
   EventLoop loop;
   service_name = service->name();
   service->start(loop, options->call_timeout);
   // Free extra memory used by options and options_processor.
   options.reset();
   options_processor.reset();
   loop.start();
   }
   } catch(const NS_SSRC_SPREAD::Error & spread_error) {
   std::cerr << "Service error: " << service_name
   << " : Caught ssrc::spread::Error\n";
   spread_error.print();
   return 1;
   } catch(const std::exception & std_error) {
   std::cerr << "Service error: " << service_name << " : "
   << std_error.what() << std::endl;
   return 1;
   } catch(...) {
   std::cerr << "Service error: " << service_name
   << " : Caught unknown exception!\n";
   throw;
   }
  
   return 0;
  }
  
  #define WISP_EMPTY_INIT_CODE
  
  #define WISP_CUSTOM_SERVICE_MAIN_WITH_INIT(service_type, handler_type, options_type, options_processor_type, has_initializer, init_code) \
  int main(int argc, char *argv[]) { \
   init_code \
   return NS_SSRC_WISP_UTILITY::service_main<service_type, handler_type, options_type, options_processor_type, has_initializer>(argc, argv); \
  }
  
  #define WISP_CUSTOM_SERVICE_MAIN(service_type, handler_type, options_type, options_processor_type, has_initializer) \
   WISP_CUSTOM_SERVICE_MAIN_WITH_INIT(service_type, handler_type, options_type, options_processor_type, has_initializer, WISP_EMPTY_INIT_CODE)
  
  #define WISP_SERVICE_MAIN_WITH_INIT(service_type, init_code) \
   WISP_CUSTOM_SERVICE_MAIN_WITH_INIT(service_type, \
   NS_SSRC_WISP_SERVICE::ServiceEventHandler, \
   NS_SSRC_WISP_UTILITY::ServiceMainOptions, \
   NS_SSRC_WISP_UTILITY::ServiceMainOptionsProcessor, \
   false, init_code)
  
  #define WISP_SERVICE_MAIN(service_type) \
   WISP_SERVICE_MAIN_WITH_INIT(service_type, WISP_EMPTY_INIT_CODE)
  
  __END_NS_SSRC_WISP_UTILITY
  
  #endif