Added frontier switch to test (TrigConfDBConnection-00-00-06)

Trigger/TrigConfiguration/TrigConfDBConnection/TrigConfDBConnection/HelloWorld.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef HelloWorld_h
+#define HelloWorld_h
+
+#include <string>
+
+class HelloWorld {
+public:
+   HelloWorld();
+   HelloWorld(const std::string& s);
+   virtual ~HelloWorld();
+
+   void greetings();
+   void setGreetings(const std::string& s);
+   void setStrPtr(const std::string* p);
+
+private:
+
+   std::string fMessage;
+
+};
+
+#endif

Trigger/TrigConfiguration/TrigConfDBConnection/cmt/fragments/install_pylib_header

+
+
+${CONSTITUENT} ::
+	@echo "${CONSTITUENT}: installing ${file} in ${install_dir} as ${package}/${target}"
+	@if test ! -d ${install_dir}/${package}; then mkdir -p ${install_dir}/${package}; fi ; \
+	cd ${install_dir}/${package} ; \
+	ln -sf ${file} ${target}; 
+
+${CONSTITUENT}clean ::
+	@if test -d ${install_dir}; then \
+	  cd ${install_dir}; \
+	fi
+
+
+

Trigger/TrigConfiguration/TrigConfDBConnection/cmt/requirements

+package TrigConfDBConnection
+author Joerg.Stelzer@cern.ch
+manager Joerg.Stelzer@cern.ch
+
+public
+
+use  AtlasPolicy                AtlasPolicy-*
+
+private
+
+use  Frontier_Client            v*                              LCG_Interfaces
+use  AtlasBoost                 AtlasBoost-*                    External
+use  AtlasPython                AtlasPython-*                   External
+
+make_fragment install_pylib_header
+make_fragment install_pylib -header=install_pylib_header
+
+pattern install_pylib \
+    #macro lib_python_path "$(CMTINSTALLAREA)/$(tag)/lib/python$(Python_config_version_twodigit)" ; \
+    macro lib_python_path "$(CMTINSTALLAREA)/python" ; \
+    document install_pylib "<package>install_pylib" install_dir=$(lib_python_path) file=$(TrigConfDBConnection_root)/$(tag)/lib<package>.so target=<target>
+
+macro_append Boost_linkopts " $(Boost_linkopts_python) "
+
+#macro hello_shlibflags $(TrigConfDBConnection_shlibflags)
+#library hello *.cxx
+
+library TrigConfDBConnection *.cxx
+
+apply_pattern installed_library
+
+apply_pattern declare_python_modules files="*.py"
+
+apply_pattern install_pylib target=libfrontier_client.so
+
+application TriggerFrontierClientTest ../src/exe/TriggerFrontierClientTest.cxx
+macro_append TriggerFrontierClientTest_dependencies TrigConfDBConnection
+

Trigger/TrigConfiguration/TrigConfDBConnection/python/__init__.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+

