Improve formalization of CameraRequets for better error handling

include/EigerCamera.h

@@ -97,8 +97,8 @@ class LIBEIGER Camera : public HwMaxImageSizeCallbackGen, public EventCallbackGe
   void setLatTime(double  lat_time);
   void getLatTime(double& lat_time);
 
-  void getExposureTimeRange(double& min_expo, double& max_expo) const;
-  void getLatTimeRange(double& min_lat, double& max_lat) const;
+  void getExposureTimeRange(double& min_expo, double& max_expo);
+  void getLatTimeRange(double& min_lat, double& max_lat);
 
   void setNbFrames(int  nb_frames);
   void getNbFrames(int& nb_frames);
@@ -161,6 +161,7 @@ class LIBEIGER Camera : public HwMaxImageSizeCallbackGen, public EventCallbackGe
   friend class SavingCtrlObj;
   friend class Stream;
   friend class MultiParamRequest;
+  friend class CameraRequest;
 
   enum InternalStatus {IDLE,RUNNING,ERROR};
   class TriggerCallback;
@@ -181,16 +182,6 @@ class LIBEIGER Camera : public HwMaxImageSizeCallbackGen, public EventCallbackGe
   void newFrameAcquired();
   bool allFramesAcquired();
 
-  template <typename C>
-  void _sendCommand(C cmd, DebObj *deb_ptr);
-  template <typename P, typename T>
-  void _setParam(P param, T value, DebObj *deb_ptr);
-  template <typename P, typename T>
-  void _getParam(P param, T& value, DebObj *deb_ptr);
-  template <typename R>
-  void _startTransfer(std::string src_file_name, std::string dest_path,
-		      AutoMutex& lock, R& req, DebObj *deb_ptr);
-
   template <typename T>
   struct Cache
   {

sip/EigerCamera.sip

@@ -62,8 +62,8 @@ namespace Eiger
     void setLatTime(double  lat_time);
     void getLatTime(double& lat_time /Out/);
 
-    void getExposureTimeRange(double& min_expo /Out/, double& max_expo /Out/) const;
-    void getLatTimeRange(double& min_lat /Out/, double& max_lat /Out/) const;
+    void getExposureTimeRange(double& min_expo /Out/, double& max_expo /Out/);
+    void getLatTimeRange(double& min_lat /Out/, double& max_lat /Out/);
 
     void setNbFrames(int  nb_frames);
     void getNbFrames(int& nb_frames /Out/);

src/EigerCamera.cpp

@@ -38,6 +38,9 @@ using namespace eigerapi;
 #define sendCommand(cmd)			\
   sendEigerCommand(*this, cmd)
 
+#define sendCommandTimeout(cmd, timeout)	\
+  sendEigerCommandTimeout(*this, cmd, timeout)
+
 #define setParam(param, value)			\
   setEigerParam(*this, param, value)
 
@@ -110,18 +113,15 @@ Camera::Camera(const std::string& detector_ip, 	///< [in] Ip address of the dete
     DEB_CONSTRUCTOR();
     DEB_PARAM() << DEB_VAR1(detector_ip);
     // Init EigerAPI
-    try
-      {
-	_synchronize();
-      }
-    catch(Exception& e)
-      {
-	DEB_ALWAYS() << "Could not get configuration parameters, try to initialize";
-	initialize();
-	AutoMutex lock(m_cond.mutex());
-	while (m_initialize_state == RUNNING)
-	  m_cond.wait();
-      }
+    try {
+      _synchronize();
+    } catch(Exception& e) {
+      DEB_ALWAYS() << "Could not get configuration parameters, try to initialize";
+      initialize();
+      AutoMutex lock(m_cond.mutex());
+      while (m_initialize_state == RUNNING)
+	m_cond.wait();
+    }
 
     // Display max image size
     DEB_TRACE() << "Detector max width: " << m_maxImageWidth;
@@ -175,7 +175,7 @@ void Camera::_initialization_finished(bool ok)
       DEB_ALWAYS() << "Synchronizing with detector ...";
       _synchronize();
       DEB_ALWAYS() << "Done!";
-    } catch (const lima::Exception& e) {
+    } catch (const Exception& e) {
       ok = false;
     }
   }
