invicnaper/MWF

///////////////////////////////////////////////////////////////////////////////
//                                                                             
//  Copyright (C) 2008-2012  Artyom Beilis (Tonkikh) <artyomtnk@yahoo.com>     
//                                                                             
//  See accompanying file COPYING.TXT file for licensing details.
//
///////////////////////////////////////////////////////////////////////////////
#include <cppcms/service.h>
#include <cppcms/application.h>
#include <cppcms/applications_pool.h>
#include <cppcms/http_request.h>
#include <cppcms/http_response.h>
#include <cppcms/http_context.h>
#include <cppcms/url_dispatcher.h>
#include <booster/aio/deadline_timer.h>
#include <booster/posix_time.h>
#include <cppcms/json.h>
#include <iostream>
#include "client.h"

class unit_test : public cppcms::application {
public:
    unit_test(cppcms::service &s) : 
        cppcms::application(s),
        timer_(s.get_io_service())
    {
        dispatcher().assign("/normal",&unit_test::normal,this);
        dispatcher().assign("/throws",&unit_test::throws,this);
        dispatcher().assign("/delayed",&unit_test::delayed,this);
        dispatcher().assign("/delayed_with_response",&unit_test::delayed_with_response,this);
        dispatcher().assign("/delayed_twice",&unit_test::delayed_twice,this);
    }
    void normal()
    {
    }
    void throws()
    {
        throw std::runtime_error("Error");
    }
    void delayed()
    {
        context_ = release_context();
        timer_.expires_from_now(booster::ptime::milliseconds(300));
        timer_.async_wait(binder(this,&unit_test::handle));
    }
    void handle()
    {
        context_->async_complete_response();
        context_.reset();
    }
    void delayed_with_response()
    {
        context_ = release_context();
        timer_.expires_from_now(booster::ptime::milliseconds(300));
        timer_.async_wait(binder(this,&unit_test::handle2));
    }
    void handle2()
    {
        context_->response().out()<<"test message";
        context_->async_complete_response();
        context_.reset();
    }
    void delayed_twice()
    {
        context_ = release_context();
        timer_.expires_from_now(booster::ptime::milliseconds(300));
        timer_.async_wait(binder(this,&unit_test::handle3));
    }
    void handle3()
    {
        context_->response().out()<<"message1";
        context_->async_flush_output(binder(this,&unit_test::handle35));
    }
    void handle35()
    {
        timer_.expires_from_now(booster::ptime::milliseconds(300));
        timer_.async_wait(binder(this,&unit_test::handle4));
    }
    void handle4()
    {
        context_->response().out()<<"message2";
        context_->async_complete_response();
        context_.reset();
    }
private:
    struct binder {
        binder(booster::intrusive_ptr<unit_test> ptr,void (unit_test::*member)()) : self(ptr),m(member)
        {
        }
        void operator()(cppcms::http::context::completion_type /*t*/) const
        {
            ((*self).*m)();
        }
        void operator()(booster::system::error_code const &/*e*/) const
        {
            ((*self).*m)();
        }
        booster::intrusive_ptr<unit_test> self;
        void (unit_test::*m)();
    };

    booster::aio::deadline_timer timer_;
    booster::shared_ptr<cppcms::http::context> context_;

};

int main(int argc,char **argv)
{
    try {
        cppcms::service srv(argc,argv);
        booster::intrusive_ptr<cppcms::application> app;
        if(srv.settings().get("test.async","sync")=="sync") {
            std::cerr << "Synchonous" << std::endl;
            srv.applications_pool().mount( cppcms::applications_factory<unit_test>());
        }
        else {
            std::cerr << "Asynchonous" << std::endl;
            app=new unit_test(srv);
            srv.applications_pool().mount(app);
        }
        srv.after_fork(submitter(srv));
        srv.run();
    }
    catch(std::exception const &e) {
        std::cerr << e.what() << std::endl;
        return EXIT_FAILURE;
    }
    return run_ok ? EXIT_SUCCESS : EXIT_FAILURE;
}