Trigger/TrigConfiguration/TrigConfDBConnection/python/frontier_client.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+
+
+from TrigConfDBConnection.libfrontier_client import Session as _Session
+from TrigConfDBConnection.libfrontier_client import AnyData as __AnyData
+#from TrigConfDBConnection.libfrontier_client import init, Connection, Request, encoding_t
+from TrigConfDBConnection.libfrontier_client import *
+
+class AnyData(__AnyData):
+    def __str__(self):
+        return "%s %s" % (self.type(), self.getString() )
+
+
+class Session:
+
+    def __getattr__(self,name):
+        # forward all calls to self.__session
+        if name in dir(self.__session):
+            return getattr(self.__session,name)
+        raise AttributeError,"Session instance does not attribute %s" % name
+
+    def __init__(self, conn):
+        self.__fieldNames = []
+        self.__fieldTypeStr = []
+        self.__fieldType = []
+        self.__numberOfFields = 0
+        self.__records = []
+        self.__session = _Session(conn)
+
+    def getData(self, requests):
+        self.__session.getData(requests)
+        self.__getHeader()
+        self.__getAllFields()
+        
+
+    def getHeader(self):
+        return (self.__fieldNames,self.__fieldTypeStr)
+
+
+    def getRecords(self):
+        return self.__records
+
+
+    def getRecords2(self):
+        return ( self.__mapRecord(record) for record in self.__records )
+
+
+    def __mapRecord(self,record):
+        return tuple( [ t(r) for (r,t) in zip(record,self.__fieldType) ] )
+        
+
+
+    def printHeader(self):
+        for i, (fname, ftype) in enumerate(zip(self.__fieldNames,self.__fieldTypeStr)):
+            print "%2i :  %-20s %-10s" % (i+1, fname, ftype)
+
+
+    def printRecords(self):
+        for i,record in enumerate(self.getRecords()):
+            print "record %4i :  %r" % (i+1, record)
+
+
+    def printRecords2(self):
+        for i,record in enumerate(self.getRecords2()):
+            print "record %4i :  %r" % (i+1, record)
+
+
+    def getNumberOfFields(self):
+        return self.__numberOfFields
+
+
+    def __getHeader(self):
+        self.__fieldNames = []
+        self.__fieldTypeStr = []
+        self.__fieldType = []
+        self.__numberOfFields = 0
+        # jump to start
+        self.__session.setCurrentLoad(1)
+        # read first field and move 
+        self.__session.next()
+        # and then the rest
+        while not self.isEOR():
+            self.__fieldNames     += [self.__session.assignString()]
+            self.__fieldTypeStr     += [self.__session.assignString()]
+            if self.__fieldTypeStr[-1].startswith("NUMBER"):
+                self.__fieldType += [int]
+            elif self.__fieldTypeStr[-1].startswith("VARCHAR"):
+                self.__fieldType += [str]
+            else:
+                self.__fieldType += [str]
+            self.__numberOfFields += 1
+
+
+    def __getAllFields(self):
+        self.__records = []
+
+        ad = AnyData()
+        while self.next():
+            record = tuple()
+            for k in range(self.__numberOfFields):
+                self.getAnyData(ad)
+                if   ad.type()==BLOB_TYPE_INT4:        record += (ad.getInt(),)
+                elif ad.type()==BLOB_TYPE_INT8:        record += (ad.getLongLong(),)
+                elif ad.type()==BLOB_TYPE_FLOAT:       record += (ad.getFloat(),)
+                elif ad.type()==BLOB_TYPE_DOUBLE:      record += (ad.getDouble(),)
+                elif ad.type()==BLOB_TYPE_TIME:        record += (ad.getLongLong(),)
+                elif ad.type()==BLOB_TYPE_ARRAY_BYTE:
+                    if not ad.getRawStrP():        record += ('NULL',)
+                    elif (ad.getRawStrS() == 0):   record += ('',)
+                    else:                          record += ('%s' % str_escape_quota(ad.getString()),)
+                else: 
+                    print "Error: unknown typeId ", ((int)(ad.type())),"\n"
+                    exit(1);
+                ad.clean()
+
+            self.__records += [record]
+            ad.clean()
+
+        if not self.isEOF():
+            print "Error: must be EOF here\n"
+            sys.exit(1);
+
+

