Merge branch 'devel-alf'

Author: PascalBoeschoten

src/CommandLineUtilities/AliceLowlevelFrontend/AliceLowlevelFrontend.h

@@ -59,14 +59,24 @@ inline void setDataBuffer(std::vector<char>& buffer, DimObject& dimObject)
   dimObject.setData(buffer.data(), buffer.size());
 }
 
+inline std::string argumentSeparator()
+{
+  return "\n";
+}
+
+inline std::string scaPairSeparator()
+{
+  return ",";
+}
+
 inline std::string successPrefix()
 {
-  return "success:";
+  return "success" + argumentSeparator();
 }
 
 inline std::string failPrefix()
 {
-  return "failure:";
+  return "failure" + argumentSeparator();
 }
 
 inline std::string makeSuccessString(const std::string& string)
@@ -92,6 +102,7 @@ inline bool isFail(const std::string& string)
 inline std::string stripPrefix(const std::string& string)
 {
   if (string.length() < PREFIX_LENGTH) {
+    printf("len=%lu  str=%s\n", string.length(), string.c_str());
     BOOST_THROW_EXCEPTION(AlfException() << ErrorInfo::Message("string too short to contain prefix"));
   }
   return string.substr(PREFIX_LENGTH);
@@ -115,7 +126,7 @@ class DimRpcInfoWrapper
       auto string = std::string(mRpcInfo->getString());
       if (isFail(string)) {
         BOOST_THROW_EXCEPTION(
-          AlfException() << ErrorInfo::Message("ALF server failure" + string));
+          AlfException() << ErrorInfo::Message("ALF server failure: " + string));
       }
       return string;
     }
@@ -137,60 +148,69 @@ class DimRpcInfoWrapper
     std::unique_ptr<DimRpcInfo> mRpcInfo;
 };
 
-class PublishRpc : DimRpcInfoWrapper
+class PublishRegistersStartRpc : DimRpcInfoWrapper
 {
   public:
-    PublishRpc(const std::string& serviceName)
+    PublishRegistersStartRpc(const std::string& serviceName)
         : DimRpcInfoWrapper(serviceName)
     {
     }
 
-    void publish(std::string dnsName, double frequency, std::vector<size_t> addresses)
+    void publish(std::string dnsName, double interval, std::vector<size_t> addresses)
     {
       std::ostringstream stream;
-      stream << dnsName << ';';
+      auto sep = argumentSeparator();
+      stream << dnsName << sep << interval;
       for (size_t i = 0; i < addresses.size(); ++i) {
-        stream << addresses[i];
-        if ((i + 1) < addresses.size()) {
-          stream << ',';
-        }
+        stream << sep << addresses[i];
       }
-      stream << ';' << frequency;
       printf("Publish: %s\n", stream.str().c_str());
       setString(stream.str());
       getString();
     }
 };
 
-class PublishScaRpc : DimRpcInfoWrapper
+class PublishScaSequenceStartRpc : DimRpcInfoWrapper
 {
   public:
-    PublishScaRpc(const std::string& serviceName)
+    PublishScaSequenceStartRpc(const std::string& serviceName)
       : DimRpcInfoWrapper(serviceName)
     {
     }
 
-    void publish(std::string dnsName, double frequency, const std::vector<Sca::CommandData>& commandDataPairs)
+    void publish(std::string dnsName, double interval, const std::vector<Sca::CommandData>& commandDataPairs)
     {
       std::ostringstream stream;
-      stream << dnsName << ';';
+      auto sep = argumentSeparator();
+      stream << dnsName << sep << interval;
       for (size_t i = 0; i < commandDataPairs.size(); ++i) {
-        stream << commandDataPairs[i].command << ',' << commandDataPairs[i].data;
-        if ((i + 1) < commandDataPairs.size()) {
-          stream << '\n';
-        }
+        stream << sep << commandDataPairs[i].command << scaPairSeparator() << commandDataPairs[i].data;
       }
-      stream << ';' << frequency;
       printf("Publish SCA: %s\n", stream.str().c_str());
       setString(stream.str());
       getString();
     }
 };
 
