service_main.h

Go to the documentation of this file.

/*
 * Copyright 2006-2008 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>
SSRC_UNIQUE_PTR<service_type> new_service(const options_type & options) {
  return SSRC_UNIQUE_PTR<service_type>(new service_type(options.connection,
                                           options.name,
                                           options.capacity));
}

template<typename service_type, typename options_type, typename init_type>
SSRC_UNIQUE_PTR<service_type> new_service(const options_type & options,
                                        const init_type & initializer)
{
  return SSRC_UNIQUE_PTR<service_type>(new 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 SSRC_UNIQUE_PTR<service_type> service_ptr;
  SSRC_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 SSRC_UNIQUE_PTR<service_type> service_ptr;
  SSRC_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> 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 boost::scoped_ptr<Options> options_ptr;
  typedef boost::scoped_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);

  string service_name;

  try {
    options_processor_ptr options_processor(new CustomOptionsProcessor);
    options_ptr options(new Options(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