TAO_Implementation_Repository: Locator_Repository.cpp File Reference

00121 {
00122   CORBA::ULong sz = in.size ();
00123   out.length (sz);
00124   for (CORBA::ULong i = 0; i < sz; ++i)
00125     {
00126       out[i].name = in[i].name.c_str ();
00127       out[i].value = in[i].value.c_str ();
00128     }
00129 }

00031 {
00032   ACE_CString ret(s);
00033   for (size_t i = 0; i < ret.length (); ++i)
00034     {
00035       ret[i] = static_cast<char>(ACE_OS::ace_tolower (s[i]));
00036     }
00037   return ret;
00038 }

00041 {
00042   ACE_Configuration_Section_Key root;
00043   int err = config.open_section (config.root_section (), ACTIVATORS_ROOT_KEY, 0, root);
00044   if (err == 0)
00045     {
00046       int index = 0;
00047       ACE_CString name;
00048       while (config.enumerate_sections (root, index, name) == 0)
00049         {
00050           ACE_CString ior;
00051           u_int token;
00052 
00053           ACE_Configuration_Section_Key key;
00054 
00055           // Can't fail, because we're enumerating
00056           config.open_section (root, name.c_str(), 0, key);
00057 
00058           config.get_string_value (key, IOR, ior);
00059           config.get_integer_value (key, TOKEN, token);
00060 
00061           Activator_Info_Ptr info (new Activator_Info (name, token, ior));
00062           map.bind (lcase (name), info);
00063           index++;
00064         }
00065     }
00066 }

00112 {
00113   loadServersAsBinary (config, repo.servers ());
00114   loadActivatorsAsBinary (config, repo.activators ());
00115 }

00169 {
00170   ACEXML_FileCharStream* fstm = new ACEXML_FileCharStream; // xml input source will take ownership
00171 
00172   if (fstm->open (fname.c_str()) != 0)
00173     {
00174       // This is not a real error. The xml file may not exist yet.
00175       delete fstm;
00176       return 0;
00177     }
00178 
00179   Server_Repo_XML_Callback cb (repo);
00180 
00181   Locator_XMLHandler handler (cb);
00182 
00183   ACEXML_Parser parser;
00184 
00185   // InputSource takes ownership
00186   ACEXML_InputSource input (fstm);
00187 
00188   parser.setContentHandler (&handler);
00189   parser.setDTDHandler (&handler);
00190   parser.setErrorHandler (&handler);
00191   parser.setEntityResolver (&handler);
00192 
00193   ACEXML_TRY_NEW_ENV
00194     {
00195       parser.parse (&input ACEXML_ENV_ARG_PARAMETER);
00196       ACEXML_TRY_CHECK;
00197     }
00198   ACEXML_CATCH (ACEXML_Exception, ex)
00199     {
00200       ACE_ERROR ((LM_ERROR, "Error during load of ImR persistence xml file."));
00201       ex.print ();
00202       return -1;
00203     }
00204   ACEXML_ENDTRY;
00205   return 0;
00206 }

00069 {
00070   ACE_Configuration_Section_Key root;
00071   int err = config.open_section (config.root_section (), SERVERS_ROOT_KEY, 0, root);
00072   if (err == 0)
00073     {
00074       int index = 0;
00075       ACE_CString name;
00076       while (config.enumerate_sections (root, index, name) == 0)
00077         {
00078           ACE_CString cmdline, dir, envstr, partial_ior, ior, aname;
00079           u_int amodeint = ImplementationRepository::MANUAL;
00080           u_int start_limit;
00081 
00082           ACE_Configuration_Section_Key key;
00083 
00084           // Can't fail, because we're enumerating
00085           config.open_section (root, name.c_str (), 0, key);
00086 
00087           // Ignore any missing values. Server name is enough on its own.
00088           config.get_string_value (key, ACTIVATOR, aname);
00089           config.get_string_value (key, STARTUP_COMMAND, cmdline);
00090           config.get_string_value (key, WORKING_DIR, dir);
00091           config.get_string_value (key, ENVIRONMENT, envstr);
00092           config.get_integer_value(key, ACTIVATION, amodeint);
00093           config.get_string_value (key, PARTIAL_IOR, partial_ior);
00094           config.get_string_value (key, IOR, ior);
00095           config.get_integer_value(key, START_LIMIT, start_limit);
00096 
00097           ImplementationRepository::ActivationMode amode =
00098             static_cast <ImplementationRepository::ActivationMode> (amodeint);
00099 
00100           ImplementationRepository::EnvironmentList env_vars =
00101             ImR_Utils::parseEnvList (envstr);
00102 
00103           Server_Info_Ptr info (new Server_Info(name, aname, cmdline,
00104             env_vars, dir, amode, start_limit, partial_ior, ior));
00105           map.bind (name, info);
00106           index++;
00107         }
00108     }
00109 }

