Scale Stack 0.3 Developer Documentation

scalestack/event/test/handler.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 <cassert>
#include <cerrno>
#include <cstring>
#include <unistd.h>

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

namespace scalestack
{
namespace event
{
namespace test
{

/*
 * Public methods.
 */

handler::handler(test& test, handler::state fatal):
  event::handler(test._handler_service),
  _state(),
  _fatal(fatal),
  _close_count(),
  _test(test),
  _pipe()
{
  if (pipe(_pipe) == -1)
    _module.log_fatal(_("Failed pipe: %s:%d"), strerror(errno), errno);
  start();
}

handler::~handler()
{
  close(_pipe[0]);
  close(_pipe[1]);
  assert(_state = _fatal);
  _test.remove_handler();

  if (_state == STATE_DONE)
    assert(_close_count == 4);
}

void handler::started(void)
{
  _state = STATE_START;
  if (_fatal == STATE_START)
    _module.log_fatal("Fatal start");

  if (_fatal == STATE_TIMER)
  {
    set_timer(1);
    usleep(2000);
  }
  else
    set_timer(100);
}

void handler::timer_expired(void)
{
  _state = STATE_TIMER;
  if (_fatal == STATE_TIMER)
    _module.log_fatal("Fatal timer");

  set_timer(1);
  set_timer(0);

  int test_pipe[2];
  if (pipe(test_pipe) == -1)
    _module.log_fatal(_("Failed pipe: %s:%d"), strerror(errno), errno);

  set_file_descriptor(test_pipe[0]);
  set_file_descriptor(test_pipe[1]);
  close(test_pipe[0]);
  close(test_pipe[1]);
  
  set_file_descriptor(_pipe[1]);
  watch_write();
}

void handler::close_file_descriptor(int)
{
  _close_count++;
}

void handler::read_ready(int)
{
  _state = STATE_READ;
  if (_fatal == STATE_READ)
    _module.log_fatal("Fatal read");
  char buffer[1024];
  if (read(_pipe[0], buffer, sizeof(buffer)) == -1 && errno != EINTR)
    _module.log_fatal(_("Failed pipe read: %s:%d"), strerror(errno), errno);
  run_now();
}

void handler::write_ready(int)
{
  _state = STATE_WRITE;
  if (_fatal == STATE_WRITE)
    _module.log_fatal("Fatal write");
  if (write(_pipe[1], "\0", 1) == -1 && errno != EINTR)
    _module.log_fatal(_("Failed pipe write: %s:%d"), strerror(errno), errno);
  set_file_descriptor(_pipe[0]);
  watch_read();
}

void handler::run(void)
{
  _state = STATE_RUN;
  if (_fatal == STATE_RUN)
    _module.log_fatal("Fatal run");
  shutdown();
  _state = STATE_DONE;
}

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

---