Scale Stack 0.3 Developer Documentation

scalestack/event/handler_service.cc

Go to the documentation of this file.

/*
 * Scale Stack
 *
 * Copyright 2010 Eric Day
 *
 * 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.
 */

#include "config.h"

#include <algorithm>
#include <cerrno>
#include <cstring>
#include <exception>
#include <functional>
#include <unistd.h>

#include <scalestack/event/handler.h>
#include <scalestack/event/handler_service.h>
#include <scalestack/kernel/core.h>
#include <scalestack/kernel/module.h>

using namespace std;

namespace scalestack
{
namespace event
{

/*
 * Public methods.
 */

handler_service::handler_service(kernel::module& module):
  kernel::service(module),
  _stop(false),
  _handler_count(),
  _service(static_cast<event::service&>(
    module.get_core().get_service("event"))),
  _pipe(),
  _handler_mutex(module),
  _handlers()
{
  if (pipe(_pipe) == -1)
    _module.log_fatal(_("Failed pipe: %s:%d"), strerror(errno), errno);
}

handler_service::~handler_service()
{
  stop();
  close(_pipe[0]);
  close(_pipe[1]);
}

void handler_service::stop(void)
{
  _stop = true;
  _handler_mutex.lock();
  for_each(_handlers.begin(), _handlers.end(), mem_fun(&handler::shutdown));

  char buffer[1024];
  while (_handler_count > 0)
  {
    _handler_mutex.unlock();

    if (read(_pipe[0], buffer, sizeof(buffer)) == -1 && errno != EINTR)
      _module.log_fatal(_("Failed pipe read: %s:%d"), strerror(errno), errno);

    _handler_mutex.lock();
  }

  _handler_mutex.unlock();
}

/*
 * Private methods.
 */

void handler_service::_start_handler(handler* handler)
{
  _handler_mutex.lock();
  try
  {
    handler->_start();
    _handlers.insert(handler);
    ++_handler_count;
    if (_stop)
      handler->shutdown();
  }
  catch (exception&)
  {
    _handler_mutex.unlock();
    throw;
  }
  _handler_mutex.unlock();
}

void handler_service::_stop_handler(handler* handler)
{
  _handler_mutex.lock();
  _handlers.erase(handler);
  _handler_mutex.unlock();

  delete handler;
  _handler_mutex.lock();
  --_handler_count;

  if (_stop)
  {
    if (write(_pipe[1], "\0", 1) == -1 && errno != EINTR)
    {
      _handler_mutex.unlock();
      _module.log_fatal(_("Failed pipe write: %s:%d"), strerror(errno), errno);
    }
  }
  _handler_mutex.unlock();
}

} /* namespace event */
} /* namespace scalestack */

---