Trigger/TrigConfiguration/TrigConfDBConnection/src/Bindings.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include <boost/python.hpp>
+
+#include "frontier_client/frontier-cpp.h"
+#include <iostream>
+
+namespace {
+   std::string escape_list="\\\'";
+   std::string
+   str_escape_quota(const std::string& str_orig) {
+      std::string str(str_orig);
+      std::string::size_type pos = 0;
+      for(;;) {
+         pos=str.find_first_of(escape_list,pos);
+         if(pos==str.npos) break;
+         str.insert(pos,1,'\\');    
+         pos+=2;
+      }
+      return str;
+   }
+}
+
+
+void getData(frontier::Session& s, const boost::python::list& l) {
+   typedef std::vector<const frontier::Request*> RequestList;
+   typedef std::vector<const frontier::Request*> RequestValueTypoe;
+
+   RequestList cl;
+
+   PyObject *obj_ptr = l.ptr();
+   boost::python::handle<> obj_iter(PyObject_GetIter(obj_ptr));
+   for(std::size_t i=0;;i++) {
+      boost::python::handle<> 
+         py_elem_hdl(boost::python::allow_null(PyIter_Next(obj_iter.get())));
+      
+      if (PyErr_Occurred()) boost::python::throw_error_already_set();
+      if (!py_elem_hdl.get()) break; // end of iteration
+
+      boost::python::object py_elem_obj(py_elem_hdl);
+      boost::python::extract<const frontier::Request*> elem_proxy(py_elem_obj);
+
+      bool success = elem_proxy.check();
+      if (success) {
+         cl.push_back(elem_proxy());
+      } else if (i == 0) {
+         break;
+      } else {
+         PyErr_SetString(PyExc_TypeError, "All items must be of same type.");
+         boost::python::throw_error_already_set();
+      }
+   }
+   s.getData(cl);
+}
+
+// // Determine if obj_ptr can be converted in a QString
+//   static void* convertible(PyObject* obj_ptr)
+//     {
+//       if (!PyString_Check(obj_ptr)) return 0;
+//       return obj_ptr;
+//     }
+
+
+PyObject*
+assignString(frontier::Session& s) {
+   std::string fieldvalue;
+   s.assignString(&fieldvalue);
+   return PyString_FromString(fieldvalue.c_str());
+}
+
+
+frontier::AnyData anydata;
+
+boost::python::object class_anydata;
+
+// frontier::AnyData
+// getAnyData1(frontier::Session& s, int not_eor) {
+//    s.getAnyData(&anydata, not_eor);
+//    return anydata; 
+// }
+
+// frontier::AnyData
+// getAnyData11(frontier::Session& s) { return getAnyData1(s,1); }
+
+int
+getAnyData2(frontier::Session & s, frontier::AnyData & anydata, int not_eor) {
+   return s.getAnyData(&anydata, not_eor);
+}
+
+int
+getAnyData21(frontier::Session & s, frontier::AnyData & anydata) { return getAnyData2(s, anydata, 1); }
+
+
+PyObject*
+getString(frontier::AnyData& data) {
+   std::string* str = data.getString();
+   if(str==0) return 0;
+   return PyString_FromString(data.getString()->c_str());
+}
+
+
+enum BLOB_TYPE {
+   BLOB_TYPE_BYTE       = 0,
+   BLOB_TYPE_INT4       = 1,
+   BLOB_TYPE_INT8       = 2,
+   BLOB_TYPE_FLOAT      = 3,
+   BLOB_TYPE_DOUBLE     = 4,
+   BLOB_TYPE_TIME       = 5,
+   BLOB_TYPE_ARRAY_BYTE = 6,
+   BLOB_TYPE_EOR        = 7,
+   BLOB_TYPE_NONE       = (1<<7),
+   BLOB_BIT_NULL        = (1<<7)
+};
+
+
+BOOST_PYTHON_MODULE(libfrontier_client)
+{
+   using namespace boost::python;
+
+   /***
+    * function frontier::init
+    ***/
+   int (*init1)() = &frontier::init;
+   int (*init2)(const std::string&, const std::string&) = &frontier::init;
+
+   def("init", init1, "Initializes frontier client.");
+   def("init", init2, 
+       "Initializes frontier client. \nloglevel can can be 'nolog', 'error', 'info' or 'warning' (which are equivalent), or anything else (treated as 'debug')",
+       args("logfilename", "loglevel"));
+   def("str_escape_quota", str_escape_quota, "add \\ before any \\\'", args("string"));
+   def("getFieldTypeName", frontier::getFieldTypeName, "returns string representation of field type", args("BLOB_TYPE"));
+
+
+   /***
+    * class frontier::Connection
+    ***/
+   class_<frontier::Connection>("Connection", init<const std::string&, const std::string*>("Connection with server url and proxy url", args("self","serverurl","proxyurl")) )
+      .def(init<const std::string&>("Connection with server url.", args("self","serverurl")))
+      .def(init<const std::list<std::string>&, const std::list<std::string>&>("Connection with list of server urls and list of proxy urls",args("self","serverurl","proxyurl")))
+      .def("setReload", &frontier::Connection::setReload)
+      .def("setDefaultParams", &frontier::Connection::setDefaultParams)
+      ;
+
+
+   /***
+    * To do the list wrapping we have two choices:
+    *   * wrap them with class_<> ourself or
+    *   * write to_python_converter() and some wrappers to extract<data> from python. 
+    * Our goal is to get to the working prototype as soon as we can. So in simplistic (a) approach 
+    * A full flexed wrapper is long and expensive, e.g. http://cci.lbl.gov/cctbx_sources/scitbx/array_family/boost_python/flex_wrapper.h
+    ***/
+
+
+   /***
+    * class frontier::Session
+    ***/
+
+   //BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(getAnyData_overloads, frontier::Session::getAnyData, 1, 2)
+   //BOOST_PYTHON_FUNCTION_OVERLOADS(getAnyData2_overloads, getAnyData2, 2, 3)
+      //    int (*init1)() = &frontier::init;
+      //    int (*init2)(const std::string&, const std::string&) = &frontier::init;
+
+
+   class_<frontier::Session>("Session", init<frontier::Connection*>() )
+      .def("getData", &getData)
+      .def("next", &frontier::Session::next)
+      .def("isEOR", &frontier::Session::isEOR)
+      .def("isEOF", &frontier::Session::isEOF)
+      .def("assignString", &assignString)
+      .def("getNumberOfRecords", &frontier::Session::getNumberOfRecords)
+      .def("getRecNum", &frontier::Session::getRecNum)
+      .def("setCurrentLoad", &frontier::Session::setCurrentLoad,
+           "Each Request generates a payload. Payload numbers started with 1.\nSo, to get data for the first Request call setCurrentLoad(1)",
+           args("self","n"))
+      .def("getAnyData", &frontier::Session::getAnyData)
+//       .def("getAnyData", &getAnyData1)
+//       .def("getAnyData", &getAnyData11)
+      .def("getAnyData", &getAnyData2)
+      .def("getAnyData", &getAnyData21)
+      ;
+
+   /***
+    * enum frontier::BLOB_TYPE
+    ***/
+   enum_<BLOB_TYPE>("BLOB_TYPE")
+      .value("BLOB_TYPE_BYTE",       BLOB_TYPE_BYTE      )
+      .value("BLOB_TYPE_INT4",       BLOB_TYPE_INT4      )
+      .value("BLOB_TYPE_INT8",       BLOB_TYPE_INT8      )
+      .value("BLOB_TYPE_FLOAT",      BLOB_TYPE_FLOAT     )
+      .value("BLOB_TYPE_DOUBLE",     BLOB_TYPE_DOUBLE    )
+      .value("BLOB_TYPE_TIME",       BLOB_TYPE_TIME      )
+      .value("BLOB_TYPE_ARRAY_BYTE", BLOB_TYPE_ARRAY_BYTE)
+      .value("BLOB_TYPE_EOR",        BLOB_TYPE_EOR       )
+      .value("BLOB_TYPE_NONE",       BLOB_TYPE_NONE      )
+      .value("BLOB_BIT_NULL",        BLOB_BIT_NULL       )
+      .export_values()
+      ;
+
+   /***
+    * enum frontier::encoding_t
+    ***/
+   enum_<frontier::encoding_t>("encoding_t")
+      .value("BLOB", frontier::BLOB)
+      .export_values()
+      ;
+
+   /***
+    * class frontier::AnyData
+    ***/
+   class_anydata = class_<frontier::AnyData>("AnyData")
+      .def("type",       &frontier::AnyData::type,        "type of data field")
+      .def("getRawI8",   &frontier::AnyData::getRawI8,    "type long long")
+      .def("getRawD",    &frontier::AnyData::getRawD,     "type double")
+      .def("getRawStrP", &frontier::AnyData::getRawStrP,  "type string")
+      .def("getRawStrS", &frontier::AnyData::getRawStrS,  "type unsigned int")
+      .def("getRawI4",   &frontier::AnyData::getRawI4,    "type int")
+      .def("getRawF",    &frontier::AnyData::getRawF,     "type float")
+      .def("getRawB",    &frontier::AnyData::getRawB,     "type char")
+      .def("getInt",     &frontier::AnyData::getInt,      "cast to type int")
+      .def("getLongLong",&frontier::AnyData::getLongLong, "cast to type long long")
+      .def("getFloat",   &frontier::AnyData::getFloat,    "cast to type float")
+      .def("getDouble",  &frontier::AnyData::getDouble,   "cast to type double")
+      .def("getString",  &getString,                      "cast to type string")
+      .def("clean",      &frontier::AnyData::clean,       "clean data")
+      ;
+
+   /***
+    * class frontier::Request
+    ***/
+   object class_req = class_<frontier::Request>("Request", init<const std::string&, frontier::encoding_t>() )
+      .def("addKey", &frontier::Request::addKey, "", args("self", "key", "value"))
+      .def("encodeParam", &frontier::Request::encodeParam, "", args("value"))
+      .def("setRetrieveZipLevel", &frontier::Request::setRetrieveZipLevel,
+           "Set the zip level of retrieved data\nlevel 0 is off, level 1 is fast, level 5 is normal, level 9 is best\ndefault is 5",
+           args("level"))
+      .staticmethod("encodeParam")
+      .staticmethod("setRetrieveZipLevel")
+      ;
+
+
+
+}

