Alarm.cpp

    {
       	ostringstream o;
#ifndef _ACCESS_NODE_D
		o << __func__<<": Parsing Failed, syntax error stopped at " << alm.formula_tree.stop << ends;
#else
		o << __func__<<": Parsing Failed, syntax error stopped at " << string(alm.formula_tree.stop, alarm_string.end()) << ends; //TODO
#endif
       	DEBUG_STREAM << o.str() << endl;
       	Tango::Except::throw_exception( \
				(const char*)"Parsing Failed!", \
				(const char*)o.str().c_str(), \
				(const char*)__func__, Tango::ERR);
    }


	//------------------------------
	//2: if alarm already exist and
	//   formula is not changed
	//------------------------------
#ifndef _RW_LOCK
	alarms.lock();
#else
	alarms.vlock->writerIn();
#endif
	alarm_container_t::iterator i = alarms.v_alarm.find(alm.name);
	if (i != alarms.v_alarm.end())
	{
		if(i->second.formula == alm.formula)
		{
			Tango::TimeVal ts = gettime();
			string cmd_name_full = alm.cmd_name_a + string(";") + alm.cmd_name_n;

			if ((alm.name.empty() == false) && \
					(alm.formula.empty() == false) && \
					((alm.lev==LEV_LOG)||(alm.lev==LEV_WARNING)|| \
					(alm.lev==LEV_FAULT)||(alm.lev.empty() == true))) {
				i->second.stat = S_NORMAL;
				i->second.ack = ACK;
				i->second.done = false;

				i->second.msg = alm.msg;
				i->second.lev = alm.lev;
				i->second.grp = alm.grp;
				//i->second.to_be_evaluated = alm.to_be_evaluated;
				i->second.time_threshold = alm.time_threshold;
				i->second.silent_time = alm.silent_time;
				i->second.silenced = alm.silenced;
				i->second.cmd_name_a = alm.cmd_name_a;
				i->second.cmd_dp_a = alm.cmd_dp_a;
				i->second.cmd_action_a = alm.cmd_action_a;
				//i->second.send_arg_a = alm.send_arg_a;
				i->second.cmd_name_n = alm.cmd_name_n;
				i->second.cmd_dp_n = alm.cmd_dp_n;
				i->second.cmd_action_n = alm.cmd_action_n;
				//i->second.send_arg_n = alm.send_arg_n;

			} else {
				ostringstream o;
				o << __func__<<": syntax error in '" << alarm_string << "'" << ends;
				WARN_STREAM << o.str() << endl;
#ifndef _RW_LOCK
				alarms.unlock();
#else
				alarms.vlock->writerOut();
#endif
				Tango::Except::throw_exception( \
						(const char*)o.str().c_str(), \
						(const char*)"", \
						(const char*)__func__, Tango::ERR);
			}


			alarms.log_alarm_db(TYPE_LOG_DESC_UPDATE, ts, alm.name, "", "",
					alm.formula, alm.time_threshold, alm.grp2str(), alm.lev, alm.msg, cmd_name_full, alm.silent_time);

			//delete proxy for actions
			if(i->second.dp_a)
				delete i->second.dp_a;
			i->second.dp_a = NULL;
			if(i->second.dp_n)
				delete i->second.dp_n;
			i->second.dp_n = NULL;

			if(alm.cmd_name_a.length() > 0)
			{
				try {
					i->second.dp_a = new Tango::DeviceProxy(i->second.cmd_dp_a);
					i->second.dp_a->ping();
					Tango::CommandInfo info = i->second.dp_a->command_query(i->second.cmd_action_a);
					if(info.in_type != Tango::DEV_STRING)
					{
						ostringstream err;
						err << "Error: command " << i->second.cmd_name_a << " does not accept a Tango::DevString as input value" << ends;
						ERROR_STREAM << __func__<<": " << err.str() << endl;
						set_internal_alarm(INTERNAL_ERROR, gettime(), err.str());
					}
					else
					{
						if(info.in_type == Tango::DEV_STRING)
							i->second.send_arg_a = true;
						else
							i->second.send_arg_a = false;
						DEBUG_STREAM << __func__<<": successfully connected to proxy=" << i->second.cmd_dp_a << " for action=" << i->second.cmd_action_a << endl;
					}
				} catch(Tango::DevFailed& e)
				{
					ostringstream err;
					err << alm.name << ": error connecting to device proxy=" << i->second.cmd_dp_a << ", err=" << e.errors[0].desc << ends;
					WARN_STREAM << __func__<<": " << err.str() << endl;
					set_internal_alarm(INTERNAL_ERROR, gettime(), err.str());
				}
			}
			if(alm.cmd_name_n.length() > 0)
			{
				try {
					i->second.dp_n = new Tango::DeviceProxy(i->second.cmd_dp_n);
					i->second.dp_n->ping();
					Tango::CommandInfo info = i->second.dp_n->command_query(i->second.cmd_action_a);
					if(info.in_type != Tango::DEV_STRING)
					{
						ostringstream err;
						err << "Error: command " << i->second.cmd_name_n << " does not accept a Tango::DevString as input value" << ends;
						ERROR_STREAM << __func__<<": " << err.str() << endl;
						set_internal_alarm(INTERNAL_ERROR, gettime(), err.str());
					}
					else
					{
						if(info.in_type == Tango::DEV_STRING)
							i->second.send_arg_n = true;
						else
							i->second.send_arg_n = false;
						DEBUG_STREAM << __func__<<": successfully connected to proxy=" << i->second.cmd_dp_n << " for action=" << i->second.cmd_action_n << endl;
					}
				} catch(Tango::DevFailed& e)
				{
					ostringstream err;
					err << alm.name << ": error connecting to device proxy=" << i->second.cmd_dp_n << ", err=" << e.errors[0].desc << ends;
					WARN_STREAM << __func__<<": " << err.str() << endl;
					set_internal_alarm(INTERNAL_ERROR, gettime(), err.str());
				}
			}
#ifndef _RW_LOCK
			alarms.unlock();
#else
			alarms.vlock->writerOut();
#endif
			return;
		}
	}
	else
	{
#ifndef _RW_LOCK
		alarms.unlock();
#else
		alarms.vlock->writerOut();
#endif
       	ostringstream o;
       	o << "Alarm '"<<alm.name<<"' not found" << ends;
       	DEBUG_STREAM << o.str() << endl;
       	Tango::Except::throw_exception( \
				(const char*)"Not found", \
				(const char*)o.str().c_str(), \
				(const char*)__func__, Tango::ERR);
	}
