LiveListenerFactory.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidAPI/LiveListenerFactory.h"
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/InstrumentInfo.h"
#include "MantidKernel/Logger.h"
#include <Poco/Net/SocketAddress.h>
 
using std::shared_ptr;
 
namespace Mantid::API {
namespace {
Kernel::Logger g_log("LiveListenerFactory");
} // namespace
 
std::shared_ptr<ILiveListener> LiveListenerFactoryImpl::create(const std::string &instrumentName, bool connect,
                                                               const API::IAlgorithm *callingAlgorithm,
                                                               const std::string &listenerConnectionName) const {
  try {
    // Look up LiveListenerInfo based on given instrument and listener names
    auto inst = Kernel::ConfigService::Instance().getInstrument(instrumentName);
    auto info = inst.liveListenerInfo(listenerConnectionName);
 
    // Defer creation logic to other create overload
    return create(info, connect, callingAlgorithm);
 
  } catch (Kernel::Exception::NotFoundError &) {
    // Could not determine LiveListenerInfo for instrumentName
    // Attempt to interpret instrumentName as listener class name instead, to
    // support legacy usage in unit tests.
    Kernel::LiveListenerInfo info(instrumentName);
    return create(info, connect, callingAlgorithm);
  }
}
 
std::shared_ptr<ILiveListener> LiveListenerFactoryImpl::create(const Kernel::LiveListenerInfo &info, bool connect,
                                                               const API::IAlgorithm *callingAlgorithm) const {
 
  ILiveListener_sptr listener = Kernel::DynamicFactory<ILiveListener>::create(info.listener());
 
  // Give LiveListener additional properties if provided
  if (callingAlgorithm) {
    listener->setAlgorithm(*callingAlgorithm);
  }
 
  if (connect) {
    try {
      Poco::Net::SocketAddress address;
 
      // To allow listener::connect to be called even when no address is given
      if (!info.address().empty())
        address = Poco::Net::SocketAddress(info.address());
 
      // If we can't connect, throw an exception to be handled below
      if (!listener->connect(address)) {
        throw Poco::Exception("Connection attempt failed.");
      }
    }
    // The Poco SocketAddress can throw all manner of exceptions if the address
    // string it gets is badly formed, or it can't successfully look up the
    // server given, or .......
    // Just catch the base class exception
    catch (Poco::Exception &pocoEx) {
      std::stringstream ss;
      ss << "Unable to connect listener [" << info.listener() << "] to [" << info.address() << "]: " << pocoEx.what();
      g_log.debug(ss.str());
      throw std::runtime_error(ss.str());
    }
  }
 
  // If we get to here, it's all good!
  return listener;
}
 
ILiveListener *LiveListenerFactoryImpl::createUnwrapped(const std::string &className) const {
  UNUSED_ARG(className)
  throw Kernel::Exception::NotImplementedError("Don't use this method - use the safe one!!!");
}
 
} // namespace Mantid::API