Trigger/TrigConfiguration/TrigConfDBConnection/src/HelloWorld.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "TrigConfDBConnection/HelloWorld.h"
+
+#include <iostream>
+
+HelloWorld::HelloWorld() :
+   fMessage("")
+{}
+
+
+HelloWorld::HelloWorld(const std::string& s) :
+   fMessage(s)
+{}
+
+
+HelloWorld::~HelloWorld()
+{}
+
+
+void
+HelloWorld::greetings()
+{
+   std::cout << fMessage << std::endl;
+}
+
+
+void
+HelloWorld::setGreetings(const std::string& s) {
+   fMessage = s;
+}
+
+
+void
+HelloWorld::setStrPtr(const std::string* p) {
+   fMessage = *p;
+}
+
+

Trigger/TrigConfiguration/TrigConfDBConnection/src/HelloWorldBindings.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include <boost/python.hpp>
+
+#include "TrigConfDBConnection/HelloWorld.h"
+
+
+BOOST_PYTHON_MODULE(hello_world)
+{
+   using namespace boost::python;
+   class_<HelloWorld>("HelloWorld", init<std::string>() )
+      .def("greetings", &HelloWorld::greetings)
+      .def("setGreetings", &HelloWorld::setGreetings)
+      .def("setStrPtr", &HelloWorld::setStrPtr)
+      ;
+}