#ifndef _RW_LOCK
	alarms.unlock();
#else
	alarms.vlock->writerOut();
#endif

	//------------------------------
	//3: remove (set active=0 on db)
	//------------------------------
	remove((Tango::DevString)alm.name.c_str());
	//------------------------------
	//4: load modified alarm
	//------------------------------
	load(argin);

	prepare_alarm_attr();
	try
	{
		if(ds_num == 0)
		{
			//attr.set_value_date_quality(ds,0/*gettime()*/,Tango::ATTR_WARNING, ds_num, 0, false);
			struct timeval now;
			gettimeofday(&now,NULL);
			push_change_event("alarm",(char**)ds,now,Tango::ATTR_WARNING, ds_num, 0, false);
		}
		else
			//attr.set_value(ds, ds_num, 0, false);
			push_change_event("alarm",ds, ds_num, 0, false);
	} catch(Tango::DevFailed& e)
	{
		ostringstream err;
		err << "error pushing alarm change event err=" << e.errors[0].desc;
		INFO_STREAM << __func__<<": " << err.str() << endl;
	}

	/*----- PROTECTED REGION END -----*/	//	Alarm::modify
}
//--------------------------------------------------------
/**
 *	Method      : Alarm::add_dynamic_commands()
 *	Description : Create the dynamic commands if any
 *                for specified device.
 */
//--------------------------------------------------------
void Alarm::add_dynamic_commands()
{
	/*----- PROTECTED REGION ID(Alarm::add_dynamic_commands) ENABLED START -----*/
	
	//	Add your own code to create and add dynamic commands if any
	
	/*----- PROTECTED REGION END -----*/	//	Alarm::add_dynamic_commands
}

/*----- PROTECTED REGION ID(Alarm::namespace_ending) ENABLED START -----*/

//	Additional Methods
/*
 * private methods
 */
