SLPThread.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.
 *
 * SLPThread.h
 * Copyright (C) 2011 Simon Newton
 *
 * The BaseSLPThread abstracts away all the SLP code in an implementation
 * independant manner. There are two implementations, one that uses openslp and
 * the other that uses OLA's SLP server.
 *
 * Like the name implies, the SLPThread starts up a new thread to handle SLP
 * operations. You simple have to call RegisterDevice / RegisterController
 * once, and the thread will take care of re-registering your service before
 * the lifetime expires.
 *
 * To de-register the service entirely call DeRegisterDevice /
 * DeRegisterController.
 *
 * The Register* and DeRegister* methods can be called from any thread.
 * The callbacks will run the in Executor passed to the constructor.
 */

#ifndef INCLUDE_OLA_E133_SLPTHREAD_H_
#define INCLUDE_OLA_E133_SLPTHREAD_H_

#include <ola/Callback.h>
#include <ola/thread/Thread.h>
#include <ola/io/SelectServer.h>
#include <ola/network/Socket.h>
#include <ola/network/IPV4Address.h>
#include <ola/rdm/UID.h>
#include <ola/thread/ExecutorInterface.h>
#include <ola/slp/SLPClient.h>
#include <ola/slp/URLEntry.h>

#include <map>
#include <string>
#include <vector>

namespace ola {
namespace e133 {

using std::string;
using ola::rdm::UID;
using ola::network::IPV4Address;
using ola::slp::URLEntries;

class SLPThreadServerInfo : public ola::slp::ServerInfo {
 public:
 string backend_type;

 SLPThreadServerInfo() : ServerInfo() {}

 SLPThreadServerInfo(const SLPThreadServerInfo &server_info)
 : ServerInfo(server_info),
 backend_type(server_info.backend_type) {
 }

 explicit SLPThreadServerInfo(const ola::slp::ServerInfo &server_info)
 : ServerInfo(server_info) {
 }
};

class BaseSLPThread: public ola::thread::Thread {
 public:
 typedef ola::BaseCallback1<void, bool> RegistrationCallback;
 typedef ola::Callback2<void, bool, const ola::slp::URLEntries&>
 DiscoveryCallback;
 typedef ola::SingleUseCallback2<void, bool, const SLPThreadServerInfo&>
 ServerInfoCallback;

 // Ownership is not transferred.
 explicit BaseSLPThread(
 ola::thread::ExecutorInterface *executor,
 unsigned int discovery_interval = DEFAULT_DISCOVERY_INTERVAL_SECONDS);
 virtual ~BaseSLPThread();

 // These must be called before Init(); Once Initialized the callbacks can't
 // be changed. Ownership of the callback is transferred.
 bool SetNewControllerCallback(DiscoveryCallback *callback);
 bool SetNewDeviceCallback(DiscoveryCallback *callback);

 void RegisterDevice(RegistrationCallback *callback,
 const IPV4Address &address,
 const UID &uid,
 uint16_t lifetime);

 void RegisterController(RegistrationCallback *callback,
 const IPV4Address &address,
 uint16_t lifetime);

 void DeRegisterDevice(RegistrationCallback *callback,
 const IPV4Address &address,
 const UID &uid);

 void DeRegisterController(RegistrationCallback *callback,
 const IPV4Address &address);

 void ServerInfo(ServerInfoCallback *callback);

 void RunDeviceDiscoveryNow();

 virtual bool Init();
 bool Start();
 bool Join(void *ptr = NULL);
 virtual void Cleanup() = 0;

 static const unsigned int DEFAULT_DISCOVERY_INTERVAL_SECONDS;

 protected:
 typedef ola::SingleUseCallback2<void, bool, const ola::slp::URLEntries&>
 InternalDiscoveryCallback;

 ola::io::SelectServer m_ss;
 ola::thread::ExecutorInterface *m_executor;

 void *Run();
 void RunCallbackInExecutor(RegistrationCallback *callback, bool ok);

 // The sub class provides these, they are allowed to block.
 virtual void RunDiscovery(InternalDiscoveryCallback *callback,
 const string &service) = 0;
 virtual void RegisterSLPService(RegistrationCallback *callback,
 const string& url,
 uint16_t lifetime) = 0;
 virtual void DeRegisterSLPService(RegistrationCallback *callback,
 const string& url) = 0;
 virtual void SLPServerInfo(ServerInfoCallback *callback) = 0;

 // Called after the SelectServer has finished and just before the thread
 // completes.
 virtual void ThreadStopping() {}

 // This enables us to limit the refresh-time, 0 means the implementation
 // doesn't have a min-refresh-time.
 virtual uint16_t MinRefreshTime() { return 0; }

 void ReRegisterAllServices();

 static const char RDNMET_SCOPE[];

 private:
 typedef struct {
 uint16_t lifetime;
 ola::thread::timeout_id timeout;
 } URLRegistrationState;
 typedef std::map<string, URLRegistrationState> URLStateMap;

 typedef struct {
 DiscoveryCallback *callback;
 ola::thread::timeout_id timeout;
 } DiscoveryState;
 typedef std::map<string, DiscoveryState> DiscoveryStateMap;

 URLStateMap m_url_map;
 DiscoveryStateMap m_discovery_callbacks;
 bool m_init_ok;
 unsigned int m_discovery_interval;

 // discovery methods
 void AddDiscoveryCallback(string service, DiscoveryCallback *callback);
 void StartDiscoveryProcess();
 void RemoveDiscoveryTimeout(DiscoveryState *state);
 void RunDiscoveryForService(const string service);
 void ForceDiscovery(const string service);
 void DiscoveryComplete(const string service, bool result,
 const URLEntries &urls);
 void RunDiscoveryCallback(DiscoveryCallback *callback, bool result,
 const URLEntries *urls);
 void DiscoveryTriggered(const string service);

 // register / deregister methods
 void RegisterService(RegistrationCallback *callback, const string url,
 uint16_t lifetime);
 void RegistrationComplete(RegistrationCallback *callback, string url,
 bool ok);
 void DeRegisterService(RegistrationCallback *callback, const string url);
 void ReRegisterService(string url);
 void CompleteCallback(RegistrationCallback *callback, bool ok);

 // server info methods
 void GetServerInfo(ServerInfoCallback *callback);
 void HandleServerInfo(ServerInfoCallback *callback, bool ok,
 const SLPThreadServerInfo &service_info);
 void CompleteServerInfo(ServerInfoCallback *callback,
 bool ok,
 const SLPThreadServerInfo *server_info_ptr);

 // helper methods
 static string GetDeviceURL(const IPV4Address& address, const UID &uid);
 static string GetControllerURL(const IPV4Address& address);
 static uint16_t ClampLifetime(const string &url, uint16_t lifetime);

 static const uint16_t MIN_SLP_LIFETIME;
 static const uint16_t SA_REREGISTRATION_TIME;
 static const char E133_DEVICE_SLP_SERVICE_NAME[];
 static const char E133_CONTROLLER_SLP_SERVICE_NAME[];
};


class SLPThreadFactory {
 public:
 static BaseSLPThread* NewSLPThread(
 ola::thread::ExecutorInterface *ss,
 unsigned int discovery_interval =
 BaseSLPThread::DEFAULT_DISCOVERY_INTERVAL_SECONDS);

 private:
 SLPThreadFactory(const SLPThreadFactory&);
 SLPThreadFactory& operator=(const SLPThreadFactory&);
};
} // namespace e133
} // namespace ola
#endif // INCLUDE_OLA_E133_SLPTHREAD_H_