Trigger/TrigConfiguration/TrigConfDBConnection/src/exe/TriggerFrontierClientTest.cxx

+/*
+ * frontier client test C++ main program that can load any query
+ * 
+ * Author: Sergey Kosyakov
+ *
+ * $Id: TriggerFrontierClientTest.cxx 524415 2012-11-04 19:27:29Z seuster $
+ *
+ * Copyright (c) 2009, FERMI NATIONAL ACCELERATOR LABORATORY
+ * All rights reserved. 
+ *
+ * For details of the Fermitools (BSD) license see Fermilab-2009.txt or
+ *  http://fermitools.fnal.gov/about/terms.html
+ *
+ */
+#include "frontier_client/frontier-cpp.h"
+#include "frontier_client/FrontierException.hpp"
+
+#include <iostream>
+#include <fstream>
+#include <stdexcept>
+#include <cstdlib>
+#include <cstring>
+
+#include <unistd.h>
+
+static std::string escape_list="\\\'";
+static std::string req_data="frontier_request:1:DEFAULT";
+
+static void str_escape_quota(std::string *str) {
+   std::string::size_type pos = 0;
+   while(1) {
+      pos=str->find_first_of(escape_list,pos);
+      if(pos==str->npos) return;
+      //std::cout<<"pos="<<pos<<'\n';
+      str->insert(pos,1,'\\');    
+      pos+=2;
+   }
+}
+
+ 
+static void print_usage(char **argv) {
+   std::cout<<"Usage: \n"<<argv[0]<<" -h\n\tPrint this info\n";
+   std::cout<<"\n"<<argv[0]<<" [-r] [-n] [-c N] [-F N] [-f file_name]\n";
+   std::cout<<"  if -f file_name is missing, reads query from stdin\n";
+   std::cout<<"  [-r] means to force a reload\n";
+   std::cout<<"  [-n] means do not print data\n";
+   std::cout<<"  [-c N] repeat the query N count times\n";
+   std::cout<<"  [-F N] fork after Nth repitition\n";
+}
+ 
+
+
+int main(int argc, char **argv) {
+   //char vc;
+   int vi;
+   long long vl;
+   float vf;
+   double vd;
+   std::string stringBuf;
+   std::string *vs=&stringBuf;
+   frontier::AnyData ad;
+   char *file_name=0;
+   int do_reload=0;
+   int do_print=1;
+   int repeat_count=1;
+   int fork_count=0;
+   int idx;
+   std::string sql("");
+  
+   try {
+      frontier::init();
+
+      // check for -h
+      for(int arg_ind=1; arg_ind<argc; arg_ind++)
+         if(strcmp(argv[arg_ind],"-h")==0) {
+            print_usage(argv);
+            return 0;
+         }
+      
+
+      for(int arg_ind=1; arg_ind<argc; arg_ind++) {
+
+         const char* arg = argv[arg_ind];
+
+         if(strcmp(arg,"-r")==0) {
+            do_reload=1;
+            continue;
+         }
+         
+         if(strcmp(arg,"-n")==0) {
+            do_print=0;
+            continue;
+         }
+
+         if(strcmp(arg,"-c")==0) {
+            if(argc==++arg_ind) {
+               std::cerr << "No number specified after -c option\n";
+               return 2;
+            }
+            repeat_count=atoi(argv[arg_ind]);
+            continue;
+         }
+
+         if(strcmp(arg,"-F")==0) {
+            if(argc==++arg_ind) {
+               std::cerr << "No number specified after -F option\n";
+               return 2;
+            }
+            fork_count=atoi(argv[arg_ind]);
+            continue;
+         }
+
+         if(strcmp(arg,"-f")==0) {
+            if(argc==++arg_ind) {
+               std::cerr << "No file name specified after -f option\n";
+               return 2;
+            }
+            file_name=argv[arg_ind];
+            continue;
+         }
+      }
+     
+      std::ifstream in_file;
+      if(file_name) {
+         in_file.open(file_name);
+         if(!in_file.is_open()) {
+            std::cerr << "Can not open file " << file_name << '\n';
+            return 2;
+         }
+      }
+
+      while(1) {
+         std::string tmp;      
+         if(file_name) {
+            if(!in_file.good()) break;
+            std::getline(in_file,tmp,'\n');
+         } else {
+            if(!std::cin.good()) break;
+            std::getline(std::cin,tmp,'\n');       
+         }
+         sql += tmp;
+      }
+      if(file_name) {in_file.close();}
+
+      std::cout<<"Entered:\n"<<sql<<'\n';
+    
+      std::string param=frontier::Request::encodeParam(sql);
+      std::cout<<"Param ["<<param<<"]\n";
+          
+      std::list<std::string> serverList;
+      //serverList.push_back("http://lxfs6043.cern.ch:8080/Frontier3D");
+      std::list<std::string> proxyList;
+      //frontier::DataSource ds(serverList, proxyList);
+      frontier::Connection con(serverList, proxyList);
+
+      for(idx=0;idx<repeat_count;idx++) {
+         if((fork_count>0)&&(idx==fork_count))
+            fork();
+
+         frontier::Session ses(&con);
+         con.setReload(do_reload);
+
+         frontier::Request req(req_data,frontier::BLOB);
+         req.addKey("p1",param);
+
+         std::vector<const frontier::Request*> vrq;
+         vrq.push_back(&req);
+         ses.getData(vrq);
+
+         ses.setCurrentLoad(1);
+      
+         int field_num=0;
+         
+         std::cout<<"\nObject fields:\n";
+         
+         ses.next();
+         // MetaData consists of one record with filed names.
+         // Let's go over all fields:
+         std::string name,type;
+      
+         while(!ses.isEOR()) {
+            ses.assignString(&name);
+            ses.assignString(&type);
+            ++field_num;
+            std::cout<<field_num<<" "<<(name)<<" "<<(type)<<std::endl;
+         }
+
+
+         // SECOND TIME
+//          ses.setCurrentLoad(1);
+//          field_num=0;
+//          std::cout<<"\nObject fields:\n";
+//          ses.next();
+//          while(!ses.isEOR()) {
+//             ses.assignString(&name);
+//             ses.assignString(&type);
+//             ++field_num;
+//             std::cout<<field_num<<" "<<(name)<<" "<<(type)<<std::endl;
+//          }
+         // END SECOND TIME
+
+
+
+	   
+         int nrec=ses.getNumberOfRecords();
+         std::cout<<"\nResult contains "<< nrec<<" objects.\n";
+	  
+         while(ses.next()) {
+            if(!do_print)continue;
+            for(int k=0;k<field_num;k++) {
+               ses.getAnyData(&ad);
+               switch(ad.type()) {
+                  //case frontier::BLOB_TYPE_BYTE:       vc=ses.getByte(); break;
+               case frontier::BLOB_TYPE_INT4:       
+                  vi=ad.getInt(); 
+                  std::cout<<vi; 
+                  break;
+               case frontier::BLOB_TYPE_INT8:       
+                  vl=ad.getLongLong(); 
+                  std::cout<<vl; 
+                  break;
+               case frontier::BLOB_TYPE_FLOAT:      
+                  vf=ad.getFloat(); 
+                  std::cout<<vf; 
+                  break;
+               case frontier::BLOB_TYPE_DOUBLE:     
+                  vd=ad.getDouble(); 
+                  std::cout<<vd; 
+                  break;
+               case frontier::BLOB_TYPE_TIME:       
+                  vl=ad.getLongLong(); 
+                  std::cout<<vl; 
+                  break;
+               case frontier::BLOB_TYPE_ARRAY_BYTE: 
+                  if(!ad.getRawStrP()) {
+                     std::cout<<"NULL";
+                  }
+                  else if (ad.getRawStrS() == 0)
+                     std::cout<<"''"; 
+                  else if (ad.getRawStrS() > 1000)
+                     std::cout<<'('<<ad.getRawStrS()<<" byte blob)"; 
+                  else {
+                     vs=ad.getString(); 
+                     str_escape_quota(vs);
+                     std::cout<<'\''<<(*vs)<<'\''<<'('<<ad.getRawStrS()<<')'; 
+                  }
+                  break;	  
+               default: 
+                  std::cout<<"Error: unknown typeId "<<((int)(ad.type()))<<"\n"; 
+                  exit(1);
+               }
+               if(k+1<field_num) {
+                  std::cout<<" ";
+               }
+               ad.clean();
+            }
+            ad.clean();
+            std::cout<<std::endl;
+         }
+         if(!ses.isEOF()) {
+            std::cout<<"Error: must be EOF here\n";
+            exit(1);
+         }
+      }
+   }
+   catch(const frontier::ConfigurationError& e) {
+      std::cout << "Frontier configuration error caught: " << e.what() << std::endl;
+      exit(1);
+   }
+   catch(const frontier::FrontierException& e) {
+      std::cout << "Frontier exception caught: " << e.what() << std::endl;
+      exit(1);
+   }
+   catch(std::exception& e) {
+      std::cout << "Error: " << e.what() << "\n";
+      exit(1);
+   }
+   catch(...) {
+      std::cout << "Unknown exception\n";
+      exit(1);
+   }
+
+   return 0;
+}