void Alarm::load_alarm(string alarm_string, alarm_t &alm, vector<string> &evn)
{	
	DEBUG_STREAM << "Alarm::load_alarm(): Creating Spirit Parser..." << endl;
	alarm_parse al_gr(alm);    //  Construct Spirit grammar		
	alm.name.clear();
	alm.attr_name.clear();
	alm.quality = Tango::ATTR_VALID;
	alm.ex_reason.clear();
	alm.ex_desc.clear();
	alm.ex_origin.clear();
	alm.formula.clear();
	alm.msg.clear();
	alm.lev.clear();
	alm.grp=0;
	alm.to_be_evaluated = false;
	alm.time_threshold = 0;
	alm.silent_time = -1;
	alm.silenced = -1;
	alm.cmd_name_a.clear();
	alm.cmd_dp_a.clear();
	alm.cmd_action_a.clear();
	alm.send_arg_a = false;
	alm.dp_a = NULL;	
	alm.cmd_name_n.clear();
	alm.cmd_dp_n.clear();
	alm.cmd_action_n.clear();
	alm.send_arg_n = false;	
	alm.dp_n = NULL;
	evn.clear();	

#ifndef _ACCESS_NODE_D	
	alm.formula_tree = ast_parse(alarm_string.c_str(), al_gr, space_p);	//parse string s with grammar al_gr, skipping white spaces	
#else	
	alm.formula_tree = 
	//boost::spirit::tree_parse_info< std::string::iterator, factory_t> tmp =
	ast_parse<factory_t>(alarm_string.begin(), alarm_string.end(), al_gr, space_p);	//parse string s with grammar al_gr, skipping white spaces
#endif
	if (alm.formula_tree.full)
	{
    	std::transform(alm.name.begin(), alm.name.end(), alm.name.begin(), (int(*)(int))tolower);		//transform to lowercase
    	//replace / with __
    	if(!alm.name.empty())
    	{
    		alm.attr_name = alm.name;
			size_t start_pos = 0;
			string from("/");
			string to("__");
			while((start_pos = alm.attr_name.find(from, start_pos)) != std::string::npos)
			{
				alm.attr_name.replace(start_pos, from.length(), to);
				start_pos += to.length(); // In case 'to' contains 'from', like replacing 'x' with 'yx'
			}
    	}
    	//std::transform(alm.formula.begin(), alm.formula.end(), alm.formula.begin(), (int(*)(int))tolower);		//transform to lowercase: incorrect, state has to be written uppercase
    	std::transform(alm.lev.begin(), alm.lev.end(), alm.lev.begin(), (int(*)(int))tolower);		//transform to lowercase
    	
    	if(alm.cmd_name_a.length() > 0)
    	{
			const char *c = alm.cmd_name_a.c_str();
			int j = 0;
			while (*c) {
				if (*c == '/')
					j++;
				if (j < 3)
					alm.cmd_dp_a.push_back(*c);
				else if (*c != '/')
					alm.cmd_action_a.push_back(*c);
				c++;
			}    
    	}
    	if(alm.cmd_name_n.length() > 0)
    	{
			const char *c = alm.cmd_name_n.c_str();
			int j = 0;
			while (*c) {
				if (*c == '/')
					j++;
				if (j < 3)
					alm.cmd_dp_n.push_back(*c);
				else if (*c != '/')
					alm.cmd_action_n.push_back(*c);
				c++;
			}    
		}

    	alm.silenced = (alm.silent_time > 0) ? 0 : -1;	//0: can be silenced, -1: cannot be silenced

		DEBUG_STREAM << "Parsing succeeded! ->" << alm.name << endl;
    	find_event_formula(alm.formula_tree,evn);				//populate event list found in this formula 
		ostringstream dbg_msg;
		dbg_msg << "In " << alm.name << " Event =";
		for (vector<string>::iterator i = evn.begin(); i != evn.end(); i++) 
			dbg_msg << *i << ", ";
		dbg_msg << ends;
		DEBUG_STREAM << dbg_msg.str() << endl;	
	}
    else
    {
       	ostringstream o;
#ifndef _ACCESS_NODE_D       	
		o << "Alarm::load_alarm(): Parsing Failed, syntax error stopped at " << alm.formula_tree.stop << ends;
#else       	
		o << "Alarm::load_alarm(): Parsing Failed, syntax error stopped at " << string(alm.formula_tree.stop, alarm_string.end()) << ends; //TODO
#endif		
       	DEBUG_STREAM << o.str() << endl;
       	Tango::Except::throw_exception( \
				(const char*)"Parsing Failed!", \
				(const char*)o.str().c_str(), \
				(const char*)"Alarm::load()", Tango::ERR);
    }	
	alm.ts = gettime();
	DEBUG_STREAM << "Alarm::load_alarm(): name     = '" << alm.name << "'" << endl;
	DEBUG_STREAM << "               attr_name     = '" << alm.attr_name << "'" << endl;
	DEBUG_STREAM << "               formula        = '" << alm.formula << "'" << endl;
	DEBUG_STREAM << "               time_threshold = '" << alm.time_threshold << "'" << endl;	
	DEBUG_STREAM << "               msg            = '" << alm.msg << "'" << endl;
	DEBUG_STREAM << "               grp            = '" << showbase << hex << alm.grp << "'=" << alm.grp2str() << endl;
	DEBUG_STREAM << "               silent_time    = '" << alm.silent_time << "'" << endl;
	DEBUG_STREAM << "               silenced       = '" << alm.silenced << "'" << endl;
	DEBUG_STREAM << "               lev            = '" << alm.lev << "'" << endl;
	DEBUG_STREAM << "               action_a       = '" << alm.cmd_name_a << "'" << endl;	
	DEBUG_STREAM << "               action_n       = '" << alm.cmd_name_n << "'" << endl;
	if ((alm.name.empty() == false) && \
			(alm.formula.empty() == false) && \
			((alm.lev==LEV_LOG)||(alm.lev==LEV_WARNING)|| \
			(alm.lev==LEV_FAULT)||(alm.lev.empty() == true))) {
		alm.stat = S_NORMAL;
		alm.ack = ACK;
		alm.done = false;
//		alm.grp = GR_DEFAULT;
//		alm.lev = LEV_DEFAULT;
	} else {
		ostringstream o;
		o << "Alarm::load_alarm(): syntax error in '" << alarm_string << "'" << ends;
		WARN_STREAM << o.str() << endl;
	
		Tango::Except::throw_exception( \
				(const char*)o.str().c_str(), \
				(const char*)"", \
				(const char*)"Alarm::load_alarm()", Tango::ERR);
	}
	add_AlarmState_dynamic_attribute(alm.attr_name);
	Tango::DevBoolean *attr_value = get_AlarmState_data_ptr(alm.attr_name);
	alm.attr_value = attr_value;
	if (alarms.exist(alm.name)) {
		ostringstream o;
		o << "Alarm::load_alarm(): alarm '" << alm.name << "' already exist" << ends;
		WARN_STREAM << o.str() << endl;
		Tango::Except::throw_exception( \
				(const char*)o.str().c_str(), \
				(const char*)o.str().c_str(), \
				(const char*)"Alarm::load_alarm()", Tango::ERR);
	}
}
void Alarm::init_alarms(map< string,vector<string> > &alarm_events)
{
#ifndef _RW_LOCK
	alarms.lock();
#else
	alarms.vlock->readerIn();
#endif
	if (alarms.v_alarm.empty() == false) 
	{
		for (alarm_container_t::iterator i = alarms.v_alarm.begin(); \
			i != alarms.v_alarm.end(); i++) 
		{
			map< string,vector<string> >::iterator f = 					//looking in map for alarm name as key
//				find(alarm_events->begin(), alarm_events->end(), i->name);
				alarm_events.find(i->second.name);
			if(f == alarm_events.end())
				continue;				//ERROR: alarm not found in alarm_event map
			DEBUG_STREAM << "Alarm::init_alarms(): found Alarm= " << i->second.name << endl;				
			for(vector<string>::iterator j = f->second.begin(); \
				j != f->second.end(); j++)
			{
				vector<event>::iterator found = \
						find(events->v_event.begin(), events->v_event.end(), (*j));
				DEBUG_STREAM << "Alarm::init_alarms(): looking in events table for Event= " << (*j) << endl;
				if (found != events->v_event.end())
				{
					i->second.insert(found->name);
					found->push_alarm(i->second.name);
					DEBUG_STREAM << "Alarm::init_alarms(): found Event= " << found->name << " <- Alarm= " << i->second.name << endl;					
					//break;		???
				}  /* if */
			}	/* for */
		}
	}
#ifndef _RW_LOCK
	alarms.unlock();
#else
	alarms.vlock->readerOut();
#endif
}
void Alarm::init_events(vector<string> &evn)
{
	if (evn.empty() == false) {		
		sort(evn.begin(), evn.end());
		vector<string>::iterator new_end = \
				unique(evn.begin(), evn.end());
		while (evn.end() != new_end) {
			evn.pop_back();
		}
		vector<string>::iterator j = evn.begin();
		while (j != evn.end()) {
			events->push_back(event(*j));
			j++;
		}
	}  /* if */
}
void Alarm::add_alarm(alarm_t& a) throw(string&)
{
	alarms.push_back(a);
	DEBUG_STREAM << "Alarm::add_alarm(): added alarm '" \
							 << a.name << "'" << endl;
}
void Alarm::add_event(alarm_t& a, vector<string> &evn) throw(string&)
{
	DEBUG_STREAM << "Alarm::add_event(): formula '" << a.formula << "'" << endl;
	/*
	 * get the list of all the events in the formula
	 */
	for (vector<string>::iterator j = evn.begin(); j != evn.end(); j++) {
		vector<event>::iterator k = \
				find(events->v_event.begin(), events->v_event.end(), *j);
		if (k != events->v_event.end()) {
			/*
			 * the event already exist; push alarm name
			 * into the per-event alarm list
			 */
			k->push_alarm(a.name);
			a.to_be_evaluated = true;
			DEBUG_STREAM << "Alarm::add_event(): '" << *j << "' found, added " \
									 << " alarm '"  << a.name << "' to list, valid=" << k->valid << endl;
#ifndef _RW_LOCK
			alarms.lock();
#else
			alarms.vlock->readerIn();
#endif
			alarm_container_t::iterator l = alarms.v_alarm.find(a.name);
			if (l != alarms.v_alarm.end()) 
			{
				l->second.insert(*j);			//insert event name in set<string> (s_event) in alarm_t 
			}
			else
			{
				WARN_STREAM << "Alarm::add_event():	error inserting event '" << *j << "' in set of alarm '" 
							<< a.name << "'" << endl;
			}
#ifndef _RW_LOCK
			alarms.unlock();
#else
			alarms.vlock->readerOut();
#endif
		} 
		else 
		{
			/*
			 * new event; add to event table
			 */
			event e(*j);
			events->push_back(e);
			/*
			 * update per-alarm event list
			 */
			DEBUG_STREAM << "Alarm::add_event(): adding '" << *j \
									 << "' to event list of alarm '" << a.name << "'" << endl;
#ifndef _RW_LOCK
			alarms.lock();
#else
			alarms.vlock->readerIn();
#endif
			alarm_container_t::iterator l = alarms.v_alarm.find(a.name);
			if (l != alarms.v_alarm.end()) 
			{			
				l->second.insert(*j);			//insert event name in set<string> in alarm_t 
			}
			else
			{
				WARN_STREAM << "Alarm::add_event():	error inserting event '" << *j << "' in set of alarm '" 
							<< a.name << "'" << endl;
			}
#ifndef _RW_LOCK
			alarms.unlock();
#else
			alarms.vlock->readerOut();
#endif
			/*
			 * now, for the just-added event, subscribe
			 */
			k = find(events->v_event.begin(), events->v_event.end(), *j);
			if (k != events->v_event.end())
			{
				k->push_alarm(a.name);
				try {
					k->dp = new Tango::DeviceProxy(k->device);
				} catch(Tango::DevFailed& e)
				{
					TangoSys_MemStream out_stream;
					out_stream << "Failed to connect device proxy=" << k->device << ends;
					k->pop_alarm(a.name);		//remove alarm/formula just added to event
					//events->v_event.pop_back();
					events->v_event.erase(k);	//remove event just added to event_table
					throw out_stream.str();
					/*Tango::Except::re_throw_exception(e,
						(const char *) "Error writing serial",
						out_stream.str(),
						(const char *) "Alarm::add_event()", Tango::ERR);*/
				}
				DEBUG_STREAM << "Alarm::add_event(): connected to DeviceProxy: " \
											 << k->device << endl;
				//now initialize value of this attribute
				try {
					Tango::DeviceAttribute attr_value;
					attr_value = k->dp->read_attribute(k->attribute);
					ecb.extract_values(&attr_value, k->value, k->type);
					k->valid = true;
					ostringstream msg;
					msg << "Alarm::add_event(): initial values of " << k->name << " = ";
					for(vector<double>::iterator dd=k->value.begin(); dd!=k->value.end(); dd++)
						msg << (*dd) << " ";
					msg << ", valid=" << k->valid << ends;
					DEBUG_STREAM << msg.str() << endl;
					//delete attr_value;
				} catch(Tango::DevFailed& e)
				{
					TangoSys_MemStream out_stream;
					out_stream << "Failed to read initial value of " << k->name << " = " << e.errors[0].desc << ends;
					k->valid = false;
#if TANGO_VER < 611		//if using subscribe stateless, alarm is not removed if it fails the subscription					
					k->pop_alarm(a.name);		//remove alarm/formula just added to event
					//events->v_event.pop_back();
					events->v_event.erase(k);	//remove event just added to event_table
					//delete attr_value;
#endif										
					throw out_stream.str();
				} catch(string & e) 
				{
					TangoSys_MemStream out_stream;
					out_stream << "Error reading initial value of " << k->name << " = " << e << ends;
					k->pop_alarm(a.name);		//remove alarm/formula just added to event
					//events->v_event.pop_back();
					events->v_event.erase(k);	//remove event just added to event_table
					//delete attr_value;					
					throw out_stream.str();
				}
			}
		}
	} //for (vector<string>::iterator j = evn.begin(); ...
}
void Alarm::subscribe_event(alarm_t& a, EventCallBack& ecb, vector<string> &evn) throw(string&)
{	
	//now subscribe all events
	for (vector<string>::iterator j = evn.begin(); j != evn.end(); j++) 
	{			
		vector<event>::iterator k = \
				find(events->v_event.begin(), events->v_event.end(), *j);
		if (k != events->v_event.end())
		{
			if(k->eid == 0)		//not subscribed yet
			{
				try {	
#if TANGO_VER < 611			
					k->eid = k->dp->subscribe_event(k->attribute, \
													Tango::CHANGE_EVENT, \
													&ecb, k->filter);
#else
					k->eid = k->dp->subscribe_event(k->attribute, \
													Tango::CHANGE_EVENT, \
													&ecb, k->filter,true);	//stateless subscription (doesn't fail if server not running)
#endif
					DEBUG_STREAM << "Alarm::add_event(): subscribed event for '" \
											 << k->attribute << "' attribute" << endl;											 
				} catch (...) {
					ostringstream o;
					o << "Alarm::add_event(): subscribe_event() failed for '" \
						<< *j << "'" << ends;
					WARN_STREAM << o.str() << endl;
					k->pop_alarm(a.name);		//remove alarm/formula just added to event
					//events->v_event.pop_back();
					events->v_event.erase(k);	//remove event just added to event_table
					delete k->dp;
					k->dp = NULL;					
					throw o.str();
				}
			} 
		}  // if (k != events->v_event.end())/
	}  // for 				
}
/*
 * because called asynchronously by alarm evaluating thread
 * will use an alarm to report errors
 */