00210 {
00211   FILE* fp = ACE_OS::fopen (fname.c_str (), "w");
00212   if (fp == 0)
00213     {
00214       ACE_ERROR ((LM_ERROR, "Couldn't write to file %s\n", fname.c_str()));
00215       return;
00216     }
00217   ACE_OS::fprintf (fp,"<?xml version=\"1.0\"?>\n");
00218   ACE_OS::fprintf (fp,"<%s>\n", Locator_XMLHandler::ROOT_TAG);
00219 
00220   // Save servers
00221   Locator_Repository::SIMap::ENTRY* sientry = 0;
00222   Locator_Repository::SIMap::ITERATOR siit (repo.servers ());
00223   for (; siit.next (sientry); siit.advance() )
00224     {
00225       Server_Info_Ptr& info = sientry->int_id_;
00226 
00227       ACE_CString name = ACEXML_escape_string (info->name);
00228       ACE_CString activator = ACEXML_escape_string (info->activator);
00229       ACE_CString cmdline = ACEXML_escape_string (info->cmdline);
00230       ACE_CString wdir = ACEXML_escape_string (info->dir);
00231       ACE_CString partial_ior = ACEXML_escape_string (info->partial_ior);
00232       ACE_CString ior = ACEXML_escape_string (info->ior);
00233 
00234       ACE_OS::fprintf (fp,"\t<%s", Locator_XMLHandler::SERVER_INFO_TAG);
00235       ACE_OS::fprintf (fp," name=\"%s\"", name.c_str ());
00236       ACE_OS::fprintf (fp," activator=\"%s\"", activator.c_str ());
00237       ACE_OS::fprintf (fp," command_line=\"%s\"", cmdline.c_str ());
00238       ACE_OS::fprintf (fp," working_dir=\"%s\"", wdir.c_str ());
00239       ACE_CString amodestr = ImR_Utils::activationModeToString (info->activation_mode);
00240       ACE_OS::fprintf (fp," activation_mode=\"%s\"", amodestr.c_str ());
00241       ACE_OS::fprintf (fp," start_limit=\"%d\"", info->start_limit);
00242       ACE_OS::fprintf (fp," partial_ior=\"%s\"", partial_ior.c_str ());
00243       ACE_OS::fprintf (fp," ior=\"%s\"", ior.c_str ());
00244       ACE_OS::fprintf (fp,">\n");
00245 
00246       for (CORBA::ULong i = 0; i < info->env_vars.length (); ++i)
00247         {
00248           ACE_OS::fprintf (fp,"\t\t<%s", Locator_XMLHandler::ENVIRONMENT_TAG);
00249           ACE_OS::fprintf (fp," name=\"%s\"", info->env_vars[i].name.in ());
00250           ACE_CString val = ACEXML_escape_string (info->env_vars[i].value.in ());
00251           ACE_OS::fprintf (fp," value=\"%s\"", val.c_str ());
00252           ACE_OS::fprintf (fp,"/>\n");
00253         }
00254 
00255       ACE_OS::fprintf (fp,"\t</%s>\n", Locator_XMLHandler::SERVER_INFO_TAG);
00256     }
00257 
00258   // Save Activators
00259   Locator_Repository::AIMap::ENTRY* aientry = 0;
00260   Locator_Repository::AIMap::ITERATOR aiit (repo.activators ());
00261   for (; aiit.next (aientry); aiit.advance ())
00262     {
00263       ACE_CString aname = aientry->ext_id_;
00264       Activator_Info_Ptr& info = aientry->int_id_;
00265       ACE_OS::fprintf (fp,"\t<%s", Locator_XMLHandler::ACTIVATOR_INFO_TAG);
00266       ACE_OS::fprintf( fp," name=\"%s\"", aname.c_str ());
00267       ACE_OS::fprintf (fp," token=\"%d\"", info->token);
00268       ACE_OS::fprintf (fp," ior=\"%s\"", info->ior.c_str ());
00269       ACE_OS::fprintf (fp,"/>\n");
00270     }
00271 
00272   ACE_OS::fprintf (fp,"</%s>\n", Locator_XMLHandler::ROOT_TAG);
00273   ACE_OS::fclose (fp);
00274 }


Classes
class	Server_Repo_XML_Callback
Functions
ACE_CString	lcase (const ACE_CString &s)
void	loadActivatorsAsBinary (ACE_Configuration &config, Locator_Repository::AIMap &map)
void	loadServersAsBinary (ACE_Configuration &config, Locator_Repository::SIMap &map)
void	loadAsBinary (ACE_Configuration &config, Locator_Repository &repo)
void	convertEnvList (const Locator_XMLHandler::EnvList &in, ImplementationRepository::EnvironmentList &out)
int	loadAsXML (const ACE_CString &fname, Locator_Repository &repo)
void	saveAsXML (const ACE_CString &fname, Locator_Repository &repo)
Variables
const char *	STARTUP_COMMAND = "StartupCommand"
const char *	WORKING_DIR = "WorkingDir"
const char *	ENVIRONMENT = "Environment"
const char *	ACTIVATION = "Activation"
const char *	PARTIAL_IOR = "Location"
const char *	IOR = "IOR"
const char *	START_LIMIT = "StartLimit"
const char *	ACTIVATOR = "Activator"
const char *	SERVERS_ROOT_KEY = "Servers"
const char *	ACTIVATORS_ROOT_KEY = "Activators"
const char *	TOKEN = "Token"
const char *	WIN32_REG_KEY = "Software\\TAO\\ImplementationRepository"

Locator_Repository.cpp File Reference

Classes

Functions

Variables

Function Documentation

Variable Documentation