OladHTTPServer.h

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Library General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * OladHTTPServer.h
 * Interface for the OLA HTTP class
 * Copyright (C) 2005-2010 Simon Newton
 */

#ifndef OLAD_OLADHTTPSERVER_H_
#define OLAD_OLADHTTPSERVER_H_

#include <time.h>
#include <string>
#include <vector>
#include "ola/ExportMap.h"
#include "ola/OlaCallbackClient.h"
#include "ola/http/HTTPServer.h"
#include "ola/http/OlaHTTPServer.h"
#include "ola/network/Interface.h"
#include "ola/rdm/PidStore.h"
#include "olad/RDMHTTPModule.h"

namespace ola {

using std::string;
using ola::http::HTTPServer;


/*
 * This is the main OLA HTTP Server
 */
class OladHTTPServer: public ola::http::OlaHTTPServer {
 public:
 struct OladHTTPServerOptions: public HTTPServer::HTTPServerOptions {
 public:
 bool enable_quit;

 OladHTTPServerOptions()
 : HTTPServer::HTTPServerOptions(),
 enable_quit(true) {
 }
 };

 OladHTTPServer(ExportMap *export_map,
 const OladHTTPServerOptions &options,
 ola::io::ConnectedDescriptor *client_socket,
 class OlaServer *ola_server,
 const ola::network::Interface &interface);
 virtual ~OladHTTPServer();

 bool Init();
 void SetPidStore(const ola::rdm::RootPidStore *pid_store);

 int JsonServerStats(const HTTPRequest *request, HTTPResponse *response);
 int JsonUniversePluginList(const HTTPRequest *request,
 HTTPResponse *response);
 int JsonPluginInfo(const HTTPRequest *request, HTTPResponse *response);
 int JsonUniverseInfo(const HTTPRequest *request, HTTPResponse *response);
 int JsonAvailablePorts(const HTTPRequest *request, HTTPResponse *response);
 int CreateNewUniverse(const HTTPRequest *request, HTTPResponse *response);
 int ModifyUniverse(const HTTPRequest *request, HTTPResponse *response);

 int GetDmx(const HTTPRequest *request, HTTPResponse *response);
 int HandleSetDmx(const HTTPRequest *request, HTTPResponse *response);
 int DisplayQuit(const HTTPRequest *request, HTTPResponse *response);
 int ReloadPlugins(const HTTPRequest *request, HTTPResponse *response);
 int ReloadPidStore(const HTTPRequest *request, HTTPResponse *response);

 void HandlePluginList(HTTPResponse *response,
 const vector<class OlaPlugin> &plugins,
 const string &error);

 void HandleUniverseList(HTTPResponse *response,
 ola::web::JsonObject *json,
 const vector<class OlaUniverse> &universes,
 const string &error);

 void HandlePartialPluginInfo(HTTPResponse *response,
 int plugin_id,
 const string &description,
 const string &error);
 void HandlePluginInfo(HTTPResponse *response,
 string description,
 const OlaCallbackClient::PluginState &state,
 const string &error);

 void HandleUniverseInfo(HTTPResponse *response,
 class OlaUniverse &universe,
 const string &error);

 void HandlePortsForUniverse(HTTPResponse *response,
 ola::web::JsonObject *json,
 unsigned int universe_id,
 const vector<class OlaDevice> &devices,
 const string &error);

 void HandleCandidatePorts(HTTPResponse *response,
 const vector<class OlaDevice> &devices,
 const string &error);

 void CreateUniverseComplete(HTTPResponse *response,
 unsigned int universe_id,
 bool included_name,
 class ActionQueue *action_queue);

 void SendCreateUniverseResponse(HTTPResponse *response,
 unsigned int universe_id,
 bool included_name,
 class ActionQueue *action_queue);

 void ModifyUniverseComplete(HTTPResponse *response,
 class ActionQueue *action_queue);
 void SendModifyUniverseResponse(HTTPResponse *response,
 class ActionQueue *action_queue);

 /*
 * Serve a help redirect
 * @param response the response to use
 */
 inline static int ServeHelpRedirect(HTTPResponse *response) {
 return HTTPServer::ServeRedirect(response, HELP_REDIRECTION);
 }

 static int ServeUsage(HTTPResponse *response, const string &details);

 static const char HELP_PARAMETER[];

 private:
 class ola::io::ConnectedDescriptor *m_client_socket;
 ola::OlaCallbackClient m_client;
 class OlaServer *m_ola_server;
 bool m_enable_quit;
 ola::network::Interface m_interface;
 RDMHTTPModule m_rdm_module;
 time_t m_start_time_t;

 OladHTTPServer(const OladHTTPServer&);
 OladHTTPServer& operator=(const OladHTTPServer&);

 void HandleGetDmx(HTTPResponse *response,
 const DmxBuffer &buffer,
 const string &error);

 void HandleBoolResponse(HTTPResponse *response, const string &error);

 void PortToJson(ola::web::JsonObject *object,
 const class OlaDevice &device,
 const class OlaPort &port,
 bool is_output);

 void AddPatchActions(ActionQueue *action_queue,
 const string port_id_string,
 unsigned int universe,
 PatchAction port_action);

 void AddPriorityActions(ActionQueue *action_queue,
 const HTTPRequest *request);

 typedef struct {
 unsigned int device_alias;
 unsigned int port;
 PortDirection direction;
 string string_id;
 } port_identifier;

 void DecodePortIds(const string &port_ids, vector<port_identifier> *ports);

 void RegisterHandler(
 const string &path,
 int (OladHTTPServer::*method)(const HTTPRequest*, HTTPResponse*));

 static const char HELP_REDIRECTION[];
 static const char K_BACKEND_DISCONNECTED_ERROR[];
 static const unsigned int K_UNIVERSE_NAME_LIMIT = 100;
 static const char K_PRIORITY_VALUE_SUFFIX[];
 static const char K_PRIORITY_MODE_SUFFIX[];
};
} // namespace ola
#endif // OLAD_OLADHTTPSERVER_H_