void Alarm::do_alarm(bei_t& e)
{
	bool changed=true;
	int num_changed=0;
	//if (e.name == INTERNAL_ERROR) {
	if(e.type == TYPE_TANGO_ERR || e.type == TYPE_GENERIC_ERR)
	{
		ostringstream o;
		o << e.msg << endl;
		WARN_STREAM << "Alarm::do_alarm(): " <<  o.str() << endl;
		vector<event>::iterator found_ev = \
			find(events->v_event.begin(), events->v_event.end(), e.ev_name);
		if (found_ev == events->v_event.end())
		{
			//try to remove network domain and FQDN
			string ev_name_str(e.ev_name);
			string::size_type pos_slash = ev_name_str.find("tango://");
			if (pos_slash != string::npos)	//FQDN!!
			{
				//first remove network domain if any
				string::size_type pos_dot = ev_name_str.find(".",8);	//look for first . after tango://
				string::size_type pos_colon = ev_name_str.find(":",8);	//look for first : after tango://
				pos_slash = ev_name_str.find('/',8);					//look for first / after tango://
				if(pos_dot < pos_slash && pos_dot != string::npos && pos_colon != string::npos && pos_slash != string::npos)	//dot is in the TANGO_HOST part
				{
					string ev_name_str_no_domain = ev_name_str.substr(0,pos_dot) + ev_name_str.substr(pos_colon);
					DEBUG_STREAM << __FUNCTION__ << " event "<< e.ev_name << " not found, trying without domain: " << ev_name_str_no_domain;
					found_ev = \
								find(events->v_event.begin(), events->v_event.end(), ev_name_str_no_domain);
				}
				if (found_ev == events->v_event.end() && pos_slash != string::npos)
				{
					ev_name_str = ev_name_str.substr(pos_slash + 1);//remove FQDN
					DEBUG_STREAM << __FUNCTION__ << " event "<< e.ev_name << " not found, trying without fqdn: " << ev_name_str;
					found_ev = \
								find(events->v_event.begin(), events->v_event.end(), ev_name_str);
				}
			}

			if (found_ev == events->v_event.end())
			{
				/*
				 * shouldn't happen!!!
				 */
				ostringstream o;
				o <<  "TANGO Error but event '" \
					<< e.ev_name << "' not found in event table!" << ends;
				WARN_STREAM << "Alarm::do_alarm(): " << o.str() << endl;
				set_internal_alarm(e.ev_name, gettime(), o.str());
			}
		}
		if(found_ev != events->v_event.end())
		{
			found_ev->err_counter++;
			if(found_ev->err_counter >= errThreshold)
			{
				set_internal_alarm(e.ev_name, gettime(), o.str(), errThreshold);
			}
			if(e.type == TYPE_TANGO_ERR)
				found_ev->ex_reason = string("Event_ERROR");
			else
				found_ev->ex_reason = string("Alarm_ERROR");
			found_ev->ex_desc = o.str();
			found_ev->ex_origin = e.ev_name;
			//LOOP ALARMS IN WHICH THIS EVENT IS USED
			vector<string>::iterator j = found_ev->m_alarm.begin();
			while (j != found_ev->m_alarm.end())
			{
#ifndef _RW_LOCK
				alarms.lock();
#else
				alarms.vlock->readerIn();
#endif
				alarm_container_t::iterator it = alarms.v_alarm.find(*j);
				if(it != alarms.v_alarm.end())
				{
					try
					{
						if(e.type == TYPE_TANGO_ERR)
							it->second.ex_reason = found_ev->ex_reason;
						else
							it->second.ex_reason = found_ev->ex_reason;
						it->second.ex_desc = found_ev->ex_desc;
						it->second.ex_origin = found_ev->ex_origin;
						Tango::DevErrorList errors(1);
						errors.length(1);
						errors[0].desc = CORBA::string_dup(it->second.ex_desc.c_str());
						errors[0].severity = Tango::ERR;
						errors[0].reason = CORBA::string_dup(it->second.ex_reason.c_str());
						errors[0].origin = CORBA::string_dup(it->second.ex_origin.c_str());
						Tango::DevFailed except(errors);
						DEBUG_STREAM << "PUSHING EXCEPTION FOR " << it->second.attr_name << " " << it->second.ex_desc << "-" << it->second.ex_reason << "-" << it->second.ex_origin << endl;
						push_change_event(it->second.attr_name, &except);
						push_archive_event(it->second.attr_name, &except);
					}catch(Tango::DevFailed &ex)
					{}
				}
#ifndef _RW_LOCK
          		alarms.unlock();
#else
          		alarms.vlock->readerOut();
#endif
          		j++;
			}
		}
		return;
	}	
	DEBUG_STREAM << "Alarm::do_alarm(): arrived event=" << e.ev_name << endl;
	
	formula_res_t res;
	vector<event>::iterator found = \
			find(events->v_event.begin(), events->v_event.end(), e.ev_name);
	if (found == events->v_event.end())
	{
		//try to remove network domain and FQDN
		string ev_name_str(e.ev_name);
		string::size_type pos_slash = ev_name_str.find("tango://");
		if (pos_slash != string::npos)	//FQDN!!
		{
			//first remove network domain if any
			string::size_type pos_dot = ev_name_str.find(".",8);	//look for first . after tango://
			string::size_type pos_colon = ev_name_str.find(":",8);	//look for first : after tango://
			pos_slash = ev_name_str.find('/',8);					//look for first / after tango://
			if(pos_dot < pos_slash && pos_dot != string::npos && pos_colon != string::npos && pos_slash != string::npos)	//dot is in the TANGO_HOST part
			{
				string ev_name_str_no_domain = ev_name_str.substr(0,pos_dot) + ev_name_str.substr(pos_colon);
				DEBUG_STREAM << __FUNCTION__ << " event "<< e.ev_name << " not found, trying without domain: " << ev_name_str_no_domain;
				found = \
							find(events->v_event.begin(), events->v_event.end(), ev_name_str_no_domain);
			}
			if (found == events->v_event.end() && pos_slash != string::npos)
			{
				ev_name_str = ev_name_str.substr(pos_slash + 1);//remove FQDN
				DEBUG_STREAM << __FUNCTION__ << " event "<< e.ev_name << " not found, trying without fqdn: " << ev_name_str;
				found = \
							find(events->v_event.begin(), events->v_event.end(), ev_name_str);
			}
		}

		if (found == events->v_event.end())
		{
			/*
			 * shouldn't happen!!!
			 */
			ostringstream o;
			o <<  "event '" \
				<< e.ev_name << "' not found in event table!" << ends;
			WARN_STREAM << "Alarm::do_alarm(): " << o.str() << endl;
			set_internal_alarm(INTERNAL_ERROR, gettime(), o.str());
		}
	}
	if (found != events->v_event.end())
	{	
		found->value = e.value;
		found->quality = e.quality;
		//found->errors = e.errors;
		found->ex_reason = e.ex_reason;
		found->ex_desc = e.ex_desc;
		found->ex_origin = e.ex_origin;
		found->valid = true;
		found->ts = e.ts;
		found->type = e.type;
		found->err_counter = 0;
		vector<string>::iterator j = found->m_alarm.begin();
		while (j != found->m_alarm.end()) 
		{    	
			//alarm_container_t::iterator it = alarms.v_alarm.find(j->first);
#ifndef _RW_LOCK
			alarms.lock();
#else
			alarms.vlock->readerIn();
#endif
			alarm_container_t::iterator it = alarms.v_alarm.find(*j);
			if(it != alarms.v_alarm.end())
			{
				string tmpname=it->first;
				try {   	
    				string attr_values;
    				res = eval_formula(it->second.formula_tree, attr_values);
          			DEBUG_STREAM << "Alarm::do_alarm(): Evaluation of " << it->second.formula << "; result=" << res.value << " quality=" << res.quality << endl;
#ifndef _RW_LOCK
          			alarms.unlock();
#else
          			alarms.vlock->readerOut();
#endif
          			changed = alarms.update(tmpname, found->ts, res, attr_values, it->second.grp2str(), it->second.msg, it->second.formula); 		//update internal structure and log to db
          			if(changed)
          				num_changed++;
          			Tango::DevBoolean *attr_value = get_AlarmState_data_ptr(it->second.attr_name);
          			*attr_value = (it->second.stat == S_ALARM);
    				try
    				{	//DevFailed for push events
    					if(it->second.ex_reason.length() == 0)
    					{
    						timeval now;
    						gettimeofday(&now, NULL);
    						push_change_event(it->second.attr_name,(Tango::DevBoolean *)attr_value,now,(Tango::AttrQuality)it->second.quality, 1/*size*/, 0, false);
    						push_archive_event(it->second.attr_name,(Tango::DevBoolean *)attr_value,now,(Tango::AttrQuality)it->second.quality, 1/*size*/, 0, false);
    					}
    					else
    					{
    						Tango::DevErrorList errors(1);
    						errors.length(1);
    						errors[0].desc = CORBA::string_dup(it->second.ex_desc.c_str());
    						errors[0].severity = Tango::ERR;
    						errors[0].reason = CORBA::string_dup(it->second.ex_reason.c_str());
    						errors[0].origin = CORBA::string_dup(it->second.ex_origin.c_str());
    						Tango::DevFailed except(errors);
        					push_change_event(it->second.attr_name, &except);
        					push_archive_event(it->second.attr_name, &except);
    					}
    				} catch(Tango::DevFailed & ex)
    				{
    					WARN_STREAM << "Alarm::do_alarm(): EXCEPTION PUSHING EVENTS: " << ex.errors[0].desc << endl;
    				}
				} catch(std::out_of_range& ex)
				{
#ifndef _RW_LOCK
          			alarms.unlock();
#else
          			alarms.vlock->readerOut();
#endif
					ostringstream o;
					o << tmpname << ": in formula array index out of range!" << ends;
					WARN_STREAM << "Alarm::do_alarm(): " << o.str() << endl;
					set_internal_alarm(INTERNAL_ERROR, gettime(), o.str());
    				try
    				{	//DevFailed for push events
						Tango::DevErrorList errors(1);
						errors.length(1);
						it->second.ex_reason = string("OUT_OF_RANGE");
						it->second.ex_desc = e.ev_name + ": " + o.str();
						it->second.ex_origin = e.ev_name;
						errors[0].desc = CORBA::string_dup(it->second.ex_desc.c_str());
						errors[0].severity = Tango::ERR;
						errors[0].reason = CORBA::string_dup(it->second.ex_reason.c_str());
						errors[0].origin = CORBA::string_dup(it->second.ex_origin.c_str());
						Tango::DevFailed except(errors);
    					push_change_event(it->second.attr_name, &except);
    					push_archive_event(it->second.attr_name, &except);
    				} catch(Tango::DevFailed & ex)
    				{
    					WARN_STREAM << "Alarm::do_alarm(): EXCEPTION PUSHING EVENTS: " << ex.errors[0].desc << endl;
    				}
				} catch(string & ex)
				{
#ifndef _RW_LOCK
          			alarms.unlock();
#else
          			alarms.vlock->readerOut();
#endif
					ostringstream o;
					o << tmpname << ": in formula err=" << ex << ends;
					WARN_STREAM << "Alarm::do_alarm(): " << o.str() << endl;
					set_internal_alarm(INTERNAL_ERROR, gettime(), o.str());
    				try
    				{	//DevFailed for push events
						Tango::DevErrorList errors(1);
						errors.length(1);
						it->second.ex_reason = string("FORMULA_ERROR");
						it->second.ex_desc = e.ev_name + ": " + o.str();
						it->second.ex_origin = e.ev_name;
						errors[0].desc = CORBA::string_dup(it->second.ex_desc.c_str());
						errors[0].severity = Tango::ERR;
						errors[0].reason = CORBA::string_dup(it->second.ex_reason.c_str());
						errors[0].origin = CORBA::string_dup(it->second.ex_origin.c_str());
						Tango::DevFailed except(errors);
    					push_change_event(it->second.attr_name, &except);
    					push_archive_event(it->second.attr_name, &except);
    				} catch(Tango::DevFailed & ex)
    				{
    					WARN_STREAM << "Alarm::do_alarm(): EXCEPTION PUSHING EVENTS: " << ex.errors[0].desc << endl;
    				}
				}
			}
			else
			{
#ifndef _RW_LOCK
				alarms.unlock();
#else
				alarms.vlock->readerOut();
#endif
				ostringstream o;
				//o << j->first << ": not found formula in alarm table" << ends;
				o << (*j) << ": not found formula in alarm table" << ends;
				WARN_STREAM << "Alarm::do_alarm(): " << o.str() << endl;
				set_internal_alarm(INTERNAL_ERROR, gettime(), o.str());
				try
				{	//DevFailed for push events
					Tango::DevErrorList errors(1);
					errors.length(1);
					it->second.ex_reason = string("NOT_FOUND");
					it->second.ex_desc = e.ev_name + ": " + o.str();
					it->second.ex_origin = e.ev_name;
					errors[0].desc = CORBA::string_dup(it->second.ex_desc.c_str());
					errors[0].severity = Tango::ERR;
					errors[0].reason = CORBA::string_dup(it->second.ex_reason.c_str());
					errors[0].origin = CORBA::string_dup(it->second.ex_origin.c_str());
					Tango::DevFailed except(errors);
					push_change_event(it->second.attr_name, &except);
					push_archive_event(it->second.attr_name, &except);
				} catch(Tango::DevFailed & ex)
				{
					WARN_STREAM << "Alarm::do_alarm(): EXCEPTION PUSHING EVENTS: " << ex.errors[0].desc << endl;
				}
			}
			j++;
		}

		prepare_alarm_attr();
		if(num_changed==0)
			return;
		if(ds_num == 0)
		{
			//attr.set_value_date_quality(ds,0/*gettime()*/,Tango::ATTR_WARNING, ds_num, 0, false);
			struct timeval now;
			gettimeofday(&now,NULL);
			push_change_event("alarm",(char**)ds,now,Tango::ATTR_WARNING, ds_num, 0, false);
		}
		else
			//attr.set_value(ds, ds_num, 0, false);
			push_change_event("alarm",ds, ds_num, 0, false);

	}
}  /* do_alarm() */