@@ -231,19 +231,14 @@ void Camera::prepareAcq()
 
   DEB_TRACE() << "Arm start";
   double timeout = 5 * 60.; // 5 min timeout
-  CommandReq arm_cmd = m_requests->get_command(Requests::ARM);
-  try
-    {
-      arm_cmd->wait(timeout);
-      DEB_TRACE() << "Arm end";
-      m_serie_id = arm_cmd->get_serie_id();
-      m_armed = true;
-    }
-  catch(const eigerapi::EigerException &e)
-    {
-      m_requests->cancel(arm_cmd);
-      HANDLE_EIGERERROR(arm_cmd, e);
-    }
+  CommandReq arm_cmd = sendCommandTimeout(Requests::ARM, timeout);
+  DEB_TRACE() << "Arm end";
+  m_armed = true;
+  try {
+    m_serie_id = arm_cmd->get_serie_id();
+  } catch(const eigerapi::EigerException &e) {
+    HANDLE_EIGERERROR(arm_cmd, e);
+  }
   m_frames_triggered = m_frames_acquired = 0;
 }
 
@@ -306,14 +301,12 @@ void Camera::getDetectorImageSize(Size& size) ///< [out] image dimensions
 {
   DEB_MEMBER_FUNCT();
 
-  ParamReq width_request = 
-    m_requests->get_param(Requests::DETECTOR_WITDH);
-  ParamReq height_request = 
-    m_requests->get_param(Requests::DETECTOR_HEIGHT);
-
-  Requests::Param::Value width = width_request->get();
-  Requests::Param::Value height = height_request->get();
-  size = Size(width.data.int_val, height.data.int_val);
+  MultiParamRequest synchro(*this);
+  unsigned int width, height;
+  synchro.addGet(Requests::DETECTOR_WITDH, width);
+  synchro.addGet(Requests::DETECTOR_HEIGHT, height);
+  synchro.wait();
+  size = Size(width, height);
 }
 
 
@@ -483,30 +476,19 @@ void Camera::getLatTime(double& lat_time) ///< [out] current latency time
 //-----------------------------------------------------------------------------
 void Camera::getExposureTimeRange(double& min_expo,	///< [out] minimum exposure time
                                   double& max_expo)   ///< [out] maximum exposure time
-const
 {
   DEB_MEMBER_FUNCT();
-  ParamReq exp_time = 
-    m_requests->get_param(Requests::EXPOSURE);
-  try
-    {
-      exp_time->wait();
-    }
-  catch(const eigerapi::EigerException &e)
-    {
-      m_requests->cancel(exp_time);
-      HANDLE_EIGERERROR(exp_time, e);
-    }
-
-  Requests::Param::Value min_val = exp_time->get_min();
-  Requests::Param::Value max_val;
-  if (m_api == Eiger1)
-    max_val = exp_time->get_max();
-  else
-    max_val.data.double_val = 1800;
-
-  min_expo = min_val.data.double_val;
-  max_expo = max_val.data.double_val;
+  double curr_expo;
+  ParamReq exp_time = getParam(Requests::EXPOSURE, curr_expo);
+  try {
+    min_expo = exp_time->get_min().data.double_val;
+    if (m_api == Eiger1)
+      max_expo = exp_time->get_max().data.double_val;
+    else
+      max_expo = 1800;
+  } catch(const eigerapi::EigerException &e) {
+    HANDLE_EIGERERROR(exp_time, e);
+  }
   DEB_RETURN() << DEB_VAR2(min_expo, max_expo);
 }
 
@@ -516,7 +498,6 @@ const
 //-----------------------------------------------------------------------------
 void Camera::getLatTimeRange(double& min_lat, ///< [out] minimum latency
                              double& max_lat) ///< [out] maximum latency
-const
 {
   DEB_MEMBER_FUNCT();
 
@@ -710,9 +691,14 @@ void Camera::_synchronize()
   else
     THROW_HW_ERROR(InvalidValue) << "Unexpected trigger mode: "
 				 << DEB_VAR1(trig_name);
-  
-  Requests::Param::Value min_frame_time = synchro[Requests::FRAME_TIME]->get_min();
-  m_min_frame_time = min_frame_time.data.double_val;
+
+  Requests::PARAM_NAME param;
+  try {
+    param = Requests::FRAME_TIME;
+    m_min_frame_time = synchro[param]->get_min().data.double_val;
+  } catch (const EigerException& e) {
+    HANDLE_EIGERERROR(synchro[param], e);
+  }
 
   if (compression_type == "none")
     m_compression_type = NoCompression;
@@ -1113,9 +1099,14 @@ void Camera::setCompressionType(Camera::CompressionType type)
   }
   DEB_TRACE() << DEB_VAR1(s);
 