-class PublishStopRpc: DimRpcInfoWrapper
+class PublishRegistersStopRpc: DimRpcInfoWrapper
+{
+  public:
+    PublishRegistersStopRpc(const std::string &serviceName)
+      : DimRpcInfoWrapper(serviceName)
+    {
+    }
+
+    void stop(std::string dnsName)
+    {
+      setString(dnsName);
+      getString();
+    }
+};
+
+class PublishScaSequenceStopRpc: DimRpcInfoWrapper
 {
   public:
-    PublishStopRpc(const std::string &serviceName)
+    PublishScaSequenceStopRpc(const std::string &serviceName)
       : DimRpcInfoWrapper(serviceName)
     {
     }
@@ -227,7 +247,7 @@ class RegisterWriteRpc: DimRpcInfoWrapper
 
     void writeRegister(uint64_t registerAddress, uint32_t registerValue)
     {
-      setString((boost::format("0x%x,0x%x") % registerAddress % registerValue).str());
+      setString((boost::format("0x%x%s0x%x") % registerAddress % argumentSeparator() % registerValue).str());
       getString();
     }
 };
@@ -257,7 +277,7 @@ class ScaWriteRpc: DimRpcInfoWrapper
 
     std::string write(uint32_t command, uint32_t data)
     {
-      setString((boost::format("0x%x,0x%x") % command % data).str());
+      setString((boost::format("0x%x%s0x%x") % command % scaPairSeparator() % data).str());
       return stripPrefix(getString());
     }
 };
@@ -310,41 +330,15 @@ class ScaWriteSequence: DimRpcInfoWrapper
     {
       std::stringstream buffer;
       for (size_t i = 0; i < sequence.size(); ++i) {
-        buffer << sequence[i].first << ',' << sequence[i].second;
+        buffer << sequence[i].first << scaPairSeparator() << sequence[i].second;
         if (i + 1 < sequence.size()) {
-          buffer << '\n';
+          buffer << argumentSeparator();
         }
       }
       return write(buffer.str());
     }
 };
 
-class StringRpcServer: public DimRpc
-{
-  public:
-    using Callback = std::function<std::string(const std::string&)>;
-
-    StringRpcServer(const std::string& serviceName, Callback callback)
-        : DimRpc(serviceName.c_str(), "C", "C"), callback(callback)
-    {
-    }
-
-    StringRpcServer(const StringRpcServer& b) = delete;
-    StringRpcServer(StringRpcServer&& b) = delete;
-
-  private:
-    void rpcHandler() override
-    {
-      try {
-        auto returnValue = callback(std::string(getString()));
-        Alf::setDataString(Alf::makeSuccessString(returnValue), *this);
-      } catch (const std::exception& e) {
-        Alf::setDataString(Alf::makeFailString(e.what()), *this);
-      }
-    }
-
-    Callback callback;
-};
 
 } // namespace Alf
 } // namespace CommandLineUtilities

src/CommandLineUtilities/AliceLowlevelFrontend/ProgramAlfScaWriteSequence.cxx

@@ -36,6 +36,8 @@ class ProgramAlfScaWriteSequence: public Program
       options.add_options()
         ("serial", boost::program_options::value<int>(&mSerialNumber),
           "Card serial number")
+        ("link", boost::program_options::value<int>(&mLink),
+          "Link")
         ("file", boost::program_options::value<std::string>(&mFilePath)->required(),
           "Path to command sequence file")
         ("out", boost::program_options::value<std::string>(&mOutFilePath),
@@ -51,8 +53,8 @@ class ProgramAlfScaWriteSequence: public Program
       }
 
       // Initialize DIM objects
-      Alf::ServiceNames names(mSerialNumber);
-      Alf::ScaWriteSequence scaWriteSequence(names.scaWriteSequence());
+      Alf::ServiceNames names(mSerialNumber, mLink);
+      Alf::ScaWriteSequence scaWriteSequence(names.scaSequence());
 
       // Read file
       std::ifstream file(mFilePath);
@@ -76,6 +78,7 @@ class ProgramAlfScaWriteSequence: public Program
     std::string mFilePath;
     std::string mOutFilePath;
     int mSerialNumber;