void Alarm::timer_update()
{
	bool changed=true;
	//DEBUG_STREAM << "Alarm::timer_update(): entering..." << endl;
	try {
		changed=alarms.timer_update();
	} catch(string & e)
	{
		ostringstream o;
		o << "Error checking time thresholds and updating alarm status=" << e << ends;
		WARN_STREAM << "Alarm::timer_update(): " << o.str() << endl;
		set_internal_alarm(INTERNAL_ERROR, gettime(), o.str());
/*		Tango::DevErrorList errors(1);
		errors.length(1);
		it->second.ex_reason = string("INTERNAL_ERROR");
		it->second.ex_desc = o.str();
		it->second.ex_origin = string("Alarm::timer_update");
		errors[0].desc = CORBA::string_dup(it->second.ex_desc.c_str());
		errors[0].severity = Tango::ERR;
		errors[0].reason = CORBA::string_dup(it->second.ex_reason.c_str());
		errors[0].origin = CORBA::string_dup(it->second.ex_origin.c_str());
		Tango::DevFailed except(errors);
		push_change_event(it->second.attr_name, &except);
		push_archive_event(it->second.attr_name, &except);*/
	}

	prepare_alarm_attr();
	if(!changed)
		return;
	try
	{
		if(ds_num == 0)
		{
			//attr.set_value_date_quality(ds,0/*gettime()*/,Tango::ATTR_WARNING, ds_num, 0, false);
			struct timeval now;
			gettimeofday(&now,NULL);
			push_change_event("alarm",(char**)ds,now,Tango::ATTR_WARNING, ds_num, 0, false);
		}
		else
			//attr.set_value(ds, ds_num, 0, false);
			push_change_event("alarm",ds, ds_num, 0, false);
	} catch(Tango::DevFailed& e)
	{
		ostringstream err;
		err << "error pushing alarm change event err=" << e.errors[0].desc;
		INFO_STREAM << __func__<<": " << err.str() << endl;
	}
}

bool Alarm::remove_alarm(string& s) throw(string&)
{
#ifndef _RW_LOCK
	alarms.lock();
#else
	alarms.vlock->writerIn();
#endif
	alarm_container_t::iterator i = alarms.v_alarm.find(s);
	if (i != alarms.v_alarm.end()) {