int main(int argc,char *argv[])
{
try
{
// Initialise the device server
//----------------------------------------
Tango::Util *tg = Tango::Util::init(argc,argv);
// Create the device server singleton
// which will create everything
//----------------------------------------
tg->server_init(false);
// Run the endless loop
//----------------------------------------
cout << "Ready to accept request" << endl;
tg->server_run();
}
catch (bad_alloc)
{
cout << "Can't allocate memory to store device object !!!" << endl;
cout << "Exiting" << endl;
}
catch (CORBA::Exception &e)
{
Tango::Except::print_exception(e);
cout << "Received a CORBA_Exception" << endl;
cout << "Exiting" << endl;
}
Tango::Util::instance()->server_cleanup();
return(0);
}
//--------------------------------------------------------
void WebSocketDSClass::erase_dynamic_attributes(const Tango::DevVarStringArray *devlist_ptr, vector<Tango::Attr *> &att_list)
{
Tango::Util *tg = Tango::Util::instance();
for (unsigned long i=0 ; i<devlist_ptr->length() ; i++)
{
Tango::DeviceImpl *dev_impl = tg->get_device_by_name(((string)(*devlist_ptr)[i]).c_str());
WebSocketDS *dev = static_cast<WebSocketDS *> (dev_impl);
vector<Tango::Attribute *> &dev_att_list = dev->get_device_attr()->get_attribute_list();
vector<Tango::Attribute *>::iterator ite_att;
for (ite_att=dev_att_list.begin() ; ite_att != dev_att_list.end() ; ++ite_att)
{
string att_name((*ite_att)->get_name_lower());
if ((att_name == "state") || (att_name == "status"))
continue;
vector<string>::iterator ite_str = find(defaultAttList.begin(), defaultAttList.end(), att_name);
if (ite_str == defaultAttList.end())
{
cout2 << att_name << " is a UNWANTED dynamic attribute for device " << (*devlist_ptr)[i] << endl;
Tango::Attribute &att = dev->get_device_attr()->get_attr_by_name(att_name.c_str());
dev->remove_attribute(att_list[att.get_attr_idx()], true, false);
--ite_att;
}
}
}
/*----- PROTECTED REGION ID(WebSocketDSClass::erase_dynamic_attributes) ENABLED START -----*/
/*----- PROTECTED REGION END -----*/ // WebSocketDSClass::erase_dynamic_attributes
}
void ZmqEventSupplier::create_event_socket()
{
if (event_pub_sock == NULL)
{
//
// Create the Publisher socket for real events and bind it
// If the user has specified one IP address on the command line,
// re-use it in the endpoint
//
event_pub_sock = new zmq::socket_t(zmq_context,ZMQ_PUB);
int linger = 0;
event_pub_sock->setsockopt(ZMQ_LINGER,&linger,sizeof(linger));
event_endpoint = "tcp://";
if (ip_specified == true)
{
event_endpoint = event_endpoint + user_ip + ':';
}
else
{
event_endpoint = event_endpoint + "*:";
}
//
// Set a publisher HWM
//
Tango::Util *tg = Tango::Util::instance();
DServer *admin_dev = tg->get_dserver_device();
int hwm = tg->get_user_pub_hwm();
if (hwm == -1)
hwm = admin_dev->zmq_pub_event_hwm;
event_pub_sock->setsockopt(ZMQ_SNDHWM,&hwm,sizeof(hwm));
//
// Bind the publisher socket to one ephemeral port
//
tango_bind(event_pub_sock,event_endpoint);
//
// If needed, replace * by host IP address in enpoint string
//
if (ip_specified == false)
{
event_endpoint.replace(6,1,host_ip);
}
}
}
Tango::DevLong DServer::un_lock_device(const Tango::DevVarLongStringArray *in_data)
{
NoSyncModelTangoMonitor mon(this);
cout4 << "In un_lock_device command for device " << in_data->svalue[0] << endl;
//
// Get client identification
//
Tango::client_addr *cl = get_client_ident();
if (cl == NULL)
{
Except::throw_exception((const char*)"API_CantGetClientIdent",
(const char*)"Cannot retrieve client identification",
(const char*)"DServer::un_lock_device");
}
cout4 << "Client identification = " << *cl << endl;
if ((cl->client_ident == false) && (in_data->lvalue[0] == 0))
{
Except::throw_exception((const char*)"API_ClientTooOld",
(const char*)"Your client cannot un-lock devices. You are using a too old Tango release. Please, update to tango V7 or more",
(const char*)"DServer::un_lock_device");
}
//
// Get the device and unlock it
//
DevLong ctr = 0;
Tango::Util *tg = Tango::Util::instance();
for (unsigned int loop = 0;loop < in_data->svalue.length();++loop)
{
string d_name(in_data->svalue[loop]);
if (d_name == get_name())
ctr = ext->lock_ctr;
else
{
DeviceImpl *the_dev = tg->get_device_by_name(d_name);
ctr = the_dev->unlock((bool)in_data->lvalue[0]);
}
if (loop > 0)
ctr = 0;
}
return ctr;
}
Tango::DevVarLongStringArray *DServer::dev_lock_status(Tango::ConstDevString dev_name)
{
NoSyncModelTangoMonitor mon(this);
cout4 << "In dev_lock_status command for device " << dev_name << endl;
//
// Get the device and get its lock status
//
string d_name(dev_name);
Tango::Util *tg = Tango::Util::instance();
DeviceImpl *the_dev = tg->get_device_by_name(d_name);
return the_dev->lock_status();
}
void ZmqEventSupplier::push_heartbeat_event()
{
time_t delta_time;
time_t now_time;
//
// Heartbeat - check wether a heartbeat event has been sent recently
// if not then send it. A heartbeat contains no data, it is used by the
// consumer to know that the supplier is still alive.
//
Tango::Util *tg = Tango::Util::instance();
DServer *adm_dev = tg->get_dserver_device();
now_time = time(NULL);
delta_time = now_time - adm_dev->last_heartbeat_zmq;
cout3 << "ZmqEventSupplier::push_heartbeat_event(): delta time since last heartbeat " << delta_time << endl;
if (heartbeat_name_init == false)
{
//
// Build heartbeat name
// This is something like
// tango://host:port/dserver/exec_name/inst_name.heartbeat when using DB
// tango://host:port/dserver/exec_name/inst_name#dbase=no.heartbeat when using file as database
//
heartbeat_event_name = heartbeat_event_name + adm_dev->get_full_name();
if (Util::_FileDb == true)
heartbeat_event_name = heartbeat_event_name + MODIFIER_DBASE_NO;
heartbeat_event_name = heartbeat_event_name + ".heartbeat";
heartbeat_name_init = true;
}
//
// We here compare delta_time to 8 and not to 10.
// This is necessary because, sometimes the polling thread is some
// milli second in advance. The computation here is done in seconds
// So, if the polling thread is in advance, delta_time computed in
// seconds will be 9 even if in reality it is 9,9
//
if (delta_time >= 8)
{
int nb_event = 1;
cout3 << "ZmqEventSupplier::push_heartbeat_event(): detected heartbeat event for " << heartbeat_event_name << endl;
cout3 << "ZmqEventSupplier::push_heartbeat_event(): delta _time " << delta_time << endl;
if (double_send_heartbeat == true)
{
nb_event = 2;
double_send_heartbeat = false;
}
while (nb_event != 0)
{
//
// Create zmq message
//
zmq::message_t name_mess(heartbeat_event_name.size());
memcpy(name_mess.data(),(void *)heartbeat_event_name.data(),heartbeat_event_name.size());
bool endian_mess_sent = false;
bool call_mess_sent = false;
try
{
//
// For debug and logging purposes
//
if (nb_event == 1)
{
if (omniORB::trace(20))
{
omniORB::logger log;
log << "ZMQ: Pushing some data" << '\n';
}
if (omniORB::trace(30))
{
{
omniORB::logger log;
log << "ZMQ: Event name" << '\n';
}
omni::giopStream::dumpbuf((unsigned char *)name_mess.data(),name_mess.size());
{
omniORB::logger log;
log << "ZMQ: Endianess" << '\n';
}
omni::giopStream::dumpbuf((unsigned char *)endian_mess.data(),endian_mess.size());
{
omniORB::logger log;
log << "ZMQ: Call info" << '\n';
}
omni::giopStream::dumpbuf((unsigned char *)heartbeat_call_mess.data(),heartbeat_call_mess.size());
}
}
//
// Push the event
//
adm_dev->last_heartbeat_zmq = now_time;
heartbeat_pub_sock->send(name_mess,ZMQ_SNDMORE);
heartbeat_pub_sock->send(endian_mess,ZMQ_SNDMORE);
endian_mess_sent = true;
heartbeat_pub_sock->send(heartbeat_call_mess,0);
call_mess_sent = true;
//
// For reference counting on zmq messages which do not have a local scope
//
endian_mess.copy(&endian_mess_2);
heartbeat_call_mess.copy(&heartbeat_call_mess_2);
nb_event--;
}
catch(...)
{
cout3 << "ZmqEventSupplier::push_heartbeat_event() failed !\n";
if (endian_mess_sent == true)
endian_mess.copy(&endian_mess_2);
if (call_mess_sent == true)
heartbeat_call_mess.copy(&heartbeat_call_mess_2);
TangoSys_OMemStream o;
o << "Can't push ZMQ heartbeat event for event ";
o << heartbeat_event_name;
if (zmq_errno() != 0)
o << "\nZmq error: " << zmq_strerror(zmq_errno()) << ends;
else
o << ends;
Except::throw_exception((const char *)"DServer_Events",
o.str(),
(const char *)"ZmqEventSupplier::push_heartbeat_event");
}
}
}
}
void ZmqEventSupplier::create_mcast_socket(string &mcast_data,int rate,McastSocketPub &ms)
{
//
// Create the Publisher socket for real events and bind it
// If the user has specified one IP address on the command line,
// re-use it in the endpoint
//
ms.pub_socket = new zmq::socket_t(zmq_context,ZMQ_PUB);
ms.endpoint = MCAST_PROT;
if (ip_specified == true)
{
ms.endpoint = ms.endpoint + user_ip + ';';
}
else
{
ApiUtil *au = ApiUtil::instance();
vector<string> adrs;
au->get_ip_from_if(adrs);
for (unsigned int i = 0;i < adrs.size();++i)
{
if (adrs[i].find("127.") == 0)
continue;
ms.endpoint = ms.endpoint + adrs[i] + ';';
break;
}
}
ms.endpoint = ms.endpoint + mcast_data;
int linger = 0;
ms.pub_socket->setsockopt(ZMQ_LINGER,&linger,sizeof(linger));
//
// Change multicast hops
//
Tango::Util *tg = Tango::Util::instance();
DServer *admin_dev = tg->get_dserver_device();
int nb_hops = admin_dev->mcast_hops;
ms.pub_socket->setsockopt(ZMQ_MULTICAST_HOPS,&nb_hops,sizeof(nb_hops));
//
// Change PGM rate to default value (80 Mbits/sec) or to user defined value
//
int local_rate = rate;
ms.pub_socket->setsockopt(ZMQ_RATE,&local_rate,sizeof(local_rate));
//
// Bind the publisher socket to the specified port
//
if (zmq_bind(*(ms.pub_socket),ms.endpoint.c_str()) != 0)
{
TangoSys_OMemStream o;
o << "Can't bind ZMQ socket with endpoint ";
o << ms.endpoint;
o << "\nZmq error: " << zmq_strerror(zmq_errno()) << ends;
Except::throw_exception((const char *)"DServer_Events",
o.str(),
(const char *)"ZmqEventSupplier::create_mcast_event_socket");
}
//
// The connection string returned to client does not need the host IP at all
//
ms.endpoint = MCAST_PROT + mcast_data;
}
int main(int argc, char *argv[])
{
INSTALL_CRASH_HANDLER;
Tango::Util *tg = 0;
try
{
//- bootstraping for yat Socket
yat::Socket::init();
//- bootstraping for galil stuffs
galil::ObjectManager::init();
// Initialise the device server
//----------------------------------------
tg = Tango::Util::init(argc,argv);
// Create the device server singleton
// which will create everything
//----------------------------------------
tg->server_init(false);
// Run the endless loop
//----------------------------------------
cout << "Ready to accept request" << endl;
tg->server_run();
}
catch (const bad_alloc&)
{
cout << "Can't allocate memory to store device object !!!" << endl;
cout << "Exiting" << endl;
}
catch (CORBA::Exception &e)
{
Tango::Except::print_exception(e);
cout << "Received a CORBA_Exception" << endl;
cout << "Exiting" << endl;
}
catch (...)
{
cout << "Received an unknown exception" << endl;
cout << "Exiting" << endl;
}
try
{
tg->server_cleanup();
}
catch (...)
{
//- ignore any error from "server_cleanup"
}
//- release galil stuffs
galil::ObjectManager::close();
//- bootstraping for yat Socket
yat::Socket::terminate();
return(0);
}
void DServer::class_factory()
{
#ifdef _TG_WINDOWS_
Tango::Util *tg = Tango::Util::instance();
string exe_name = tg->get_ds_exec_name();
exe_name = exe_name + ".exe";
HMODULE mod;
FARPROC proc;
convertor conv;
PTR tmp;
if (tg->is_py_ds() == false)
{
if ((mod = GetModuleHandle(exe_name.c_str())) == NULL)
{
cerr << "Oups, no class defined in this server. Exiting ..." << endl;
exit(-1);
}
}
else
{
if ((mod = GetModuleHandle(TANGO_PY_MOD_NAME)) == NULL)
{
cerr << "Oups, no class defined in this server. Exiting ..." << endl;
exit(-1);
}
}
//
// Use the mangled name to find the user DServer::class_factory method
//
// Due to the fact that on Windows 64 bits we have both _WIN32 and _WIN64
// defined, start by testing _WIN64 (See tango_config.h)
//
#ifdef _WIN64
if ((proc = GetProcAddress(mod,"?class_factory@DServer@Tango@@AEAAXXZ")) == NULL)
#elif _WIN32 /* WIN32 */
if ((proc = GetProcAddress(mod,"?class_factory@DServer@Tango@@AAEXXZ")) == NULL)
#endif
{
cerr << "Oups, no class defined in this server. Exiting ..." << endl;
exit(-1);
}
else
{
conv.d = &DServer::stop_polling;
conv.s = proc;
tmp = conv.d;
(this->*tmp)();
}
#elif __darwin__
Tango::Util *tg = Tango::Util::instance();
string exe_name = tg->get_ds_exec_name();
exe_name = exe_name;
void *mod;
void *proc;
convertor conv;
PTR tmp;
if (tg->is_py_ds() == false)
{
if ((mod = dlopen (exe_name.c_str(), RTLD_LAZY )) == NULL)
{
cerr << "Oups, no class defined in this server. Exiting ..." << endl;
exit(-1);
}
}
else
{
/*
if ((mod = GetModuleHandle(TANGO_PY_MOD_NAME)) == NULL)
{
cerr << "Oups, no class defined in this server. Exiting ..." << endl;
exit(-1);
}
*/
}
//
// Use the mangled name to find the user DServer::class_factory method
//
// Due to the fact that on Windows 64 bits we have both WIN32 and WIN64
// defined, start by testing WIN64 (See tango_config.h)
//
if ((proc = dlsym (mod,"_ZN5Tango7DServer13class_factoryEv")) == NULL)
{
cerr << "error : " << dlerror() << endl;
cerr << "Oups, no class defined in this server. Exiting ..." << endl;
exit(-1);
}
else
{
conv.d = &DServer::stop_polling;
conv.s = proc;
tmp = conv.d;
(this->*tmp)();
}
#else
cerr << "Oups, no class defined in this server. Exiting ..." << endl;
exit(-1);
#endif
}
void DServer::lock_device(const Tango::DevVarLongStringArray *in_data)
{
NoSyncModelTangoMonitor mon(this);
string dev_name(in_data->svalue[0]);
int lock_validity = in_data->lvalue[0];
cout4 << "In lock_device command for device " << dev_name << ", lock validity = " << lock_validity << endl;
//
// Get client identification
//
Tango::client_addr *cl = get_client_ident();
if (cl == NULL)
{
Except::throw_exception((const char*)"API_CantGetClientIdent",
(const char*)"Cannot retrieve client identification",
(const char*)"DServer::lock_device");
}
cout4 << "Client identification = " << *cl << endl;
if (cl->client_ident == false)
{
Except::throw_exception((const char*)"API_ClientTooOld",
(const char*)"Your client cannot lock devices. You are using a too old Tango release. Please, update to tango V7 or more",
(const char*)"DServer::lock_device");
}
//
// Transform device name to lower case
//
Tango::Util *tg = Tango::Util::instance();
string local_dev_name(get_name());
transform(local_dev_name.begin(),local_dev_name.end(),local_dev_name.begin(),::tolower);
string d_name_lower(dev_name);
transform(d_name_lower.begin(),d_name_lower.end(),d_name_lower.begin(),::tolower);
//
// Refuse to lock the admin device
//
if (d_name_lower == local_dev_name)
{
Except::throw_exception((const char *)"API_DeviceUnlockable",
(const char *)"Impossible to lock device server administration device",
(const char *)"DServer::lock_device");
}
//
// Get device ptr
//
DeviceImpl *the_dev;
the_dev = tg->get_device_by_name(dev_name);
//
// Refuse to lock database device
//
string &cl_name = the_dev->get_device_class()->get_name();
if (::strcmp(cl_name.c_str(),DATABASE_CLASS) == 0)
{
Except::throw_exception((const char *)"API_DeviceUnlockable",
(const char *)"Impossible to lock database device",
(const char *)"DServer::lock_device");
}
//
// Mark the device as locked
//
the_dev->lock(cl,lock_validity);
}
void DServer::re_lock_devices(const Tango::DevVarStringArray *dev_name_list)
{
NoSyncModelTangoMonitor mon(this);
cout4 << "In re_lock_devices command" << endl;
CORBA::ULong loop;
CORBA::ULong nb_dev = dev_name_list->length();
for (loop = 0;loop < nb_dev;loop++)
cout4 << "Device to re-lock: " << (*dev_name_list)[loop] << endl;
//
// Get client identification
//
Tango::client_addr *cl = get_client_ident();
if (cl == NULL)
{
Except::throw_exception((const char*)"API_CantGetClientIdent",
(const char*)"Cannot retrieve client identification",
(const char*)"DServer::re_lock_devices");
}
cout4 << "Client identification = " << *cl << endl;
if (cl->client_ident == false)
{
Except::throw_exception((const char*)"API_ClientTooOld",
(const char*)"Your client cannot re_lock devices. You are using a too old Tango release. Please, update to tango V7 or more",
(const char*)"DServer::re_lock_devices");
}
//
// ReLock the devices
// If we have an error in this loop, memorize it and throw the exception at the
// end of the loop
//
Tango::Util *tg = Tango::Util::instance();
DevErrorList errors;
long nb_error = 0;
for (loop = 0;loop < nb_dev;loop++)
{
string d_name((*dev_name_list)[loop]);
//
// Get device ptr
//
DeviceImpl *the_dev = NULL;
try
{
the_dev = tg->get_device_by_name(d_name);
}
catch (Tango::DevFailed &e)
{
errors.length(nb_error + 1);
errors[nb_error].desc = CORBA::string_dup(e.errors[0].desc.in());
errors[nb_error].reason = CORBA::string_dup(e.errors[0].reason.in());
errors[nb_error].origin = CORBA::string_dup(e.errors[0].origin.in());
errors[nb_error].severity = e.errors[0].severity;
nb_error++;
}
//
// ReLock the device
//
try
{
the_dev->relock(cl);
}
catch (Tango::DevFailed &e)
{
errors.length(nb_error + 1);
errors[nb_error].desc = CORBA::string_dup(e.errors[0].desc.in());
errors[nb_error].reason = CORBA::string_dup(e.errors[0].reason.in());
errors[nb_error].origin = CORBA::string_dup(e.errors[0].origin.in());
errors[nb_error].severity = e.errors[0].severity;
nb_error++;
}
}
//
// Throw the exception if we had one during the loop
//
if (nb_error != 0)
{
throw Tango::DevFailed(errors);
}
}
