EntityRetrieverPlugin.h

Go to the documentation of this file.

#ifndef __ARC_ENTITYRETRIEVERPLUGIN_H__
#define __ARC_ENTITYRETRIEVERPLUGIN_H__

#include <list>
#include <map>
#include <set>
#include <string>

#include <arc/UserConfig.h>
#include <arc/compute/Endpoint.h>
#include <arc/compute/EndpointQueryingStatus.h>
#include <arc/compute/ExecutionTarget.h>
#include <arc/loader/Loader.h>
#include <arc/loader/FinderLoader.h>

namespace Arc {

template<typename T>
class EndpointQueryOptions {
public:

  EndpointQueryOptions(const std::set<std::string>& preferredInterfaceNames = std::set<std::string>()) : preferredInterfaceNames(preferredInterfaceNames) {}

  const std::set<std::string>& getPreferredInterfaceNames() const { return preferredInterfaceNames; }
private:
  std::set<std::string> preferredInterfaceNames;
};

template<>
class EndpointQueryOptions<Endpoint> {
public:

  EndpointQueryOptions(bool recursive = false,
                       const std::list<std::string>& capabilityFilter = std::list<std::string>(),
                       const std::list<std::string>& rejectedServices = std::list<std::string>(),
                       const std::set<std::string>& preferredInterfaceNames = std::set<std::string>() )
    : recursive(recursive), capabilityFilter(capabilityFilter), rejectedServices(rejectedServices),
      preferredInterfaceNames(preferredInterfaceNames) {}

  bool recursiveEnabled() const { return recursive; }
  const std::list<std::string>& getCapabilityFilter() const { return capabilityFilter; }
  const std::list<std::string>& getRejectedServices() const { return rejectedServices; }
  const std::set<std::string>& getPreferredInterfaceNames() const { return preferredInterfaceNames; }

private:
  bool recursive;
  std::list<std::string> capabilityFilter;
  std::list<std::string> rejectedServices;
  std::set<std::string> preferredInterfaceNames;
};

template<typename T>
class EntityRetrieverPlugin : public Plugin {
protected:
  EntityRetrieverPlugin(PluginArgument* parg): Plugin(parg) {};
public:
  virtual const std::list<std::string>& SupportedInterfaces() const { return supportedInterfaces; };
  virtual bool isEndpointNotSupported(const Endpoint&) const = 0;
  virtual EndpointQueryingStatus Query(const UserConfig&, const Endpoint& rEndpoint, std::list<T>&, const EndpointQueryOptions<T>& options) const = 0;

  static const std::string kind;

protected:
  std::list<std::string> supportedInterfaces;
};

template<typename T>
class EntityRetrieverPluginLoader : public Loader {
public:
  EntityRetrieverPluginLoader() : Loader(BaseConfig().MakeConfig(Config()).Parent()) {}
  ~EntityRetrieverPluginLoader();

  EntityRetrieverPlugin<T>* load(const std::string& name);
  static std::list<std::string> getListOfPlugins();
  const std::map<std::string, EntityRetrieverPlugin<T> *>& GetTargetInformationRetrieverPlugins() const { return plugins; }

protected:
  std::map<std::string, EntityRetrieverPlugin<T> *> plugins;

  static Logger logger;
};

class ServiceEndpointRetrieverPlugin : public EntityRetrieverPlugin<Endpoint> {
protected:
  ServiceEndpointRetrieverPlugin(PluginArgument* parg);
  virtual ~ServiceEndpointRetrieverPlugin() {}
};

class TargetInformationRetrieverPlugin : public EntityRetrieverPlugin<ComputingServiceType> {
protected:
  TargetInformationRetrieverPlugin(PluginArgument* parg);
  virtual ~TargetInformationRetrieverPlugin() {}
};

class JobListRetrieverPlugin : public EntityRetrieverPlugin<Job> {
protected:
  JobListRetrieverPlugin(PluginArgument* parg);
  virtual ~JobListRetrieverPlugin() {}
};

typedef EntityRetrieverPluginLoader<Endpoint> ServiceEndpointRetrieverPluginLoader;

typedef EntityRetrieverPluginLoader<ComputingServiceType> TargetInformationRetrieverPluginLoader;

typedef EntityRetrieverPluginLoader<Job> JobListRetrieverPluginLoader;

} // namespace Arc

#endif // __ARC_ENTITYRETRIEVERPLUGIN_H__