ChangeLogTag: Wed Feb 18 00:52:18 UTC 2009 William R. Otte <wotte@dre.vanderbilt.edu>

1 files changed, 907 insertions, 913 deletions

diff --git a/CIAO/DAnCE/RepositoryManager/RepositoryManager_Impl.cpp b/CIAO/DAnCE/RepositoryManager/RepositoryManager_Impl.cpp
index e09701a184f..10a47e9886c 100644
--- a/CIAO/DAnCE/RepositoryManager/RepositoryManager_Impl.cpp
+++ b/CIAO/DAnCE/RepositoryManager/RepositoryManager_Impl.cpp
@@ -58,827 +58,820 @@ namespace
   static const char *RM_RECORD_UUID_SECTION = "UUIDs";
 }
 
-//-----------------------------------------------------------------
-//Constructor
-//
-//-----------------------------------------------------------------
+namespace DAnCE
+{
+  
+  //-----------------------------------------------------------------
+  //Constructor
+  //
+  //-----------------------------------------------------------------
 
-CIAO_RepositoryManagerDaemon_i::CIAO_RepositoryManagerDaemon_i
+  RepositoryManagerDaemon_i::RepositoryManagerDaemon_i
   (CORBA::ORB_ptr the_orb, const char* server, const char* install_dir)
-  : the_orb_ (CORBA::ORB::_duplicate (the_orb)),
-    install_root_ (""),
-    HTTP_server_ ("http://"),
-    install_path (install_dir)
-{
-  //form the path
-  this->HTTP_server_ += server;
-  this->HTTP_server_ += "/";
-  this->HTTP_server_ += install_path;
-  this->HTTP_server_ += "/";
-
-  //create directory in which the packages will be stored
-  ACE_OS::mkdir(install_path.c_str ());
-  //if dir already exists a -1 is returned
-  //we ignore this, just need to make sure the directory exists
-
-  ACE_OS::getcwd (this->cwd_, TEMP_LEN);
-
-  this->install_root_ = this->cwd_;
-  this->install_root_ += "/";
-  this->install_root_ += install_path;
-
-  // Install the configuration files to get the names, UUIDs, & types info.
-  ACE_Configuration_Heap cfg;
-  cfg.open ();
-  ACE_Configuration_Section_Key root = cfg.root_section ();
-
-  ACE_Registry_ImpExp config_importer (cfg);
-  ACE_OS::chdir (install_path.c_str ());
-  config_importer.import_config (RM_RECORD_FILE);
-  ACE_OS::chdir (this->cwd_);
-
-  ACE_CString name;
-  ACE_Configuration::VALUETYPE type;
-  ACE_CString path;
-
-  ACE_Configuration_Section_Key NameSection;
-  cfg.open_section (root, RM_RECORD_NAME_SECTION, 1, NameSection);
-  u_int index = 0;
-  while (!cfg.enumerate_values (NameSection, index, name, type))
+    : the_orb_ (CORBA::ORB::_duplicate (the_orb)),
+      install_root_ (""),
+      HTTP_server_ ("http://"),
+      install_path (install_dir)
   {
-    cfg.get_string_value (NameSection, name.c_str (), path);
-    this->names_.bind (name, path);
+    //form the path
+    this->HTTP_server_ += server;
+    this->HTTP_server_ += "/";
+    this->HTTP_server_ += install_path;
+    this->HTTP_server_ += "/";
+
+    //create directory in which the packages will be stored
+    ACE_OS::mkdir(install_path.c_str ());
+    //if dir already exists a -1 is returned
+    //we ignore this, just need to make sure the directory exists
+
+    ACE_OS::getcwd (this->cwd_, TEMP_LEN);
+
+    this->install_root_ = this->cwd_;
+    this->install_root_ += "/";
+    this->install_root_ += install_path;
+
+    // Install the configuration files to get the names, UUIDs, & types info.
+    ACE_Configuration_Heap cfg;
+    cfg.open ();
+    ACE_Configuration_Section_Key root = cfg.root_section ();
+
+    ACE_Registry_ImpExp config_importer (cfg);
+    ACE_OS::chdir (install_path.c_str ());
+    config_importer.import_config (RM_RECORD_FILE);
+    ACE_OS::chdir (this->cwd_);
+
+    ACE_CString name;
+    ACE_Configuration::VALUETYPE type;
+    ACE_CString path;
+
+    ACE_Configuration_Section_Key NameSection;
+    cfg.open_section (root, RM_RECORD_NAME_SECTION, 1, NameSection);
+    u_int index = 0;
+    while (!cfg.enumerate_values (NameSection, index, name, type))
+      {
+        cfg.get_string_value (NameSection, name.c_str (), path);
+        this->names_.bind (name, path);
 
-    ++index;
-  }
+        ++index;
+      }
 
-  ACE_Configuration_Section_Key UUIDSection;
-  cfg.open_section (root, RM_RECORD_UUID_SECTION, 1, UUIDSection);
-  index = 0;
-  while (!cfg.enumerate_values (UUIDSection, index, name, type))
-  {
-    cfg.get_string_value (UUIDSection, name.c_str (), path);
-    this->uuids_.bind (name, path);
+    ACE_Configuration_Section_Key UUIDSection;
+    cfg.open_section (root, RM_RECORD_UUID_SECTION, 1, UUIDSection);
+    index = 0;
+    while (!cfg.enumerate_values (UUIDSection, index, name, type))
+      {
+        cfg.get_string_value (UUIDSection, name.c_str (), path);
+        this->uuids_.bind (name, path);
 
-    ++index;
-  }
+        ++index;
+      }
 
-  // Add types
-  index = 0;
-  for (PCMap_Iterator iter = this->names_.begin ();
-    iter != this->names_.end ();
-    ++iter, ++index)
-  {
-    PCEntry& element = *iter;
+    // Add types
+    index = 0;
+    for (PCMap_Iterator iter = this->names_.begin ();
+         iter != this->names_.end ();
+         ++iter, ++index)
+      {
+        PCEntry& element = *iter;
 
-    ::Deployment::PackageConfiguration_var pc = this->findPackageByName (element.ext_id_.c_str ());
+        ::Deployment::PackageConfiguration_var pc = this->findPackageByName (element.ext_id_.c_str ());
 
-    if(!this->add_type (pc, element.ext_id_.c_str ()))
-      ACE_ERROR ((LM_ERROR, "Failed to add the type\n"));
+        if(!this->add_type (pc, element.ext_id_.c_str ()))
+          ACE_ERROR ((LM_ERROR, "Failed to add the type\n"));
+      }
   }
-}
 
-//-----------------------------------------------------------------
-//Destructor
-//
-//-----------------------------------------------------------------
+  //-----------------------------------------------------------------
+  //Destructor
+  //
+  //-----------------------------------------------------------------
 
-CIAO_RepositoryManagerDaemon_i::~CIAO_RepositoryManagerDaemon_i (void)
-{
-  this->names_.unbind_all ();
-  this->uuids_.unbind_all ();
-  this->types_.unbind_all ();
-}
-
-//-----------------------------------------------------------------
-//shutdown
-//
-//-----------------------------------------------------------------
+  RepositoryManagerDaemon_i::~RepositoryManagerDaemon_i (void)
+  {
+    this->names_.unbind_all ();
+    this->uuids_.unbind_all ();
+    this->types_.unbind_all ();
+  }
 
-void CIAO_RepositoryManagerDaemon_i::shutdown ()
+  //-----------------------------------------------------------------
+  //shutdown
+  //
+  //-----------------------------------------------------------------
 
-{
-  // Release resource.
-  this->names_.unbind_all ();
-  this->uuids_.unbind_all ();
-  this->types_.unbind_all ();
+  void RepositoryManagerDaemon_i::shutdown ()
 
-  this->the_orb_->shutdown (0);
-}
+  {
+    // Release resource.
+    this->names_.unbind_all ();
+    this->uuids_.unbind_all ();
+    this->types_.unbind_all ();
 
+    this->the_orb_->shutdown (0);
+  }
 
-//-----------------------------------------------------------------
-//installPackage
-//
-//-----------------------------------------------------------------
 
-void CIAO_RepositoryManagerDaemon_i::installPackage (
-                                                     const char * installationName,
-                                                     const char * location,
-                                                     ::CORBA::Boolean replace
-                                                     )
-{
+  //-----------------------------------------------------------------
+  //installPackage
+  //
+  //-----------------------------------------------------------------
 
-  PCEntry *entry = 0;
-  if (this->names_.find (ACE_CString (installationName), entry) == 0)
-    {
-      if (!replace)
-        throw Deployment::NameExists ();
-      else
-        deletePackage (installationName);
-    }
+  void RepositoryManagerDaemon_i::installPackage (const char * installationName,
+                                                  const char * location,
+                                                  ::CORBA::Boolean replace)
+  {
 
-  //Now lets form the path for the local file
-  //NOTE: I need the absolute path because I will change to a subdirectory
-  //when I am parsing the descriptors
+    PCEntry *entry = 0;
+    if (this->names_.find (ACE_CString (installationName), entry) == 0)
+      {
+        if (!replace)
+          throw Deployment::NameExists ();
+        else
+          deletePackage (installationName);
+      }
 
-  ACE_CString path (this->install_root_);
-  path += "/";
-  path += installationName;
+    //Now lets form the path for the local file
+    //NOTE: I need the absolute path because I will change to a subdirectory
+    //when I am parsing the descriptors
 
-  ACE_CString package_path (path);
-  package_path += ".cpk";        //package extension
+    ACE_CString path (this->install_root_);
+    path += "/";
+    path += installationName;
 
-  ACE_CString pc_path (path);
-  pc_path += PC_EXTENSION;      //external PackageConfiguration extension
+    ACE_CString package_path (path);
+    package_path += ".cpk";        //package extension
 
+    ACE_CString pc_path (path);
+    pc_path += PC_EXTENSION;      //external PackageConfiguration extension
 
-  ACE_CString descriptor_dir (path);
-  descriptor_dir += "/descriptors/"; //location of the descriptor directory
 
+    ACE_CString descriptor_dir (path);
+    descriptor_dir += "/descriptors/"; //location of the descriptor directory
 
-  //check if URL or local file
-  //download or load into memory
 
-  if (ACE_OS::strstr (location, "http://"))
-    {
+    //check if URL or local file
+    //download or load into memory
 
-      //TODO: how can I incorporate a Auto_Ptr is explicit release is needed
-      ACE_Message_Block* mb = 0;
-      ACE_NEW_THROW_EX (mb, ACE_Message_Block (), CORBA::NO_MEMORY ());
+    if (ACE_OS::strstr (location, "http://"))
+      {
 
-      //get the remote file
-      if (!HTTP_Get (location, *mb))
-        {
-          mb->release ();
+        //TODO: how can I incorporate a Auto_Ptr is explicit release is needed
+        ACE_Message_Block* mb = 0;
+        ACE_NEW_THROW_EX (mb, ACE_Message_Block (), CORBA::NO_MEMORY ());
+
+        //get the remote file
+        if (!HTTP_Get (location, *mb))
+          {
+            mb->release ();
+            throw CORBA::INTERNAL ();
+          }
+
+        // Write file to designated location on disk
+        if (!RM_Helper::write_to_disk (package_path.c_str (), *mb))
+          {
+            mb->release ();
+            throw CORBA::INTERNAL ();
+          }
+
+        mb->release ();
+      }
+    else
+      {
+        if (!RM_Helper::copy_from_disk_to_disk (location, package_path.c_str ()))
           throw CORBA::INTERNAL ();
-        }
+      }
 
-      // Write file to designated location on disk
-      if (!RM_Helper::write_to_disk (package_path.c_str (), *mb))
-        {
-          mb->release ();
-          throw CORBA::INTERNAL ();
-        }
 
-      mb->release ();
-    }
-  else
-    {
-      if (!RM_Helper::copy_from_disk_to_disk (location, package_path.c_str ()))
-        throw CORBA::INTERNAL ();
-    }
+    ZIP_Wrapper::uncompress (const_cast<char*> (package_path.c_str ()),
+                             const_cast<char*> (this->install_root_.c_str ()),
+                             false //not verbose
+                             );
 
+    //Start the parsing
 
-  ZIP_Wrapper::uncompress (const_cast<char*> (package_path.c_str ()),
-                           const_cast<char*> (this->install_root_.c_str ()),
-                           false //not verbose
-                           );
+    ACE_CString pc_name;
 
-  //Start the parsing
+    this->find_PC_name (const_cast<char*> (package_path.c_str ()), pc_name);
 
-  ACE_CString pc_name;
+    //if the PackageConfiguration name cannot be found, then there is nothing to install
+    if (pc_name == "")
+      {
+        //clean the extracted files
+        remove_extracted_package (path.c_str ());
+        //remove the package
+        remove (package_path.c_str ());
 
-  this->find_PC_name (const_cast<char*> (package_path.c_str ()), pc_name);
+        throw Deployment::PackageError ();
+      }
 
-  //if the PackageConfiguration name cannot be found, then there is nothing to install
-  if (pc_name == "")
-  {
-    //clean the extracted files
-    remove_extracted_package (path.c_str ());
-    //remove the package
-    remove (package_path.c_str ());
+    //TODO: move exception throwing out of this func. User boolean error handling!!!
+    //TODO: check for errors!
+    Deployment::PackageConfiguration_var pc;
+    pc = this->retrieve_PC_from_descriptors (const_cast<char*> (pc_name.c_str ()),
+                                             descriptor_dir.c_str ());
 
-    throw Deployment::PackageError ();
-  }
 
-  //TODO: move exception throwing out of this func. User boolean error handling!!!
-  //TODO: check for errors!
-  Deployment::PackageConfiguration_var pc;
-  pc = this->retrieve_PC_from_descriptors (const_cast<char*> (pc_name.c_str ()),
-                                           descriptor_dir.c_str ());
+    if (this->uuids_.find (ACE_CString (pc->UUID), entry) == 0)
+      {
+        //clean the extracted files
+        remove_extracted_package (path.c_str ());
+        //remove the package
+        remove (package_path.c_str ());
 
+        throw Deployment::NameExists ();
+      }
 
-  if (this->uuids_.find (ACE_CString (pc->UUID), entry) == 0)
-  {
-    //clean the extracted files
-    remove_extracted_package (path.c_str ());
-    //remove the package
-    remove (package_path.c_str ());
+    //forming the server path info
+    ACE_CString server_path (this->HTTP_server_);
+    server_path += installationName;
 
-    throw Deployment::NameExists ();
-  }
+    //NOTE: ComponentPackageReferences are currently NOT supported
+    if (!(pc->basePackage.length () > 0))
+      {
+        //clean the extracted files
+        remove_extracted_package (path.c_str ());
+        //remove the package
+        remove (package_path.c_str ());
 
-  //forming the server path info
-  ACE_CString server_path (this->HTTP_server_);
-  server_path += installationName;
+        throw CORBA::NO_IMPLEMENT ();
+      }
 
-  //NOTE: ComponentPackageReferences are currently NOT supported
-  if (!(pc->basePackage.length () > 0))
-  {
-    //clean the extracted files
-    remove_extracted_package (path.c_str ());
-    //remove the package
-    remove (package_path.c_str ());
+    PC_Updater updater (server_path, package_path);
 
-    throw CORBA::NO_IMPLEMENT ();
-  }
+    if (!updater.update (pc))
+      {
+        ACE_DEBUG ((LM_ERROR, "[RM] problem updating the PackageConfiguration!\n"));
 
-  PC_Updater updater (server_path, package_path);
+        //clean the extracted files
+        remove_extracted_package (path.c_str ());
+        //remove the package
+        remove (package_path.c_str ());
+        throw Deployment::PackageError ();
+      }
 
-  if (!updater.update (pc))
-  {
-    ACE_DEBUG ((LM_ERROR, "[RM] problem updating the PackageConfiguration!\n"));
 
-    //clean the extracted files
-    remove_extracted_package (path.c_str ());
-    //remove the package
-    remove (package_path.c_str ());
-    throw Deployment::PackageError ();
-  }
+    //now lets externalize the PackageConfiguration, so that we can access it later on
+    //without having to do the whole parsing again.
+    //NOTE: Order here is important. Do not populate maps before the externalization!
+    RM_Helper::externalize (pc, pc_path.c_str ());
 
+    //insert the package into the database
+    if (this->names_.bind (ACE_CString (installationName), path) == -1)
+      {
+        ACE_ERROR ((LM_ERROR,
+                    "[RM] could not bind %s.\n",
+                    installationName));
+
+        //clean the extracted files
+        remove_extracted_package (path.c_str ());
+        //remove the package
+        remove (package_path.c_str ());
+        //remove the PackageConfiguration externalization
+        remove (pc_path.c_str ());
+
+        //throw exception
+        throw CORBA::INTERNAL ();
+      }
 
-  //now lets externalize the PackageConfiguration, so that we can access it later on
-  //without having to do the whole parsing again.
-  //NOTE: Order here is important. Do not populate maps before the externalization!
-  RM_Helper::externalize (pc, pc_path.c_str ());
+    //ALSO NEED THE UUID here
+    if (this->uuids_.bind (ACE_CString (pc->UUID), path) == -1)
+      {
+        ACE_ERROR ((LM_ERROR,
+                    "[RM] could not bind %s.\n",
+                    ACE_CString (pc->UUID).c_str ()));
 
-  //insert the package into the database
-  if (this->names_.bind (ACE_CString (installationName), path) == -1)
-  {
-    ACE_ERROR ((LM_ERROR,
-                 "[RM] could not bind %s.\n",
-                 installationName));
+        //unbind the name
+        this->names_.unbind (installationName);
 
-    //clean the extracted files
-    remove_extracted_package (path.c_str ());
-    //remove the package
-    remove (package_path.c_str ());
-    //remove the PackageConfiguration externalization
-    remove (pc_path.c_str ());
+        //clean the extracted files
+        remove_extracted_package (path.c_str ());
+        //remove the package
+        remove (package_path.c_str ());
+        //remove the PackageConfiguration externalization
+        remove (pc_path.c_str ());
 
-    //throw exception
-    throw CORBA::INTERNAL ();
-  }
+        //throw exception
+        throw CORBA::INTERNAL ();
+      }
 
-  //ALSO NEED THE UUID here
-  if (this->uuids_.bind (ACE_CString (pc->UUID), path) == -1)
-  {
-     ACE_ERROR ((LM_ERROR,
-                 "[RM] could not bind %s.\n",
-                 ACE_CString (pc->UUID).c_str ()));
-
-     //unbind the name
-     this->names_.unbind (installationName);
-
-     //clean the extracted files
-     remove_extracted_package (path.c_str ());
-     //remove the package
-     remove (package_path.c_str ());
-     //remove the PackageConfiguration externalization
-     remove (pc_path.c_str ());
-
-     //throw exception
-     throw CORBA::INTERNAL ();
+    //now add the type interface
+    if(!this->add_type (pc, installationName))
+      ACE_ERROR ((LM_ERROR, "Failed to add the type\n"));
+
+    this->dump ();
+
+    this->save ();
+
+    ACE_DEBUG ((LM_INFO,
+                "Installed PackageConfiguration \n\tname: %s \n\tuuid: %s\n",
+                installationName, ACE_CString (pc->UUID).c_str ()));
   }
 
-  //now add the type interface
-  if(!this->add_type (pc, installationName))
-    ACE_ERROR ((LM_ERROR, "Failed to add the type\n"));
 
-  this->dump ();
+  //-----------------------------------------------------------------
+  //createPackage
+  //
+  //-----------------------------------------------------------------
 
-  this->save ();
+  void RepositoryManagerDaemon_i::createPackage (const char * installationName,
+                                                 const ::Deployment::PackageConfiguration & package,
+                                                 const char * baseLocation,
+                                                 ::CORBA::Boolean replace)
+  {
+    ::Deployment::PackageConfiguration pc = package;
 
-  ACE_DEBUG ((LM_INFO,
-              "Installed PackageConfiguration \n\tname: %s \n\tuuid: %s\n",
-              installationName, ACE_CString (pc->UUID).c_str ()));
-}
+    // Find if there is a PackageConfiguration with the same name.
+    PCEntry *entry = 0;
+    if (this->names_.find (ACE_CString (installationName), entry) == 0)
+      {
+        if (!replace)
+          throw Deployment::NameExists ();
+        else
+          deletePackage (installationName);
+      }
 
+    // Find if there is a PackageConfiguration with the same uuid.
+    if (this->uuids_.find (ACE_CString (pc.UUID), entry) == 0)
+      throw Deployment::NameExists ();
 
-//-----------------------------------------------------------------
-//createPackage
-//
-//-----------------------------------------------------------------
+    // Find if the PackageConfiguration has a basePackage.
+    // NOTE: ComponentPackageReferences are currently NOT supported.
+    if (!(pc.basePackage.length () > 0))
+      throw CORBA::NO_IMPLEMENT ();
 
-void CIAO_RepositoryManagerDaemon_i::createPackage (
-                                                    const char * installationName,
-                                                    const ::Deployment::PackageConfiguration & package,
-                                                    const char * baseLocation,
-                                                    ::CORBA::Boolean replace
-                                                    )
-{
-  ::Deployment::PackageConfiguration pc = package;
+    // Form the path for the local file
+    ACE_CString path (this->install_root_);
+    path += "/";
+    path += installationName;
 
-  // Find if there is a PackageConfiguration with the same name.
-  PCEntry *entry = 0;
-  if (this->names_.find (ACE_CString (installationName), entry) == 0)
-    {
-      if (!replace)
-        throw Deployment::NameExists ();
-      else
-        deletePackage (installationName);
-    }
+    ACE_CString package_path (path);
+    package_path += ".cpk";        //package extension
 
-  // Find if there is a PackageConfiguration with the same uuid.
-  if (this->uuids_.find (ACE_CString (pc.UUID), entry) == 0)
-    throw Deployment::NameExists ();
+    ACE_CString pc_path (path);
+    pc_path += PC_EXTENSION;      //external PackageConfiguration extension
 
-  // Find if the PackageConfiguration has a basePackage.
-  // NOTE: ComponentPackageReferences are currently NOT supported.
-  if (!(pc.basePackage.length () > 0))
-    throw CORBA::NO_IMPLEMENT ();
+    // Check if URL or local file, download or load into memory
+    if (ACE_OS::strstr (baseLocation, "http://"))
+      {
+        //TODO: how can I incorporate a Auto_Ptr is explicit release is needed
+        ACE_Message_Block* mb;
+        ACE_NEW_THROW_EX (mb, ACE_Message_Block (), CORBA::NO_MEMORY ());
+
+        //get the remote file
+        if (!HTTP_Get (baseLocation, *mb))
+          {
+            mb->release ();
+            throw CORBA::INTERNAL ();
+          }
+
+        // Write file to designated location on disk
+        if (!RM_Helper::write_to_disk (package_path.c_str (), *mb))
+          {
+            mb->release ();
+            throw CORBA::INTERNAL ();
+          }
+
+        mb->release ();
+      }
+    else
+      {
+        if (!RM_Helper::copy_from_disk_to_disk (baseLocation, package_path.c_str ()))
+          throw CORBA::INTERNAL ();
+      }
 
-  // Form the path for the local file
-  ACE_CString path (this->install_root_);
-  path += "/";
-  path += installationName;
 
-  ACE_CString package_path (path);
-  package_path += ".cpk";        //package extension
+    ZIP_Wrapper::uncompress (const_cast<char*> (package_path.c_str ()),
+                             const_cast<char*> (this->install_root_.c_str ()),
+                             false //not verbose
+                             );
 
-  ACE_CString pc_path (path);
-  pc_path += PC_EXTENSION;      //external PackageConfiguration extension
+    // Form the server path info
+    ACE_CString server_path (this->HTTP_server_);
+    server_path += installationName;
 
-  // Check if URL or local file, download or load into memory
-  if (ACE_OS::strstr (baseLocation, "http://"))
-  {
-    //TODO: how can I incorporate a Auto_Ptr is explicit release is needed
-    ACE_Message_Block* mb;
-    ACE_NEW_THROW_EX (mb, ACE_Message_Block (), CORBA::NO_MEMORY ());
-
-    //get the remote file
-    if (!HTTP_Get (baseLocation, *mb))
-    {
-      mb->release ();
-      throw CORBA::INTERNAL ();
-    }
+    // Update the newly installed package configration informantion.
+    PC_Updater updater (server_path, package_path);
 
-    // Write file to designated location on disk
-    if (!RM_Helper::write_to_disk (package_path.c_str (), *mb))
-    {
-      mb->release ();
-      throw CORBA::INTERNAL ();
-    }
+    if (!updater.update (pc))
+      {
+        ACE_ERROR ((LM_ERROR, "[RM] problem updating the PackageConfiguration!\n"));
+        //clean the extracted files
+        remove_extracted_package (path.c_str ());
+        //remove the package
+        remove (package_path.c_str ());
+        throw Deployment::PackageError ();
+      }
 
-    mb->release ();
-  }
-  else
-  {
-    if (!RM_Helper::copy_from_disk_to_disk (baseLocation, package_path.c_str ()))
-      throw CORBA::INTERNAL ();
-  }
+    // Externalize the PackageConfiguration, so that we can access it later on
+    // without having to do the whole parsing again.
+    // NOTE: Order here is important. Do not populate maps before the externalization!
+    RM_Helper::externalize (pc, pc_path.c_str ());
 
+    // Insert the name of the package.
+    if (this->names_.bind (ACE_CString (installationName), path) == -1)
+      {
+        ACE_ERROR ((LM_ERROR,
+                    "[RM] could not bind %s.\n",
+                    installationName));
+
+        //clean the extracted files
+        remove_extracted_package (path.c_str ());
+        //remove the package
+        remove (package_path.c_str ());
+        //remove the PackageConfiguration externalization
+        remove (pc_path.c_str ());
+
+        //throw exception
+        throw CORBA::INTERNAL ();
+      }
 
-  ZIP_Wrapper::uncompress (const_cast<char*> (package_path.c_str ()),
-    const_cast<char*> (this->install_root_.c_str ()),
-    false //not verbose
-    );
+    // Insert the UUID of the package.
+    if (this->uuids_.bind (ACE_CString (pc.UUID), path) == -1)
+      {
+        ACE_ERROR ((LM_ERROR,
+                    "[RM] could not bind %s.\n",
+                    ACE_CString (pc.UUID).c_str ()));
 
-  // Form the server path info
-  ACE_CString server_path (this->HTTP_server_);
-  server_path += installationName;
+        //unbind the name
+        this->names_.unbind (installationName);
 
-  // Update the newly installed package configration informantion.
-  PC_Updater updater (server_path, package_path);
+        //clean the extracted files
+        remove_extracted_package (path.c_str ());
+        //remove the package
+        remove (package_path.c_str ());
+        //remove the PackageConfiguration externalization
+        remove (pc_path.c_str ());
 
-  if (!updater.update (pc))
-  {
-    ACE_ERROR ((LM_ERROR, "[RM] problem updating the PackageConfiguration!\n"));
-    //clean the extracted files
-    remove_extracted_package (path.c_str ());
-    //remove the package
-    remove (package_path.c_str ());
-    throw Deployment::PackageError ();
-  }
+        //throw exception
+        throw CORBA::INTERNAL ();
+      }
 
-  // Externalize the PackageConfiguration, so that we can access it later on
-  // without having to do the whole parsing again.
-  // NOTE: Order here is important. Do not populate maps before the externalization!
-  RM_Helper::externalize (pc, pc_path.c_str ());
+    //now add the type interface
+    //TODO: CHECK if successful
+    if(!this->add_type (pc, installationName))
+      ACE_ERROR ((LM_ERROR, "Failed to add the type\n"));
 
-  // Insert the name of the package.
-  if (this->names_.bind (ACE_CString (installationName), path) == -1)
-  {
-    ACE_ERROR ((LM_ERROR,
-                 "[RM] could not bind %s.\n",
-                 installationName));
+    this->dump ();
 
-    //clean the extracted files
-    remove_extracted_package (path.c_str ());
-    //remove the package
-    remove (package_path.c_str ());
-    //remove the PackageConfiguration externalization
-    remove (pc_path.c_str ());
+    this->save ();
 
-    //throw exception
-    throw CORBA::INTERNAL ();
+    ACE_DEBUG ((LM_INFO,
+                "Created PackageConfiguration \n  directory: %s \n  name: %s \n  uuid: %s\n",
+                path.c_str (), installationName, ACE_CString (pc.UUID).c_str ()));
   }
 
-  // Insert the UUID of the package.
-  if (this->uuids_.bind (ACE_CString (pc.UUID), path) == -1)
-  {
-     ACE_ERROR ((LM_ERROR,
-                 "[RM] could not bind %s.\n",
-                 ACE_CString (pc.UUID).c_str ()));
-
-     //unbind the name
-     this->names_.unbind (installationName);
-
-     //clean the extracted files
-     remove_extracted_package (path.c_str ());
-     //remove the package
-     remove (package_path.c_str ());
-     //remove the PackageConfiguration externalization
-     remove (pc_path.c_str ());
-
-     //throw exception
-     throw CORBA::INTERNAL ();
-  }
 
-  //now add the type interface
-  //TODO: CHECK if successful
-  if(!this->add_type (pc, installationName))
-    ACE_ERROR ((LM_ERROR, "Failed to add the type\n"));
+  //-----------------------------------------------------------------
+  //findPackageByName
+  //
+  //-----------------------------------------------------------------
 
-  this->dump ();
+  ::Deployment::PackageConfiguration*
+  RepositoryManagerDaemon_i::findPackageByName (const char * name)
 
-  this->save ();
+  {
+    // Find out if the PackageConfiguration was installed in the repository,
+    // return it if found or throw and exception otherwise
 
-  ACE_DEBUG ((LM_INFO,
-              "Created PackageConfiguration \n  directory: %s \n  name: %s \n  uuid: %s\n",
-              path.c_str (), installationName, ACE_CString (pc.UUID).c_str ()));
-}
+    PCEntry *entry = 0;
 
+    if (this->names_.find (ACE_CString (name), entry) != 0)
+      throw Deployment::NoSuchName ();
+    //PackageConfiguration was not found
 
-//-----------------------------------------------------------------
-//findPackageByName
-//
-//-----------------------------------------------------------------
+    ACE_CString pc_path (entry->int_id_.c_str ());
+    pc_path += PC_EXTENSION;
 
-::Deployment::PackageConfiguration*
-CIAO_RepositoryManagerDaemon_i::findPackageByName (const char * name)
+    Deployment::PackageConfiguration_var pc;
+    ACE_NEW_THROW_EX (pc,
+                      Deployment::PackageConfiguration (),
+                      CORBA::NO_MEMORY ());
 
-{
-  // Find out if the PackageConfiguration was installed in the repository,
-  // return it if found or throw and exception otherwise
 
-  PCEntry *entry = 0;
+    if(!RM_Helper::reincarnate (pc, pc_path.c_str ()))
+      throw CORBA::INTERNAL ();
 
-  if (this->names_.find (ACE_CString (name), entry) != 0)
-    throw Deployment::NoSuchName ();
-  //PackageConfiguration was not found
+    ACE_DEBUG ((LM_INFO, "Successfully looked up \'%s\'.\n", name));
 
-  ACE_CString pc_path (entry->int_id_.c_str ());
-  pc_path += PC_EXTENSION;
+    return pc._retn ();
+  }
 
-  Deployment::PackageConfiguration_var pc;
-  ACE_NEW_THROW_EX (pc,
-                    Deployment::PackageConfiguration (),
-                    CORBA::NO_MEMORY ());
 
+  //-----------------------------------------------------------------
+  //findPackageByUUID
+  //
+  //-----------------------------------------------------------------
 
-  if(!RM_Helper::reincarnate (pc, pc_path.c_str ()))
-    throw CORBA::INTERNAL ();
+  ::Deployment::PackageConfiguration*
+  RepositoryManagerDaemon_i::findPackageByUUID (const char * UUID)
 
-  ACE_DEBUG ((LM_INFO, "Successfully looked up \'%s\'.\n", name));
+  {
+    // Find out if the PackageConfiguration was installed in the repository,
+    // return it if found or throw and exception otherwise
 
-  return pc._retn ();
-}
+    PCEntry *entry = 0;
 
+    if (this->uuids_.find (ACE_CString (UUID), entry) != 0)
+      throw Deployment::NoSuchName ();
+    //PackageConfiguration was not found
 
-//-----------------------------------------------------------------
-//findPackageByUUID
-//
-//-----------------------------------------------------------------
+    ACE_CString pc_path (entry->int_id_.c_str ());
+    pc_path += PC_EXTENSION;
 
-::Deployment::PackageConfiguration*
-CIAO_RepositoryManagerDaemon_i::findPackageByUUID (const char * UUID)
+    Deployment::PackageConfiguration_var pc;
+    ACE_NEW_THROW_EX (pc,
+                      Deployment::PackageConfiguration (),
+                      CORBA::NO_MEMORY ());
 
-{
-  // Find out if the PackageConfiguration was installed in the repository,
-  // return it if found or throw and exception otherwise
 
-  PCEntry *entry = 0;
+    if(!RM_Helper::reincarnate (pc, pc_path.c_str ()))
+      throw CORBA::INTERNAL ();
 
-  if (this->uuids_.find (ACE_CString (UUID), entry) != 0)
-    throw Deployment::NoSuchName ();
-  //PackageConfiguration was not found
+    ACE_DEBUG ((LM_INFO, "Successfully looked up %s.\n", UUID));
 
-  ACE_CString pc_path (entry->int_id_.c_str ());
-  pc_path += PC_EXTENSION;
+    return pc._retn ();
+  }
 
-  Deployment::PackageConfiguration_var pc;
-  ACE_NEW_THROW_EX (pc,
-                    Deployment::PackageConfiguration (),
-                    CORBA::NO_MEMORY ());
+  //-----------------------------------------------------------------
+  //findPackageByType
+  //
+  //-----------------------------------------------------------------
 
+  ::CORBA::StringSeq * RepositoryManagerDaemon_i::findNamesByType (const char * type)
+  {
+    CIEntry *entry = 0;
 
-  if(!RM_Helper::reincarnate (pc, pc_path.c_str ()))
-    throw CORBA::INTERNAL ();
+    //find the type in the interface map
+    if (this->types_.find (ACE_CString (type), entry) != 0)
+      {
+        //return an empty sequence
+        CORBA::StringSeq_var seq;
+        ACE_NEW_THROW_EX (seq, CORBA::StringSeq (0), CORBA::NO_MEMORY ());
 
-  ACE_DEBUG ((LM_INFO, "Successfully looked up %s.\n", UUID));
+        return seq._retn ();
+      }
+    else
+      {
+        CISet ci_set = (*entry).int_id_set_;
+
+        CORBA::ULong len = ci_set.size ();
+
+        //allocate a sequence of the right length
+        CORBA::StringSeq_var seq;
+        ACE_NEW_THROW_EX (seq,
+                          CORBA::StringSeq (len),
+                          CORBA::NO_MEMORY ());
+        seq->length (len);
+
+        //store the elements in the string sequence
+        CISet_Iterator ci_set_iter (ci_set);
+        CORBA::ULong index = 0;
+        for (ci_set_iter = ci_set.begin ();
+             ci_set_iter != ci_set.end () && index < len;
+             ++ci_set_iter, ++index)
+          {
+            seq[index] = CORBA::string_dup ((*ci_set_iter).c_str ());
+          }
+
+        return seq._retn ();
+      }
+  }
 
-  return pc._retn ();
-}
 
-//-----------------------------------------------------------------
-//findPackageByType
-//
-//-----------------------------------------------------------------
+  //-----------------------------------------------------------------
+  //getAllNames
+  //
+  //-----------------------------------------------------------------
 
-::CORBA::StringSeq * CIAO_RepositoryManagerDaemon_i::findNamesByType (
-                                                                      const char * type
-                                                                      )
-{
-  CIEntry *entry = 0;
+  ::CORBA::StringSeq*
+  RepositoryManagerDaemon_i::getAllNames ()
 
-    //find the type in the interface map
-  if (this->types_.find (ACE_CString (type), entry) != 0)
   {
-    //return an empty sequence
-    CORBA::StringSeq_var seq;
-    ACE_NEW_THROW_EX (seq, CORBA::StringSeq (0), CORBA::NO_MEMORY ());
+    //Map.current_size () gives you the current number with the duplicates
+    //Map.total_size () gives you the allocated space + the empty slots
+    //Apparently the only way to figure out the number of keys is to
+    //count them with an iterator.
 
-    return seq._retn ();
-  }
-  else
-  {
-    CISet ci_set = (*entry).int_id_set_;
+    CORBA::ULong num_entries = 0;
 
-    CORBA::ULong len = ci_set.size ();
+    for (PCMap_Iterator i = this->names_.begin ();
+         i != this->names_.end ();
+         ++i)
+      ++num_entries;
 
-    //allocate a sequence of the right length
     CORBA::StringSeq_var seq;
-    ACE_NEW_THROW_EX (seq,
-                      CORBA::StringSeq (len),
-                      CORBA::NO_MEMORY ());
-    seq->length (len);
+    ACE_NEW_THROW_EX (seq, CORBA::StringSeq (num_entries), CORBA::NO_MEMORY ());
 
-    //store the elements in the string sequence
-    CISet_Iterator ci_set_iter (ci_set);
-    CORBA::ULong index = 0;
-    for (ci_set_iter = ci_set.begin ();
-         ci_set_iter != ci_set.end () && index < len;
-         ++ci_set_iter, ++index)
-    {
-      seq[index] = CORBA::string_dup ((*ci_set_iter).c_str ());
-    }
-
-    return seq._retn ();
-  }
-}
 
+    seq->length (num_entries);
 
-//-----------------------------------------------------------------
-//getAllNames
-//
-//-----------------------------------------------------------------
-
-::CORBA::StringSeq*
-CIAO_RepositoryManagerDaemon_i::getAllNames ()
+    CORBA::ULong index = 0;
+    for (PCMap_Iterator iter = this->names_.begin ();
+         iter != this->names_.end () && index < num_entries;
+         ++iter, ++index)
+      {
+        PCEntry& element = *iter;
+        seq[index] = CORBA::string_dup (element.ext_id_.c_str ());
+      }
 
-{
-  //Map.current_size () gives you the current number with the duplicates
-  //Map.total_size () gives you the allocated space + the empty slots
-  //Apparently the only way to figure out the number of keys is to
-  //count them with an iterator.
+    ACE_DEBUG ((LM_INFO, "The number of packages %d\n", seq->length ()));
 
-  CORBA::ULong num_entries = 0;
+    return seq._retn ();    //release the underlying CORBA::StringSeq
+  }
 
-  for (PCMap_Iterator i = this->names_.begin ();
-       i != this->names_.end ();
-       ++i)
-     ++num_entries;
 
-  CORBA::StringSeq_var seq;
-  ACE_NEW_THROW_EX (seq, CORBA::StringSeq (num_entries), CORBA::NO_MEMORY ());
+  //-----------------------------------------------------------------
+  //getAllTypes
+  //
+  //-----------------------------------------------------------------
 
+  ::CORBA::StringSeq * RepositoryManagerDaemon_i::getAllTypes ()
+  {
+    //Map.current_size () gives you the current number with the duplicates
+    //Map.total_size () gives you the allocated space + the empty slots
+    //Apparently the only way to figure out the number of keys is to
+    //count them with an iterator.
 
-  seq->length (num_entries);
+    CORBA::ULong num_entries = 0;
 
-  CORBA::ULong index = 0;
-  for (PCMap_Iterator iter = this->names_.begin ();
-    iter != this->names_.end () && index < num_entries;
-    ++iter, ++index)
-  {
-    PCEntry& element = *iter;
-    seq[index] = CORBA::string_dup (element.ext_id_.c_str ());
-  }
+    for (CIMap_Iterator i = this->types_.begin ();
+         i != this->types_.end ();
+         ++i)
+      ++num_entries;
 
-  ACE_DEBUG ((LM_INFO, "The number of packages %d\n", seq->length ()));
+    CORBA::StringSeq_var seq;
+    ACE_NEW_THROW_EX (seq,
+                      CORBA::StringSeq (num_entries),
+                      CORBA::NO_MEMORY ());
 
-  return seq._retn ();    //release the underlying CORBA::StringSeq
-}
 
+    seq->length (num_entries);
 
-//-----------------------------------------------------------------
-//getAllTypes
-//
-//-----------------------------------------------------------------
+    CORBA::ULong index = 0;
+    for (CIMap_Iterator iter = this->types_.begin ();
+         iter != this->types_.end () && index < num_entries;
+         ++iter, ++index)
 
-::CORBA::StringSeq * CIAO_RepositoryManagerDaemon_i::getAllTypes (
+      {
+        CIEntry& element = *iter;
+        seq[index] = CORBA::string_dup (element.ext_id_.c_str ());
+      }
 
-  )
-{
-  //Map.current_size () gives you the current number with the duplicates
-  //Map.total_size () gives you the allocated space + the empty slots
-  //Apparently the only way to figure out the number of keys is to
-  //count them with an iterator.
+    ACE_DEBUG ((LM_DEBUG, "The number of types: %d\n", num_entries));
 
-  CORBA::ULong num_entries = 0;
+    return seq._retn ();    //release the underlying CORBA::StringSeq
+  }
 
-  for (CIMap_Iterator i = this->types_.begin ();
-       i != this->types_.end ();
-       ++i)
-     ++num_entries;
 
-  CORBA::StringSeq_var seq;
-  ACE_NEW_THROW_EX (seq,
-                    CORBA::StringSeq (num_entries),
-                    CORBA::NO_MEMORY ());
+  //-----------------------------------------------------------------
+  //DeletePackage
+  //
+  //-----------------------------------------------------------------
 
+  void RepositoryManagerDaemon_i::deletePackage (const char * installationName)
+  {
+    bool internal_err = false;
 
-  seq->length (num_entries);
+    PCEntry *entry = 0;
 
-  CORBA::ULong index = 0;
-  for (CIMap_Iterator iter = this->types_.begin ();
-    iter != this->types_.end () && index < num_entries;
-    ++iter, ++index)
+    if (this->names_.find (ACE_CString (installationName), entry) != 0)
+      throw Deployment::NoSuchName ();
 
-  {
-    CIEntry& element = *iter;
-    seq[index] = CORBA::string_dup (element.ext_id_.c_str ());
-  }
+    //cache the package path
+    ACE_CString path (entry->int_id_.c_str ());
 
-  ACE_DEBUG ((LM_DEBUG, "The number of types: %d\n", num_entries));
+    //remove the name association
+    if (this->names_.unbind (installationName) == -1)
+      {
+        ACE_ERROR ((LM_ERROR,
+                    "Unable to unbind %s.\n",
+                    installationName));
+        internal_err = true;
+      }
 
-  return seq._retn ();    //release the underlying CORBA::StringSeq
-}
+    //the package location
+    ACE_CString package_path (path);
+    package_path += ".cpk";        //package extension
 
+    //the PackageConfiguration externalization location
+    ACE_CString pc_path (path);
+    pc_path += PC_EXTENSION;        //external PackageConfiguration extension
 
-//-----------------------------------------------------------------
-//DeletePackage
-//
-//-----------------------------------------------------------------
+    Deployment::PackageConfiguration_var pc;
+    ACE_NEW_THROW_EX (pc,
+                      Deployment::PackageConfiguration (),
+                      CORBA::NO_MEMORY ());
 
-void CIAO_RepositoryManagerDaemon_i::deletePackage (
-                                                    const char * installationName
-                                                    )
-{
-  bool internal_err = false;
 
-  PCEntry *entry = 0;
+    if(!RM_Helper::reincarnate (pc, pc_path.c_str ()))
+      {
+        ACE_ERROR ((LM_ERROR, "Could not reincarnate PC\n"));
+        internal_err = true;
+      }
 
-  if (this->names_.find (ACE_CString (installationName), entry) != 0)
-    throw Deployment::NoSuchName ();
+    if (this->uuids_.unbind (ACE_CString (pc->UUID)) == -1)
+      {
+        ACE_ERROR ((LM_ERROR, "Could not remove UUID\n"));
+        internal_err = true;
+      }
 
-  //cache the package path
-  ACE_CString path (entry->int_id_.c_str ());
+    //remove the type from the interface map
+    if (!this->remove_type (pc, installationName))
+      {
+        ACE_ERROR ((LM_ERROR, "Could not remove type\n"));
+        internal_err = true;
+      }
 
-  //remove the name association
-  if (this->names_.unbind (installationName) == -1)
-  {
-    ACE_ERROR ((LM_ERROR,
-                "Unable to unbind %s.\n",
-                installationName));
-    internal_err = true;
-  }
+    //actually delete the package here!
 
-  //the package location
-  ACE_CString package_path (path);
-  package_path += ".cpk";        //package extension
+    //clean the extracted files
+    remove_extracted_package (path.c_str ());
+    //remove the package
+    remove (package_path.c_str ());
+    //remove the PackageConfiguration externalization
+    remove (pc_path.c_str ());
 
-  //the PackageConfiguration externalization location
-  ACE_CString pc_path (path);
-  pc_path += PC_EXTENSION;        //external PackageConfiguration extension
+    this->dump ();
 
-  Deployment::PackageConfiguration_var pc;
-  ACE_NEW_THROW_EX (pc,
-                    Deployment::PackageConfiguration (),
-                    CORBA::NO_MEMORY ());
+    this->save ();
 
+    if (internal_err)
+      throw CORBA::INTERNAL ();
+    else
+      ACE_DEBUG ((LM_INFO, "Successfully deleted \'%s\'\n", installationName));
 
-  if(!RM_Helper::reincarnate (pc, pc_path.c_str ()))
-  {
-    ACE_ERROR ((LM_ERROR, "Could not reincarnate PC\n"));
-      internal_err = true;
   }
 
-  if (this->uuids_.unbind (ACE_CString (pc->UUID)) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Could not remove UUID\n"));
-    internal_err = true;
-  }
 
-  //remove the type from the interface map
-  if (!this->remove_type (pc, installationName))
+  //==========================================HELPER METHODS==================================================
+
+  Deployment::PackageConfiguration*
+  RepositoryManagerDaemon_i::retrieve_PC_from_package (char* package)
   {
-    ACE_ERROR ((LM_ERROR, "Could not remove type\n"));
-    internal_err = true;
-  }
+    char temp[128];
+    //  ACE_thread_t thread_id = ACE_Thread::self ();
+    char* PID = ACE_OS::itoa (ACE_OS::getpid (), temp, 10);
 
-  //actually delete the package here!
+    ACE_OS::mkdir(PID);
+    //if dir already exists a -1 is returned
+    //we ignore this, just need to make sure the directory exists
 
-  //clean the extracted files
-  remove_extracted_package (path.c_str ());
-  //remove the package
-  remove (package_path.c_str ());
-  //remove the PackageConfiguration externalization
-  remove (pc_path.c_str ());
+    //change the working dir
+    ACE_OS::chdir (PID);
 
-  this->dump ();
+    ACE_CString pcd_name;
+    //extract the necessary descriptors
+    if (extract_descriptor_files (package,
+                                  pcd_name) < 0)
+      {
+        ACE_OS::chdir (this->cwd_);
+        ACE_ERROR ((LM_ERROR,
+                    "(%P|%t) RepositoryManager: error extracting necessary files\n"));
+        throw CORBA::INTERNAL ();
+      }
 
-  this->save ();
+    Deployment::PackageConfiguration_var pc;
+    //parse the PCD to make sure that there are no package errors
+    try
+      {
+        //CIAO::Config_Handlers::STD_PC_Intf intf (pcd_name.c_str ());
+        //pc = intf.get_PC ();
+      }
+    catch (...)
+      {
+        ACE_ERROR ((LM_ERROR,
+                    "(%P|%t) RepositoryManager: Error parsing the PCD\n"));
 
-  if (internal_err)
-    throw CORBA::INTERNAL ();
-  else
-    ACE_DEBUG ((LM_INFO, "Successfully deleted \'%s\'\n", installationName));
+        //change back the the old working dir
+        ACE_OS::chdir (this->cwd_);
+        throw Deployment::PackageError ();
+      }
+    //able to parse the PC. So lets install the package in the repo
 
-}
+    //we no longer need the descriptors, so lets erase them!
+    remove_descriptor_files (package);
 
+    //change back the the old working dir
+    ACE_OS::chdir (this->cwd_);
 
-//==========================================HELPER METHODS==================================================
+    //now lets erase the directory!
+    ACE_OS::rmdir (PID);
+    //the ACE_OS::rmdir does not work. Possibly because we need to delete
+    //the contents first. I will look into it more closely when I am back.
 
-Deployment::PackageConfiguration*
-CIAO_RepositoryManagerDaemon_i::retrieve_PC_from_package (char* package)
-{
-  char temp[128];
-  //  ACE_thread_t thread_id = ACE_Thread::self ();
-  char* PID = ACE_OS::itoa (ACE_OS::getpid (), temp, 10);
-
-  ACE_OS::mkdir(PID);
-  //if dir already exists a -1 is returned
-  //we ignore this, just need to make sure the directory exists
-
-  //change the working dir
-  ACE_OS::chdir (PID);
-
-  ACE_CString pcd_name;
-  //extract the necessary descriptors
-  if (extract_descriptor_files (package,
-                                pcd_name) < 0)
-    {
-      ACE_OS::chdir (this->cwd_);
-      ACE_ERROR ((LM_ERROR,
-                  "(%P|%t) RepositoryManager: error extracting necessary files\n"));
-      throw CORBA::INTERNAL ();
-    }
-
-  Deployment::PackageConfiguration_var pc;
-  //parse the PCD to make sure that there are no package errors
-  try
-    {
-      //CIAO::Config_Handlers::STD_PC_Intf intf (pcd_name.c_str ());
-      //pc = intf.get_PC ();
-    }
-  catch (...)
-    {
-      ACE_ERROR ((LM_ERROR,
-                  "(%P|%t) RepositoryManager: Error parsing the PCD\n"));
-
-      //change back the the old working dir
-      ACE_OS::chdir (this->cwd_);
-      throw Deployment::PackageError ();
-    }
-  //able to parse the PC. So lets install the package in the repo
-
-  //we no longer need the descriptors, so lets erase them!
-  remove_descriptor_files (package);
-
-  //change back the the old working dir
-  ACE_OS::chdir (this->cwd_);
-
-  //now lets erase the directory!
-  ACE_OS::rmdir (PID);
-  //the ACE_OS::rmdir does not work. Possibly because we need to delete
-  //the contents first. I will look into it more closely when I am back.
-
-  return pc._retn ();
-}
+    return pc._retn ();
+  }
 
 
-//function to retvieve a file via HTTP
-//stores the file in the passed preallocated ACE_Message_Block
-//returns 1 on success
-//      0 on error
+  //function to retvieve a file via HTTP
+  //stores the file in the passed preallocated ACE_Message_Block
+  //returns 1 on success
+  //      0 on error
 
-int CIAO_RepositoryManagerDaemon_i::HTTP_Get (const char* URL, ACE_Message_Block &mb)
-{
+  int RepositoryManagerDaemon_i::HTTP_Get (const char* URL, ACE_Message_Block &mb)
+  {
     URL_Parser *parser = TheURL_Parser::instance ();
     if (!parser->parseURL (const_cast<char*> (URL)))
-    return 0;
+      return 0;
 
     // Create a client
     TAO_HTTP_Client client;
@@ -887,182 +880,182 @@ int CIAO_RepositoryManagerDaemon_i::HTTP_Get (const char* URL, ACE_Message_Block
     if (client.open (parser->filename_,
                      parser->hostname_,
                      parser->port_) == -1)
-    {
+      {
         client.close ();
         return 0;
-    }
+      }
 
     // Read from it
     if (client.read (&mb) <= 0)
-    {
+      {
         client.close ();
         return 0;
-    }
+      }
 
-  return 1;
-}
+    return 1;
+  }
 
 
 
-//function to parse and return the PackageConfiguration from the already
-//extracted descriptor files
-Deployment::PackageConfiguration*
-CIAO_RepositoryManagerDaemon_i::retrieve_PC_from_descriptors (const char* pc_name,
-                                                              const char* descriptor_dir)
-{
-  //change the working dir
-  ACE_OS::chdir (descriptor_dir);
-
-  Deployment::PackageConfiguration_var pc = new Deployment::PackageConfiguration ();
-  //parse the PCD to make sure that there are no package errors
-  try
-    {
-       CIAO::Config_Handlers::Packaging::PCD_Handler::package_config (pc_name, *pc);
-    }
-  catch (...)
-    {
-      ACE_ERROR ((LM_ERROR,
-                  "(%P|%t) [RM::retrieve_PC_from_descriptors] Error parsing the PCD\n"));
-
-      //change back the the old working dir
-      ACE_OS::chdir (this->cwd_);
-      throw Deployment::PackageError ();
-    }
-  //able to parse the PC. So lets install the package in the repo
-
-  //change back the the old working dir
-  ACE_OS::chdir (this->cwd_);
-
-  return pc._retn ();
-}
+  //function to parse and return the PackageConfiguration from the already
+  //extracted descriptor files
+  Deployment::PackageConfiguration*
+  RepositoryManagerDaemon_i::retrieve_PC_from_descriptors (const char* pc_name,
+                                                           const char* descriptor_dir)
+  {
+    //change the working dir
+    ACE_OS::chdir (descriptor_dir);
 
+    Deployment::PackageConfiguration_var pc = new Deployment::PackageConfiguration ();
+    //parse the PCD to make sure that there are no package errors
+    try
+      {
+        CIAO::Config_Handlers::Packaging::PCD_Handler::package_config (pc_name, *pc);
+      }
+    catch (...)
+      {
+        ACE_ERROR ((LM_ERROR,
+                    "(%P|%t) [RM::retrieve_PC_from_descriptors] Error parsing the PCD\n"));
 
-//find out what the name of the PackageConfiguration file is
-void CIAO_RepositoryManagerDaemon_i::find_PC_name (char* package, ACE_CString& pcd_name)
-{
-  pcd_name = "";  //empty the contents of the ACE_CString
+        //change back the the old working dir
+        ACE_OS::chdir (this->cwd_);
+        throw Deployment::PackageError ();
+      }
+    //able to parse the PC. So lets install the package in the repo
 
-  //create a doubly link list
-  ACE_New_Allocator allocator;
-  ACE_Double_Linked_List<ZIP_File_Info> list (&allocator);
+    //change back the the old working dir
+    ACE_OS::chdir (this->cwd_);
 
-  //get the list of files in the package and figure out the names of all necessary files
-  if (!(ZIP_Wrapper::file_list_info (package, list)))
-    return;
+    return pc._retn ();
+  }
 
-  size_t skip_len = ACE_OS::strlen ("descriptors") + 1;
 
-  while (!list.is_empty ())
-    {
-      ZIP_File_Info* inf = list.delete_head ();
+  //find out what the name of the PackageConfiguration file is
+  void RepositoryManagerDaemon_i::find_PC_name (char* package, ACE_CString& pcd_name)
+  {
+    pcd_name = "";  //empty the contents of the ACE_CString
 
-      if (ACE_OS::strstr (inf->name_.c_str (), "descriptors"))
-        if (ACE_OS::strstr (inf->name_.c_str (), ".pcd"))
-          pcd_name = inf->name_.c_str () + skip_len;
+    //create a doubly link list
+    ACE_New_Allocator allocator;
+    ACE_Double_Linked_List<ZIP_File_Info> list (&allocator);
 
-      //deallocate the head of the filename list
-      delete inf;
-    }
-}
+    //get the list of files in the package and figure out the names of all necessary files
+    if (!(ZIP_Wrapper::file_list_info (package, list)))
+      return;
 
+    size_t skip_len = ACE_OS::strlen ("descriptors") + 1;
 
-//We are using Xercesc in the Config_Handlers and unfortunately its API only
-//takes a file in the local file system as an argument, thus need to
-//write out the contents of the deployent plan to a file
-//in the current directory. I use the thread id to guarrantee
-//lack of race conditions if multithreading is enabled
+    while (!list.is_empty ())
+      {
+        ZIP_File_Info* inf = list.delete_head ();
 
-int CIAO_RepositoryManagerDaemon_i::extract_descriptor_files (char* package, ACE_CString& pcd_name)
-{
-  //create a doubly link list
-  ACE_New_Allocator allocator;
-  ACE_Double_Linked_List<ZIP_File_Info> list (&allocator);
+        if (ACE_OS::strstr (inf->name_.c_str (), "descriptors"))
+          if (ACE_OS::strstr (inf->name_.c_str (), ".pcd"))
+            pcd_name = inf->name_.c_str () + skip_len;
 
-  //get the list of files in the package and figure out the names of all necessary files
-  if (!(ZIP_Wrapper::file_list_info (package, list)))
-    return 0;
+        //deallocate the head of the filename list
+        delete inf;
+      }
+  }
 
-  size_t skip_len = ACE_OS::strlen ("descriptors") + 1;
 
-  while (!list.is_empty ())
-    {
-      ZIP_File_Info* inf = list.delete_head ();
-      ACE_Message_Block* file = 0;
-      if (ACE_OS::strstr (inf->name_.c_str (), "descriptors"))
-        {
-          if (ACE_OS::strstr (inf->name_.c_str (), ".pcd"))
-            pcd_name = inf->name_.c_str () + skip_len;
+  //We are using Xercesc in the Config_Handlers and unfortunately its API only
+  //takes a file in the local file system as an argument, thus need to
+  //write out the contents of the deployent plan to a file
+  //in the current directory. I use the thread id to guarrantee
+  //lack of race conditions if multithreading is enabled
 
-          //extract the descriptor from the package
-          ACE_NEW_RETURN (file, ACE_Message_Block (0,0), 0);
-          if (!ZIP_Wrapper::get_file(const_cast<char*> (package),
-                                     const_cast<char*> (inf->name_.c_str ()),
-                                     *file))
-            {
-              ACE_ERROR ((LM_ERROR,
-                          "[RM::extract_descriptor_files] Unable to retrieve file!\n"));
-              //release the message block chain
-              file->release ();
-              return 0;
-            }
-
-
-          //write the file to disk
-          if(!RM_Helper::write_to_disk (inf->name_.c_str () + skip_len, *file))
-            {
-              ACE_ERROR ((LM_ERROR,
-                          "[RM::extract_descriptor_files] Unable to write out descriptor to disk!\n"));
-              //release the message block chain
-              file->release ();
-              return 0;
-            }
-
-          //release the message block chain
-          file->release ();
-        }
-
-      //deallocate the head of the filename list
-      delete inf;
-    }
-
-  return 1;
-}
+  int RepositoryManagerDaemon_i::extract_descriptor_files (char* package, ACE_CString& pcd_name)
+  {
+    //create a doubly link list
+    ACE_New_Allocator allocator;
+    ACE_Double_Linked_List<ZIP_File_Info> list (&allocator);
 
-int CIAO_RepositoryManagerDaemon_i::remove_descriptor_files (char* package)
-{
-  int return_code = 1;
+    //get the list of files in the package and figure out the names of all necessary files
+    if (!(ZIP_Wrapper::file_list_info (package, list)))
+      return 0;
 
-  //create a doubly link list
-  ACE_New_Allocator allocator;
-  ACE_Double_Linked_List<ZIP_File_Info> list (&allocator);
+    size_t skip_len = ACE_OS::strlen ("descriptors") + 1;
 
-  //get the list of files in the package and figure out the names of all necessary files
-  if (!(ZIP_Wrapper::file_list_info (package, list)))
-    return 0;
+    while (!list.is_empty ())
+      {
+        ZIP_File_Info* inf = list.delete_head ();
+        ACE_Message_Block* file = 0;
+        if (ACE_OS::strstr (inf->name_.c_str (), "descriptors"))
+          {
+            if (ACE_OS::strstr (inf->name_.c_str (), ".pcd"))
+              pcd_name = inf->name_.c_str () + skip_len;
+
+            //extract the descriptor from the package
+            ACE_NEW_RETURN (file, ACE_Message_Block (0,0), 0);
+            if (!ZIP_Wrapper::get_file(const_cast<char*> (package),
+                                       const_cast<char*> (inf->name_.c_str ()),
+                                       *file))
+              {
+                ACE_ERROR ((LM_ERROR,
+                            "[RM::extract_descriptor_files] Unable to retrieve file!\n"));
+                //release the message block chain
+                file->release ();
+                return 0;
+              }
+
+
+            //write the file to disk
+            if(!RM_Helper::write_to_disk (inf->name_.c_str () + skip_len, *file))
+              {
+                ACE_ERROR ((LM_ERROR,
+                            "[RM::extract_descriptor_files] Unable to write out descriptor to disk!\n"));
+                //release the message block chain
+                file->release ();
+                return 0;
+              }
+
+            //release the message block chain
+            file->release ();
+          }
+
+        //deallocate the head of the filename list
+        delete inf;
+      }
 
-  size_t skip_len = ACE_OS::strlen ("descriptors") + 1;
-
-  while (!list.is_empty ())
-    {
-      ZIP_File_Info* inf = list.delete_head ();
-      if (ACE_OS::strstr (inf->name_.c_str (), "descriptors"))
-        {
-          //delete disk
-          if(remove (inf->name_.c_str () + skip_len))
-            {
-              ACE_ERROR ((LM_ERROR,
-                          "[RM::remove_descriptor_files] Unable to remove file from disk!\n"));
-              return_code = 0;
-            }
-        }
-      //deallocate the head of the filename list
-      delete inf;
-    }
-
-  return return_code;
-}
+    return 1;
+  }
+
+  int RepositoryManagerDaemon_i::remove_descriptor_files (char* package)
+  {
+    int return_code = 1;
+
+    //create a doubly link list
+    ACE_New_Allocator allocator;
+    ACE_Double_Linked_List<ZIP_File_Info> list (&allocator);
+
+    //get the list of files in the package and figure out the names of all necessary files
+    if (!(ZIP_Wrapper::file_list_info (package, list)))
+      return 0;
+
+    size_t skip_len = ACE_OS::strlen ("descriptors") + 1;
+
+    while (!list.is_empty ())
+      {
+        ZIP_File_Info* inf = list.delete_head ();
+        if (ACE_OS::strstr (inf->name_.c_str (), "descriptors"))
+          {
+            //delete disk
+            if(remove (inf->name_.c_str () + skip_len))
+              {
+                ACE_ERROR ((LM_ERROR,
+                            "[RM::remove_descriptor_files] Unable to remove file from disk!\n"));
+                return_code = 0;
+              }
+          }
+        //deallocate the head of the filename list
+        delete inf;
+      }
+
+    return return_code;
+  }
 
-int CIAO_RepositoryManagerDaemon_i::remove_extracted_package (const char* path)
+  int RepositoryManagerDaemon_i::remove_extracted_package (const char* path)
   {
     ACE_TCHAR full_path[MAXPATHLEN];
     ACE_OS::getcwd (full_path, sizeof(full_path));
@@ -1072,30 +1065,30 @@ int CIAO_RepositoryManagerDaemon_i::remove_extracted_package (const char* path)
     ACE_Dirent dir (path);
 
     for (ACE_DIRENT *directory; (directory = dir.read ()) != 0;)
-    {
-      if (ACE::isdotdir (directory->d_name) == true)
-        continue;
-
-      ACE_stat stat_buf;
-      ACE_OS::lstat (directory->d_name, &stat_buf);
-
-      ACE_CString temp = path;
-      temp += "/";
-      temp += directory->d_name;
-      switch (stat_buf.st_mode & S_IFMT)
-        {
-        case S_IFREG: // Either a regular file or an executable.   
-          remove (temp.c_str ());
-          break;
-
-        case S_IFDIR:
-          remove_extracted_package (temp.c_str ());
-          break;
-
-        default:
-          break;
-        }
-    }
+      {
+        if (ACE::isdotdir (directory->d_name) == true)
+          continue;
+
+        ACE_stat stat_buf;
+        ACE_OS::lstat (directory->d_name, &stat_buf);
+
+        ACE_CString temp = path;
+        temp += "/";
+        temp += directory->d_name;
+        switch (stat_buf.st_mode & S_IFMT)
+          {
+          case S_IFREG: // Either a regular file or an executable.   
+            remove (temp.c_str ());
+            break;
+
+          case S_IFDIR:
+            remove_extracted_package (temp.c_str ());
+            break;
+
+          default:
+            break;
+          }
+      }
     
     ACE_OS::chdir (full_path);
     
@@ -1104,122 +1097,123 @@ int CIAO_RepositoryManagerDaemon_i::remove_extracted_package (const char* path)
     return 0;
   }
 
-//function to extract the type of the component from
-//the PackageConfiguration and update the interface map
-//returns 1 on success
-//        0 on error
+  //function to extract the type of the component from
+  //the PackageConfiguration and update the interface map
+  //returns 1 on success
+  //        0 on error
 
-int CIAO_RepositoryManagerDaemon_i::add_type (Deployment::PackageConfiguration& pc,
-                                              const char* name)
-{
-  if (pc.basePackage.length () > 0)
+  int RepositoryManagerDaemon_i::add_type (Deployment::PackageConfiguration& pc,
+                                           const char* name)
   {
-    ::CORBA::StringSeq supportedTypes = pc.basePackage[0]
-                                        .implementation[0]
-                                        .referencedImplementation
-                                        .implements
-                                        .supportedType;
-
-    if (supportedTypes.length () != 0)
-    {
-      CORBA::ULong len = supportedTypes.length ();
-      for (CORBA::ULong i = 0; i < len; ++i)
+    if (pc.basePackage.length () > 0)
       {
-        this->types_.bind (ACE_CString (supportedTypes[i]), name);
+        ::CORBA::StringSeq supportedTypes = pc.basePackage[0]
+          .implementation[0]
+          .referencedImplementation
+          .implements
+          .supportedType;
+
+        if (supportedTypes.length () != 0)
+          {
+            CORBA::ULong len = supportedTypes.length ();
+            for (CORBA::ULong i = 0; i < len; ++i)
+              {
+                this->types_.bind (ACE_CString (supportedTypes[i]), name);
+              }
+          }
+      }
+    else //ComponentPackageReference
+      {
+        //not implemented yet
+        return 0;
       }
-    }
-  }
-  else //ComponentPackageReference
-  {
-    //not implemented yet
-    return 0;
-  }
 
-  return 1;
-}
+    return 1;
+  }
 
-//function to remove the interface type of the component
-//being removed from the interface map
-//returns 1 on success
-//        0 on error
+  //function to remove the interface type of the component
+  //being removed from the interface map
+  //returns 1 on success
+  //        0 on error
 
-int CIAO_RepositoryManagerDaemon_i::remove_type (Deployment::PackageConfiguration& pc,
-                                                 const char* name)
-{
-  if (pc.basePackage.length () > 0)
+  int RepositoryManagerDaemon_i::remove_type (Deployment::PackageConfiguration& pc,
+                                              const char* name)
   {
-    ::CORBA::StringSeq supportedTypes = pc.basePackage[0]
-                                        .implementation[0]
-                                        .referencedImplementation
-                                        .implements
-                                        .supportedType;
-
-    if (supportedTypes.length () != 0)
-    {
-      CORBA::ULong len = supportedTypes.length ();
-      for (CORBA::ULong i = 0; i < len; ++i)
+    if (pc.basePackage.length () > 0)
       {
-        if (this->types_.unbind (ACE_CString (supportedTypes[i]), ACE_CString (name)) != 0)
-          ACE_DEBUG ((LM_DEBUG, "Could not find type %s with package name %s!\n",
-                      ACE_CString (supportedTypes[i]).c_str (),
-                      name));
+        ::CORBA::StringSeq supportedTypes = pc.basePackage[0]
+          .implementation[0]
+          .referencedImplementation
+          .implements
+          .supportedType;
+
+        if (supportedTypes.length () != 0)
+          {
+            CORBA::ULong len = supportedTypes.length ();
+            for (CORBA::ULong i = 0; i < len; ++i)
+              {
+                if (this->types_.unbind (ACE_CString (supportedTypes[i]), ACE_CString (name)) != 0)
+                  ACE_DEBUG ((LM_DEBUG, "Could not find type %s with package name %s!\n",
+                              ACE_CString (supportedTypes[i]).c_str (),
+                              name));
+              }
+          }
+      }
+    else //ComponentPackageReference
+      {
+        //not implemented yet
+        return 0;
       }
-    }
-  }
-  else //ComponentPackageReference
-  {
-    //not implemented yet
-    return 0;
-  }
 
-  return 1;
-}
+    return 1;
+  }
 
-//function to dump the state of the RepositoryManager
-void CIAO_RepositoryManagerDaemon_i::dump (void)
-{
+  //function to dump the state of the RepositoryManager
+  void RepositoryManagerDaemon_i::dump (void)
+  {
 #if defined (ACE_HAS_DUMP)
 
-  ACE_DEBUG(LM_DEBUG, "NAMES:\n");
-  this->names_.dump ();
-  ACE_DEBUG(LM_DEBUG, "UUIDs:\n");
-  this->uuids_.dump ();
-  ACE_DEBUG (LM_DEBUG, "Component Interface Types:\n");
-  this->types_.dump ();
+    ACE_DEBUG(LM_DEBUG, "NAMES:\n");
+    this->names_.dump ();
+    ACE_DEBUG(LM_DEBUG, "UUIDs:\n");
+    this->uuids_.dump ();
+    ACE_DEBUG (LM_DEBUG, "Component Interface Types:\n");
+    this->types_.dump ();
 
 #endif /* ACE_HAS_DUMP */
-}
-
-//function to save the package info of the RepositoryManager
-void CIAO_RepositoryManagerDaemon_i::save (void)
-{
-  // Save the names, UUIDs, & types info to the configuration files.
-  ACE_Configuration_Heap cfg;
-  cfg.open ();
-  ACE_Configuration_Section_Key root = cfg.root_section ();
-
-  ACE_Configuration_Section_Key NameSection;
-  cfg.open_section (root, RM_RECORD_NAME_SECTION, 1, NameSection);
-  for (PCMap_Iterator iter = this->names_.begin ();
-    iter != this->names_.end ();
-    ++iter)
-  {
-    PCEntry& element = *iter;
-    cfg.set_string_value (NameSection, element.ext_id_.c_str (), element.int_id_.c_str ());
   }
 
-  ACE_Configuration_Section_Key UUIDSection;
-  cfg.open_section (root, RM_RECORD_UUID_SECTION, 1, UUIDSection);
-  for (PCMap_Iterator iter = this->uuids_.begin ();
-    iter != this->uuids_.end ();
-    ++iter)
+  //function to save the package info of the RepositoryManager
+  void RepositoryManagerDaemon_i::save (void)
   {
-    PCEntry& element = *iter;
-    cfg.set_string_value (UUIDSection, element.ext_id_.c_str (), element.int_id_.c_str ());
-  }
+    // Save the names, UUIDs, & types info to the configuration files.
+    ACE_Configuration_Heap cfg;
+    cfg.open ();
+    ACE_Configuration_Section_Key root = cfg.root_section ();
+
+    ACE_Configuration_Section_Key NameSection;
+    cfg.open_section (root, RM_RECORD_NAME_SECTION, 1, NameSection);
+    for (PCMap_Iterator iter = this->names_.begin ();
+         iter != this->names_.end ();
+         ++iter)
+      {
+        PCEntry& element = *iter;
+        cfg.set_string_value (NameSection, element.ext_id_.c_str (), element.int_id_.c_str ());
+      }
 
-  ACE_Registry_ImpExp exporter (cfg);
-  ACE_OS::chdir (install_path.c_str ());
-  exporter.export_config (RM_RECORD_FILE);
-  ACE_OS::chdir (this->cwd_);
+    ACE_Configuration_Section_Key UUIDSection;
+    cfg.open_section (root, RM_RECORD_UUID_SECTION, 1, UUIDSection);
+    for (PCMap_Iterator iter = this->uuids_.begin ();
+         iter != this->uuids_.end ();
+         ++iter)
+      {
+        PCEntry& element = *iter;
+        cfg.set_string_value (UUIDSection, element.ext_id_.c_str (), element.int_id_.c_str ());
+      }
+
+    ACE_Registry_ImpExp exporter (cfg);
+    ACE_OS::chdir (install_path.c_str ());
+    exporter.export_config (RM_RECORD_FILE);
+    ACE_OS::chdir (this->cwd_);
+  }
 }