-  ParamReq type_req =
-    m_requests->get_param(Requests::COMPRESSION_TYPE);
-  Requests::Param::Value types_allowed = type_req->get_allowed_values();
+  std::string type_str;
+  ParamReq type_req = getParam(Requests::COMPRESSION_TYPE, type_str);
+  Requests::Param::Value types_allowed;
+  try {
+    types_allowed = type_req->get_allowed_values();
+  } catch (const EigerException &e) {
+    HANDLE_EIGERERROR(type_req, e);
+  }
   const vector<string>& l = types_allowed.string_array;
   if (DEB_CHECK_ANY(DebTypeTrace)) {
     DEB_TRACE() << "allowed compression types:";

src/EigerCameraRequests.h

@@ -44,76 +44,91 @@ typedef eigerapi::CurlLoop::FutureRequest::CallbackPtr CallbackPtr;
 /*----------------------------------------------------------------------------
 			    class Camera request helpers
  ----------------------------------------------------------------------------*/
-
-template <typename C>
-void Camera::_sendCommand(C cmd, DebObj *deb_ptr)
+class CameraRequest
 {
-  DEB_FROM_PTR(deb_ptr);
-  CommandReq req = m_requests->get_command(cmd);
-  try {
-    req->wait();
-  } catch(const eigerapi::EigerException &e) {
-    m_requests->cancel(req);
-    HANDLE_EIGERERROR(req, e);
+public:
+  CameraRequest(Camera& cam) : m_cam(cam), m_requests(m_cam.m_requests) {}
+
+  CommandReq doSendCommandTimeout(eigerapi::Requests::COMMAND_NAME cmd,
+				  double timeout, DebObj *deb_ptr)
+  {
+    DEB_FROM_PTR(deb_ptr);
+    CommandReq req = m_requests->get_command(cmd);
+    try {
+      req->wait(timeout);
+    } catch(const eigerapi::EigerException &e) {
+      m_requests->cancel(req);
+      HANDLE_EIGERERROR(req, e);
+    }
+    return req;
   }
-}
 
-template <typename P, typename T>
-void Camera::_setParam(P param, T value, DebObj *deb_ptr)
-{
-  DEB_FROM_PTR(deb_ptr);
-  ParamReq req = m_requests->set_param(param, value);
-  try {
-    req->wait();
-  } catch(const eigerapi::EigerException &e) {
-    HANDLE_EIGERERROR(req, e);
+  template <typename T>
+  ParamReq doSetParam(eigerapi::Requests::PARAM_NAME param, T value,
+		      DebObj *deb_ptr)
+  {
+    DEB_FROM_PTR(deb_ptr);
+    ParamReq req = m_requests->set_param(param, value);
+    try {
+      req->wait();
+    } catch(const eigerapi::EigerException &e) {
+      HANDLE_EIGERERROR(req, e);
+    }
+    return req;
   }
-}    
 
-template <typename P, typename T>
-void Camera::_getParam(P param, T& value, DebObj *deb_ptr)
-{
-  DEB_FROM_PTR(deb_ptr);
-  ParamReq req = m_requests->get_param(param, value);
-  try {
-    req->wait();
-  } catch(const eigerapi::EigerException &e) {
-    m_requests->cancel(req);
-    HANDLE_EIGERERROR(req, e);
+  template <typename T>
+  ParamReq doGetParam(eigerapi::Requests::PARAM_NAME param, T& value,
+		      DebObj *deb_ptr)
+  {
+    DEB_FROM_PTR(deb_ptr);
+    ParamReq req = m_requests->get_param(param, value);
+    try {
+      req->wait();
+    } catch(const eigerapi::EigerException &e) {
+      m_requests->cancel(req);
+      HANDLE_EIGERERROR(req, e);
+    }
+    return req;
   }
-}
 
-template <typename R>
-void Camera::_startTransfer(std::string src_file_name,
-			    std::string dest_path,
-			    AutoMutex& lock, R& req,
-			    DebObj *deb_ptr)
-{
-  DEB_FROM_PTR(deb_ptr);
-
-  try {
-    req = m_requests->start_transfer(src_file_name, dest_path);
-  } catch(eigerapi::EigerException& e) {
-    Event *event = new Event(Hardware,Event::Error, Event::Saving,
-			     Event::SaveOpenError,e.what());
-    AutoMutexUnlock u(lock);
-    reportEvent(event);
-    req.reset();
+  TransferReq doStartTransfer(std::string src_file_name, std::string dest_path,
+			      AutoMutex& lock, DebObj *deb_ptr)
+  {
+    DEB_FROM_PTR(deb_ptr);
+    TransferReq req;
+    try {
+      req = m_requests->start_transfer(src_file_name, dest_path);
+    } catch(eigerapi::EigerException& e) {
+      Event *event = new Event(Hardware,Event::Error, Event::Saving,
+			       Event::SaveOpenError,e.what());
+      AutoMutexUnlock u(lock);
+      m_cam.reportEvent(event);
+      req.reset();
+    }
+    return req;
   }
-}
 
+public:
+  Camera& m_cam;
+  eigerapi::Requests *m_requests;
+};
+
+
+#define sendEigerCommand(cam, cmd)			\
+  sendEigerCommandTimeout(cam, cmd, eigerapi::CurlLoop::FutureRequest::TIMEOUT)
 
-#define sendEigerCommand(cam, cmd)		\
-  (cam)._sendCommand(cmd, DEB_PTR())
+#define sendEigerCommandTimeout(cam, cmd, timeout)	\
+  CameraRequest(cam).doSendCommandTimeout(cmd, timeout, DEB_PTR())
 
-#define setEigerParam(cam, param, value)	\
-  (cam)._setParam(param, value, DEB_PTR())
+#define setEigerParam(cam, param, value)		\
+  CameraRequest(cam).doSetParam(param, value, DEB_PTR())
 
-#define getEigerParam(cam, param, value)	\
-  (cam)._getParam(param, value, DEB_PTR())
+#define getEigerParam(cam, param, value)		\
+  CameraRequest(cam).doGetParam(param, value, DEB_PTR())
 
-#define startEigerTransfer(cam, src_file_name, dest_path, lock, req)	\
-  (cam)._startTransfer(src_file_name, dest_path, lock, req, DEB_PTR())
+#define startEigerTransfer(cam, src_file_name, dest_path, lock)		\
+  CameraRequest(cam).doStartTransfer(src_file_name, dest_path, lock, DEB_PTR())
 
 
 /*----------------------------------------------------------------------------

src/EigerSavingCtrlObj.cpp

@@ -306,8 +306,9 @@ void SavingCtrlObj::_PollingThread::threadFunction()
 	      std::string master_file_name = prefix + "_master.h5";
 	      std::string dest_path = directory + "/" + master_file_name;
 	      TransferReq master_file_req;
-	      startEigerTransfer(m_saving.m_cam,src_file_name.str(),
-				 dest_path,lock,master_file_req);
+	      master_file_req = startEigerTransfer(m_saving.m_cam,
+						   src_file_name.str(),
+						   dest_path,lock);
 	      if (!master_file_req) {
 		// stop the loop
 		m_saving.m_nb_file_to_watch = m_saving.m_nb_file_transfer_started = 0;
@@ -360,8 +361,9 @@ void SavingCtrlObj::_PollingThread::threadFunction()
 		  DEB_TRACE() << "Start transfer file: " << DEB_VAR1(*file_name);
 		  std::string dest_path = directory + "/" + src_file_name.str();
 		  TransferReq file_req;
-		  startEigerTransfer(m_saving.m_cam,src_file_name.str(),
-				     dest_path, lock,file_req);
+		  file_req = startEigerTransfer(m_saving.m_cam,
+						src_file_name.str(),
+						dest_path,lock);
 		  if (!file_req) {
 		    // stop the loop
 		    m_saving.m_nb_file_to_watch = m_saving.m_nb_file_transfer_started = 0;