WebExpositorBundle.cpp

Go to the documentation of this file.

/** @file    WebExpositorBundle.cpp
 *  @author  Alessandro Polo
 *  @version $Id: WebExpositorBundle.cpp 3775 2011-01-01 16:38:17Z alex $
 *  @brief
 * File containing methods for the wosh::bundles::WebExpositorBundle class.
 * The header for this class can be found in WebExpositorBundle.h, check that file
 * for class description.
 ****************************************************************************/
/* Copyright (c) 2007-2011, WOSH - Wide Open Smart Home 
 * by Alessandro Polo - OpenSmartHome.com
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the OpenSmartHome.com WOSH nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY Alessandro Polo ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL Alessandro Polo BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ****************************************************************************/

 #include "WebExpositorBundle.h"
 #include <core/ObjectFactory.h>
 #include <core/PersistenceManager.h>
 #include <core/BusManager.h>
 #include <core/FileSystem.h>
 #include <core/WoshKernel.h>
 #include <core/MethodsCommon.h>
 #include <core/DataSet.h>
 #include <core/BusRing.h>
 #include <core/SystemInfo.h>
 #include <cstdio>


using namespace std;
namespace wosh {
 namespace bundles {

 WOSH_REGISTER(wosh::bundles::WebExpositorBundle, wosh::interfaces::network::WebExpositor, _WebExpositor_VERSION, bundles_WebExpositorBundle1)
 WOSH_REGISTER(wosh::bundles::WebExpositorBundle, wosh::BundleGeneric, _WebExpositor_VERSION, bundles_WebExpositorBundle2)

//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////// CONSTRUCTORS

WebExpositorBundle::WebExpositorBundle()
    : BundleGeneric(), webServer(NULL) {
    BundleGeneric::setName( _WebExpositor_NAME, false );
    Properties.update( _KEY_Version, _WebExpositor_VERSION );
    Requirements.add<wosh::network::WebServer>();

Log.setLevel(LOG_DEBUG);

    Log(LOG_DEBUG, " Setting default properties and permissions.." );


//  SHARED PROPERTIES

    Log(LOG_DEBUG, " Registering methods.." );

    Log(LOG_DEBUG, " Setting up WebServer.." );
    this->webServer = ObjectFactory::createTypeOf<wosh::network::WebServer>(false);
    if ( this->webServer != NULL ) {
        this->webServer->setListener(this);
        this->webServer->setParentObject(this);
     }

    setBundleState(Bundle::STATE_CREATED, false);
 }

WebExpositorBundle::~WebExpositorBundle() {
    Log(LOG_INFO, " Destroying.." );
    if ( isBundleRunning() ) {
        Log(LOG_WARNING, "~WebExpositorBundle() : Destroying while RUNNING! Trying to stop.." );
        bundleStop();
     }
    Log(LOG_DEBUG, ":~WebExpositorBundle() : Destroying Scheduler.." );
    WRESULT destroyed = ObjectFactory::destroy(this->webServer);
    this->webServer = NULL;
    if ( WFAILED(destroyed) ) {
     }
    Log(LOG_VERBOSE, ":~WebExpositorBundle() : Destroyed." );
 }

//////////////////////////////////////////////////////////////////////////////////////////////// CONSTRUCTORS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////// BUNDLE CONTROL

WRESULT WebExpositorBundle::bundleStart() {
    if ( !BundleGeneric::bundleValidate_StartStop(Bundle::STATE_STARTING) ) return WRET_ERR_WRONG_STATE;
    setBundleState( Bundle::STATE_STARTING );

    WRESULT ret = WRET_OK;
    if ( this->webServer == NULL ) {
        ret = WRET_ERR_INTERNAL;
        SystemInfo::raise(this, &Log, SystemInfo::TYPE_ERROR, SystemInfo::MODE_PERMANENT, SystemInfo::SCOPE_SYSTEM, SystemInfo::PRIORITY_FAILURE,
                            "Internal Error",
                            "bundleStart() FAILED Creating WebServer.." );
     }
    else {
        ret = this->webServer->startServer();
        
     }

    if ( WSUCCEEDED(ret) )
        setBundleState( Bundle::STATE_STARTED );
    return ret;
 }

WRESULT WebExpositorBundle::bundleStop() {
    if ( !BundleGeneric::bundleValidate_StartStop(Bundle::STATE_STOPPING) ) return WRET_ERR_WRONG_STATE;
    setBundleState( Bundle::STATE_STOPPING );

    WRESULT ret = WRET_ERR_INTERNAL;
    if ( this->webServer != NULL ) {
        ret = this->webServer->stopServer();
     }

    setBundleState( Bundle::STATE_STOPPED );
    return ret;
 }

////////////////////////////////////////////////////////////////////////////////////////////// BUNDLE CONTROL
//////////////////////////////////////////////////////////////////////////////////////////////////////////////

void WebExpositorBundle::busMessage( const Message& message, const Bus* source ) {
    if ( message.isEmpty() ) return;
    if ( !MessageFilter::filterReplica(message, &BusCore) ) return;
    BundleGeneric::busMessage(message, source);
 }

//////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////// PROPERTY EVENT

bool WebExpositorBundle::updatingProperty( bool& do_update, const Variant& value_proposed, Property& property_current, const PropertiesProvider* source ) {
    return BundleGeneric::updatingProperty(do_update, value_proposed, property_current, source);
 }

////////////////////////////////////////////////////////////////////////////////////////////// PROPERTY EVENT
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////

bool WebExpositorBundle::incomingConnection( const std::string& address_port, WebServer* ) {
    // check greenlist/blacklist
    return true;
 }

bool WebExpositorBundle::webrequest_evaluate( WebServerRequest* request, WebServer* ) {
    SecurityToken* session_token = NULL; // TODO
    Request* msg_request = new Request();
    URI target;
//const char* page = WebServer::getDefaultPage();
//request->replyResponse(page);
    vector<string> vpath;
    String::split(vpath, request->url, "/", _String_SPLIT_OPTION_NOT_EMPTY | _String_SPLIT_OPTION_TRIM);
    target.setKernelName(vpath.front());
    if ( !vpath.empty() )
        vpath.erase(vpath.begin());
    target.setPath(vpath);
    target.setName(vpath.back());
    if ( !target.getPath().empty() ) 
        target.getPath().pop_back();
    Log(LOG_DEBUG, ":webrequest_evaluate() Parsed url '%s' as URI '%s'", request->url, target.toString().c_str()  );

    msg_request->setMethod(_METHOD_ListProperties);
    Log(LOG_DEBUG, ":webrequest_evaluate() Parsed method '%s'", msg_request->getMethod().c_str()  );

    //------------------------------------
    // synch MODE:
    unsigned long timeout = 15 * 1000L;
    Message* message = new Message(msg_request);
    int64 id = message->getID();
    message->setSource(this);
    message->setDestinationBus(_Bus_ANY);
    message->setDestination(target);
    signMessage(message, session_token);
    Log(LOG_VERBOSE, ":webrequest_evaluate() Posting Message#%"PRId64" (waiting reply %ul)", id, timeout );
    Message* reply = BusCore.postMessageWaitReply(message, timeout);
    if ( reply == NULL ) {
        Log(LOG_WARNING, ":webrequest_evaluate() Timeout Message#%"PRId64"", id );
        return false;
     }
    if ( reply->isEmpty() || !reply->getContent()->isResponse() || !reply->getContent()->asResponse()->hasData() ) {
        const char* page = WebServer::getDefaultPage();
        request->replyResponse(page);
        return true;
     }
//  char* buffer = new char[16000];
//  memset(buffer, 0, 10);
//  int64 size = PersistenceManager::serializeTo(reply->getContent()->asResponse()->getData(), "HTML", buffer, 16000, EncoderOptions() );
//printf( "\n-------------\n%s\n----------------\n", buffer);
//  if ( size < 15089LL )
//      memset(buffer+(int)size, 0, 10);
//  request->replyResponse( buffer );
//  delete [] buffer;

//   WebServerPage* response = new WebServerPage();
//  response->allocateBuffer(16000);
//  response->setBuffer(NULL);
//  delete response;
    return true;
 }

//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////// METHODS

//////////////////////////////////////////////////////////////////////////////////////////////////////////////

 }; // namespace bundles
}; // namespace wosh