Trigger/TrigConfiguration/TrigConfDBConnection/test/testFrontierClient.py

+#!/usr/bin/env python
+
+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+def main(sql, doReload):
+
+    (ALL, VERBOSE, DEBUG, INFO, WARNING, ERROR, FATAL) = range(7)
+    from AthenaCommon.Logging import logging
+    log = logging.getLogger( "TrigConfigSvcUtils.py" )
+    log.setLevel(VERBOSE)
+
+    connection = "TRIGGERDBREPR"
+
+    from TriggerJobOpts.TriggerFlags import TriggerFlags as tf
+    tf.triggerUseFrontier = True
+
+    from TrigConfigSvc.TrigConfigSvcUtils import interpretConnection
+    connectionParameters = interpretConnection(connection)
+
+    print "Connection: ", connectionParameters
+
+    from TrigConfDBConnection import frontier_client as fc
+
+    fc.init("testFrontier.log","debug")
+
+    conn = fc.Connection(connectionParameters['url'])
+
+    session = fc.Session(conn)
+
+    conn.setReload(doReload)
+
+    req = fc.Request("frontier_request:1:DEFAULT", fc.encoding_t.BLOB)
+    param = fc.Request.encodeParam(sql)
+    req.addKey("p1",param)
+
+    session.getData([req])
+
+    session.printHeader()
+
+    nfield = session.getNumberOfFields()
+    print "\nNumber of fields:", nfield, "\n"
+
+    
+    nrec = session.getNumberOfRecords()
+    print "\nResult contains", nrec, "objects.\n"
+
+    session.printRecords2()
+
+    return 0
+
+
+
+if __name__=="__main__":
+    from sys import exit
+
+    doReload = True
+    sql = "select distinct SM.SMT_ID, SM.SMT_NAME, SM.SMT_VERSION, SM.SMT_COMMENT, SM.SMT_ORIGIN, SM.SMT_USERNAME, SM.SMT_STATUS from ATLAS_CONF_TRIGGER_REPR.SUPER_MASTER_TABLE SM"
+    
+    exit(main(sql=sql, doReload=doReload))
+    

Trigger/TrigConfiguration/TrigConfDBConnection/test/testHelloWorld.py

+#!/usr/bin/env python
+
+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+def main():
+    from TrigConfDBConnection import frontier_client as fc
+
+    hw = fc.HelloWorld("Hello world!")
+
+    hw.greetings()
+    
+    hw.setGreetings("Hello universe!")
+    
+    hw.greetings()
+
+    hw.setStrPtr("Hello All!")
+    
+    hw.greetings()
+
+    return 0
+
+if __name__=="__main__":
+    from sys import exit
+    exit(main())
+    

Trigger/TrigConfiguration/TrigConfDBConnection/test/testquery.txt

+select distinct SM.SMT_ID, SM.SMT_NAME, SM.SMT_VERSION, SM.SMT_COMMENT, SM.SMT_ORIGIN, SM.SMT_USERNAME, SM.SMT_STATUS from ATLAS_CONF_TRIGGER_REPR.SUPER_MASTER_TABLE SM