+    int mLink;
 };
 } // Anonymous namespace
 

src/CommandLineUtilities/AliceLowlevelFrontend/ProgramAliceLowlevelFrontendClient.cxx

@@ -4,6 +4,7 @@
 /// \author Pascal Boeschoten ([email protected])
 
 #include "CommandLineUtilities/Program.h"
+#include "Common/GuardFunction.h"
 #include <iostream>
 #include <thread>
 #include <dim/dic.hxx>
@@ -43,49 +44,71 @@ class ProgramAliceLowlevelFrontendClient: public Program
     virtual Description getDescription() override
     {
       return {"ALF DIM Client example", "ALICE low-level front-end DIM Client example",
-        "roc-alf-client --serial=12345"};
+        "roc-alf-client --serial=12345 --link=42"};
     }
 
     virtual void addOptions(boost::program_options::options_description& options) override
     {
-      options.add_options()("serial", boost::program_options::value<int>(&mSerialNumber), "Card serial number");
+      options.add_options()
+        ("serial", boost::program_options::value<int>(&mSerialNumber), "Card serial number")
+        ("link", boost::program_options::value<int>(&mLink), "Link");
     }
 
     virtual void run(const boost::program_options::variables_map&) override
     {
       // Get DIM DNS node from environment
       if (getenv(std::string("DIM_DNS_NODE").c_str()) == nullptr) {
-        BOOST_THROW_EXCEPTION(Alf::AlfException() << Alf::ErrorInfo::Message("Environment variable 'DIM_DNS_NODE' not set"));
+        BOOST_THROW_EXCEPTION(
+          Alf::AlfException() << Alf::ErrorInfo::Message("Environment variable 'DIM_DNS_NODE' not set"));
       }
 
+      cout << "Using serial=" << mSerialNumber << " link=" << mLink << '\n';
+
       // Initialize DIM objects
-      Alf::ServiceNames names(mSerialNumber);
+      Alf::ServiceNames names(mSerialNumber, mLink);
       TemperatureInfo alfTestInt(names.temperature());
       Alf::RegisterReadRpc readRpc(names.registerReadRpc());
       Alf::RegisterWriteRpc writeRpc(names.registerWriteRpc());
       Alf::ScaReadRpc scaReadRpc(names.scaRead());
       Alf::ScaWriteRpc scaWriteRpc(names.scaWrite());
       Alf::ScaGpioReadRpc scaGpioReadRpc(names.scaGpioRead());
       Alf::ScaGpioWriteRpc scaGpioWriteRpc(names.scaGpioWrite());
-      Alf::ScaWriteSequence scaWriteSequence(names.scaWriteSequence());
-      Alf::PublishRpc publishRpc(names.publishStartCommandRpc());
-      Alf::PublishScaRpc publishScaRpc(names.publishScaStartCommandRpc());
-
-      publishRpc.publish("ALF/TEST/1", 1.0, {0x1fc});
-      publishRpc.publish("ALF/TEST/2", 3.0, {0x100, 0x104, 0x108});
+      Alf::ScaWriteSequence scaWriteSequence(names.scaSequence());
+      Alf::PublishRegistersStartRpc publishRegistersStartRpc(names.publishRegistersStart());
+      Alf::PublishRegistersStopRpc publishRegistersStopRpc(names.publishRegistersStop());
+      Alf::PublishScaSequenceStartRpc publishScaSequenceStartRpc(names.publishScaSequenceStart());
+      Alf::PublishScaSequenceStopRpc publishScaSequenceStopRpc(names.publishScaSequenceStop());
+
+      publishRegistersStartRpc.publish("TEST_1", 5.0, {0x1fc});
+      publishRegistersStartRpc.publish("TEST_2", 5.0, {0x100, 0x104});
+      publishScaSequenceStartRpc.publish("TEST_3", 2.5, {{0x0, 0x1}, {0x10, 0x11}});
+
+      AliceO2::Common::GuardFunction publishStopper{
+        [&]() {
+          publishRegistersStopRpc.stop("TEST_1");
+          publishRegistersStopRpc.stop("TEST_2");
+          publishScaSequenceStopRpc.stop("TEST_3");
+        }
+      };
 
-      publishScaRpc.publish("ALF/TEST/SCA_1", 1.0, {{0x0, 0x1}, {0x10, 0x11}});
+      for (int i = 0; i < 3; ++i) {
+        cout << "SCA write '" << i << "'" << endl;
+        cout << "  result: " << scaWriteRpc.write(0xabcdabcd, i) << endl;
+        cout << "SCA read" << endl;
+        cout << "  result: " << scaReadRpc.read() << endl;
+      }
 
-      for (int i = 0; i < 10; ++i) {
+      for (int i = 0; i < 3; ++i) {
         cout << "SCA GPIO write '" << i << "'" << endl;
         cout << "  result: " << scaGpioWriteRpc.write(i) << endl;
         cout << "SCA GPIO read" << endl;
         cout << "  result: " << scaGpioReadRpc.read() << endl;
       }
 
       {
-        cout << "1k writes to 0x1fc..." << endl;
-        for (int i = 0; i < 1000; ++i) {
+        cout << "Reads & writes to 0x1fc..." << endl;
+        for (int i = 0; i < 3; ++i) {
+          writeRpc.writeRegister(0x1fc, 0x123);
           readRpc.readRegister(0x1fc);
         }
         cout << "Done!" << endl;
@@ -96,7 +119,7 @@ class ProgramAliceLowlevelFrontendClient: public Program
         cout << "Writing blob of " << numInts << " pairs of 32-bit ints..." << endl;
         std::vector<std::pair<uint32_t, uint32_t>> buffer(numInts);
         for (size_t i = 0; i < buffer.size(); ++i) {
-          buffer[i] = {i * 2, i * 2 + 1};
+          buffer[i] = {0xabcdab + i * 2, 0xabcdab + i * 2 + 1};
         }
 
         std::string result = scaWriteSequence.write(buffer);
@@ -107,41 +130,27 @@ class ProgramAliceLowlevelFrontendClient: public Program
 
       {
         cout << "Writing blob with comments..." << endl;
-        std::string result = scaWriteSequence.write("# Hello!\n11,22\n33,44\n# Bye!");
+        std::string result = scaWriteSequence.write("# Hello!\nabcdab11,22\nabcdab33,44\n# Bye!");
         cout << "Done!" << endl;
         cout << "Got result: \n";
         cout << "  " << result << '\n';
       }
 
-      while (false)//!isSigInt())
-      {
-        cout << "-------------------------------------\n";
-        cout << "Temperature   = " << gTemperature << endl;
-
-        int writes = 10; //std::rand() % 50;
-        cout << "Write   0x1f8 = 0x1 times " << writes << endl;
-        for (int i = 0; i < writes; ++i) {
-          writeRpc.writeRegister(0x1f8, 0x1);
-        }
+      try {
+        cout << "Writing bad blob..." << endl;
+        std::string result = scaWriteSequence.write("I AM BAD\n11,22\n33,44\nAAAAAAAAaaaaa");
+      } catch (const Alf::AlfException& e) {
+        cout << "Successfully broke the server!\n";
+      }
 
-        cout << "Read    0x1fc = " << readRpc.readRegister(0x1fc) << endl;
-        cout << "Read    0x1ec = " << readRpc.readRegister(0x1ec) << endl;
-        cout << "Cmd     0x1f4 = 0x1" << endl;
-        writeRpc.writeRegister(0x1f4, 0x1);
-        cout << "Cmd     0x1f4 = 0x2" << endl;
-        writeRpc.writeRegister(0x1f4, 0x1);
-        cout << "Cmd     0x1f4 = 0x3" << endl;
-        writeRpc.writeRegister(0x1f4, 0x1);
+      while (!isSigInt())
+      {
         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
       }
-
-      Alf::PublishStopRpc publishStopRpc(names.publishStopCommandRpc());
-      publishStopRpc.stop("ALF/TEST/1");
-      publishStopRpc.stop("ALF/TEST/2");
-      publishStopRpc.stop("ALF/TEST/SCA_1");
     }
 
     int mSerialNumber;
+    int mLink;
 };
 } // Anonymous namespace