Fairly extensive overhaul of the test code, and correcting some API-based gotchas found as a result of testing. First, test_basic.py code now uses api.py methods as opposed to lower level methods, ensuring we test what API consumers are most likely to use. Second, remote.py tests are (largely) complete and clean. In api.py and remote.py I've added a method to ensure that the API configurations are always up to date before API calls, preventing synchronization issues that previously had to be worked around. As a result of this the server.update() call is no more. The mechanism behind this remains rough and we may want to optimize things a bit later, though the API signatures around this new checking code are solid. Upgrading the internals should be possible to avoid additional reloading of the config. Ultimately we may want to teach cobbler's local API to ask cobbler's cobblerd for it's definitive copy though that is to be explored later.

14 files changed, 275 insertions, 164 deletions

diff --git a/CHANGELOG b/CHANGELOG
index 10398637..54f61d9a 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -38,6 +38,7 @@ Cobbler CHANGELOG
 - (FEAT) --environment parameter added to reposync
 - (BUGF) have triggers ignore dotfiles so directories can be version controlled (and so on)
 - (FEAT) init scripts and specfiles now install on SuSE
+- (TEST) added remote tests, moved existing unit tests to api.py methods 
 
 - Fri Sep 26 2008 - 1.2.5
 - (BUGF) expose --arch for "cobbler image add"
diff --git a/cobbler/api.py b/cobbler/api.py
index b7a509fa..1c7d40a4 100644
--- a/cobbler/api.py
+++ b/cobbler/api.py
@@ -72,6 +72,8 @@ class BootAPI:
         self.perms_ok = False
         if not BootAPI.__has_loaded:
 
+            self.modified_timestamp = 0
+
             # NOTE: we do not log all API actions, because
             # a simple CLI invocation may call adds and such
             # to load the config, which would just fill up
@@ -112,6 +114,38 @@ class BootAPI:
  
     def __setup_logger(self,name):
         return utils.setup_logger(name)
+    
+    def last_modified_time(self):
+        """
+        Returns the time of the last modification to cobbler, made by any
+        API instance, regardless of the serializer type.
+        """
+        if not os.path.exists("/var/lib/cobbler/.mtime"):
+            fd = open("/var/lib/cobbler/.mtime")
+            fd.write("0")
+            fd.close()
+            return 0
+        fd = open("/var/lib/cobbler/.mtime")
+        data = fd.read().strip()
+        return float(data)
+
+    def __needs_refresh(self):
+        """
+        Returns whether the configuration as of /now/ matches the configuration
+        on disk, requiring an API reload.
+        """
+        now = self.last_modified_time()
+        return (self.modified_timestamp < now)
+
+    def __refresh(self):
+        """
+        Reloads the configuration from disk in the event of an API change that
+        was initiated from /outside/ this current API handle. 
+        """
+        if self.__needs_refresh():
+           self.clear()
+           self.deserialize()
+           self.modified_timestamp = self.last_modified_time()
 
     def log(self,msg,args=None,debug=False):
         if debug:
@@ -183,62 +217,77 @@ class BootAPI:
         return self._config.settings()
 
     def copy_distro(self, ref, newname):
+        self.__refresh()
         self.log("copy_distro",[ref.name, newname])
         return self._config.distros().copy(ref,newname)
 
     def copy_profile(self, ref, newname):
+        self.__refresh()
         self.log("copy_profile",[ref.name, newname])
         return self._config.profiles().copy(ref,newname)
 
     def copy_system(self, ref, newname):
+        self.__refresh()
         self.log("copy_system",[ref.name, newname])
         return self._config.systems().copy(ref,newname)
 
     def copy_repo(self, ref, newname):
+        self.__refresh()
         self.log("copy_repo",[ref.name, newname])
         return self._config.repos().copy(ref,newname)
     
     def copy_image(self, ref, newname):
+        self.__refresh()
         self.log("copy_image",[ref.name, newname])
         return self._config.images().copy(ref,newname)
 
     def remove_distro(self, ref, recursive=False):
+        self.__refresh()
         self.log("remove_distro",[ref.name])
         return self._config.distros().remove(ref.name, recursive=recursive)
 
     def remove_profile(self,ref, recursive=False):
+        self.__refresh()
         self.log("remove_profile",[ref.name])
         return self._config.profiles().remove(ref.name, recursive=recursive)
 
-    def remove_system(self,ref, recursive=False):
+    def remove_system(self, ref, recursive=False):
+        self.__refresh()
         self.log("remove_system",[ref.name])
         return self._config.systems().remove(ref.name)
 
-    def remove_repo(self, ref,recursive=False):
+    def remove_repo(self, ref, recursive=False):
+        self.__refresh()
         self.log("remove_repo",[ref.name])
         return self._config.repos().remove(ref.name)
     
-    def remove_image(self, ref):
+    def remove_image(self, ref, recursive=False):
+        self.__refresh()
         self.log("remove_image",[ref.name])
-        return self._config.images().remove(ref.name)
+        return self._config.images().remove(ref.name, recursive=recursive)
 
     def rename_distro(self, ref, newname):
+        self.__refresh()
         self.log("rename_distro",[ref.name,newname])
         return self._config.distros().rename(ref,newname)
 
     def rename_profile(self, ref, newname):
+        self.__refresh()
         self.log("rename_profiles",[ref.name,newname])
         return self._config.profiles().rename(ref,newname)
 
     def rename_system(self, ref, newname):
+        self.__refresh()
         self.log("rename_system",[ref.name,newname])
         return self._config.systems().rename(ref,newname)
 
     def rename_repo(self, ref, newname):
+        self.__refresh()
         self.log("rename_repo",[ref.name,newname])
         return self._config.repos().rename(ref,newname)
     
     def rename_image(self, ref, newname):
+        self.__refresh()
         self.log("rename_image",[ref.name,newname])
         return self._config.images().rename(ref,newname)
 
@@ -263,38 +312,48 @@ class BootAPI:
         return self._config.new_image(is_subobject=is_subobject)
 
     def add_distro(self, ref, check_for_duplicate_names=False):
+        self.__refresh()
         self.log("add_distro",[ref.name])
         return self._config.distros().add(ref,save=True,check_for_duplicate_names=check_for_duplicate_names)
 
     def add_profile(self, ref, check_for_duplicate_names=False):
+        self.__refresh()
         self.log("add_profile",[ref.name])
         return self._config.profiles().add(ref,save=True,check_for_duplicate_names=check_for_duplicate_names)
 
     def add_system(self, ref, check_for_duplicate_names=False, check_for_duplicate_netinfo=False):
+        self.__refresh()
         self.log("add_system",[ref.name])
         return self._config.systems().add(ref,save=True,check_for_duplicate_names=check_for_duplicate_names,check_for_duplicate_netinfo=check_for_duplicate_netinfo)
 
     def add_repo(self, ref, check_for_duplicate_names=False):
+        self.__refresh()
         self.log("add_repo",[ref.name])
         return self._config.repos().add(ref,save=True,check_for_duplicate_names=check_for_duplicate_names)
     
     def add_image(self, ref, check_for_duplicate_names=False):
+        self.__refresh()
         self.log("add_image",[ref.name])
         return self._config.images().add(ref,save=True,check_for_duplicate_names=check_for_duplicate_names)
 
     def find_distro(self, name=None, return_list=False, no_errors=False, **kargs):
+        self.__refresh()
         return self._config.distros().find(name=name, return_list=return_list, no_errors=no_errors, **kargs)
 
     def find_profile(self, name=None, return_list=False, no_errors=False, **kargs):
+        self.__refresh()
         return self._config.profiles().find(name=name, return_list=return_list, no_errors=no_errors, **kargs)
 
     def find_system(self, name=None, return_list=False, no_errors=False, **kargs):
+        self.__refresh()
         return self._config.systems().find(name=name, return_list=return_list, no_errors=no_errors, **kargs)
 
     def find_repo(self, name=None, return_list=False, no_errors=False, **kargs):
+        self.__refresh()
         return self._config.repos().find(name=name, return_list=return_list, no_errors=no_errors, **kargs)
 
     def find_image(self, name=None, return_list=False, no_errors=False, **kargs):
+        self.__refresh()
         return self._config.images().find(name=name, return_list=return_list, no_errors=no_errors, **kargs)
 
     def dump_vars(self, obj, format=False):
@@ -396,6 +455,7 @@ class BootAPI:
         /tftpboot.  Any operations done in the API that have not been
         saved with serialize() will NOT be synchronized with this command.
         """
+        self.__refresh()
         self.log("sync")
         sync = self.get_sync()
         return sync.run()
@@ -418,6 +478,7 @@ class BootAPI:
         Take the contents of /var/lib/cobbler/repos and update them --
         or create the initial copy if no contents exist yet.
         """
+        self.__refresh()
         self.log("reposync",[name])
         reposync = action_reposync.RepoSync(self._config, tries=tries, nofail=nofail)
         return reposync.run(name)
@@ -464,12 +525,14 @@ class BootAPI:
     def deserialize(self):
         """
         Load the current configuration from config file(s)
+        Cobbler internal use only.
         """
         return self._config.deserialize()
 
     def deserialize_raw(self,collection_name):
         """
         Get the collection back just as raw data.
+        Cobbler internal use only.
         """
         return self._config.deserialize_raw(collection_name)
 
@@ -477,12 +540,14 @@ class BootAPI:
         """
         Get an object back as raw data.
         Can be very fast for shelve or catalog serializers
+        Cobbler internal use only.
         """
         return self._config.deserialize_item_raw(collection_name,obj_name)
 
     def get_module_by_name(self,module_name):
         """
         Returns a loaded cobbler module named 'name', if one exists, else None.
+        Cobbler internal use only.
         """
         return module_loader.get_module_by_name(module_name)
 
@@ -491,18 +556,21 @@ class BootAPI:
         Looks in /etc/cobbler/modules.conf for a section called 'section'
         and a key called 'name', and then returns the module that corresponds
         to the value of that key.
+        Cobbler internal use only.
         """
         return module_loader.get_module_from_file(section,name,fallback)
 
     def get_modules_in_category(self,category):
         """
         Returns all modules in a given category, for instance "serializer", or "cli".
+        Cobbler internal use only.
         """
         return module_loader.get_modules_in_category(category)
 
     def authenticate(self,user,password):
         """
         (Remote) access control.
+        Cobbler internal use only.
         """
         rc = self.authn.authenticate(self,user,password)
         self.log("authenticate",[user,rc])
@@ -511,6 +579,7 @@ class BootAPI:
     def authorize(self,user,resource,arg1=None,arg2=None):
         """
         (Remote) access control.
+        Cobbler internal use only.
         """
         rc = self.authz.authorize(self,user,resource,arg1,arg2,acl_engine=self.acl_engine)
         self.log("authorize",[user,resource,arg1,arg2,rc],debug=True)
diff --git a/cobbler/collection.py b/cobbler/collection.py
index 3df7234c..7f3a3aac 100644
--- a/cobbler/collection.py
+++ b/cobbler/collection.py
@@ -144,6 +144,9 @@ class Collection(serializable.Serializable):
             item = self.factory_produce(self.config,seed_data)
             self.add(item)
 
+    def copy(self,ref,newname):
+        ref.name = newname
+        return self.add(ref,save=True,with_copy=True,with_triggers=True,with_sync=True,check_for_duplicate_names=True,check_for_duplicate_netinfo=False)
 
     def rename(self,ref,newname,with_sync=True,with_triggers=True):
         """
diff --git a/cobbler/collection_distros.py b/cobbler/collection_distros.py
index ac545637..34acf971 100644
--- a/cobbler/collection_distros.py
+++ b/cobbler/collection_distros.py
@@ -69,7 +69,10 @@ class Distros(collection.Collection):
                     lite_sync = action_litesync.BootLiteSync(self.config)
                     lite_sync.remove_single_profile(name)
             del self.listing[name]
+
+            print "DEBUG: serialize delete called"
             self.config.serialize_delete(self, obj)
+
             if with_delete:
                 self.log_func("deleted distro %s" % name)
                 if with_triggers: 
@@ -98,5 +101,7 @@ class Distros(collection.Collection):
                    utils.rmtree(path)
 
             return True
-        raise CX(_("cannot delete object that does not exist: %s") % name)
+
+        # raise CX(_("cannot delete object that does not exist: %s") % name)
+        return False
 
diff --git a/cobbler/collection_images.py b/cobbler/collection_images.py
index 9bc2109c..706c2baa 100644
--- a/cobbler/collection_images.py
+++ b/cobbler/collection_images.py
@@ -56,5 +56,6 @@ class Images(collection.Collection):
                 if with_triggers:
                     self._run_triggers(obj, "/var/lib/cobbler/triggers/delete/image/post/*")
             return True
-        raise CX(_("cannot delete an object that does not exist: %s") % name)
 
+        # raise CX(_("cannot delete an object that does not exist: %s") % name)
+        return False
diff --git a/cobbler/collection_profiles.py b/cobbler/collection_profiles.py
index e86a353b..c2547288 100644
--- a/cobbler/collection_profiles.py
+++ b/cobbler/collection_profiles.py
@@ -75,5 +75,6 @@ class Profiles(collection.Collection):
                 if with_triggers: 
                     self._run_triggers(obj, "/var/lib/cobbler/triggers/delete/profile/post/*")
             return True
-        raise CX(_("cannot delete an object that does not exist: %s") % name)
 
+        # raise CX(_("cannot delete an object that does not exist: %s") % name)
+        return False
diff --git a/cobbler/collection_repos.py b/cobbler/collection_repos.py
index 8ce150d4..75d5653f 100644
--- a/cobbler/collection_repos.py
+++ b/cobbler/collection_repos.py
@@ -71,5 +71,6 @@ class Repos(collection.Collection):
                     utils.rmtree(path)
 
             return True
-        raise CX(_("cannot delete an object that does not exist: %s") % name)
+        # raise CX(_("cannot delete an object that does not exist: %s") % name)
+        return False
 
diff --git a/cobbler/collection_systems.py b/cobbler/collection_systems.py
index 45af6206..40c78a6c 100644
--- a/cobbler/collection_systems.py
+++ b/cobbler/collection_systems.py
@@ -64,6 +64,7 @@ class Systems(collection.Collection):
                     self._run_triggers(obj, "/var/lib/cobbler/triggers/delete/system/post/*")
 
             return True
-        raise CX(_("cannot delete an object that does not exist: %s") % name)
-    
+        
+        # raise CX(_("cannot delete an object that does not exist: %s") % name)
+        return False 
      
diff --git a/cobbler/config.py b/cobbler/config.py
index 3d270d82..d399fee6 100644
--- a/cobbler/config.py
+++ b/cobbler/config.py
@@ -44,8 +44,8 @@ from utils import _
 
 class Config:
 
-   #has_loaded = False
-   #__shared_state = {}
+   has_loaded = False
+   __shared_state = {}
 
 
    def __init__(self,api):
@@ -54,14 +54,15 @@ class Config:
        Constructor.  Manages a definitive copy of all data collections with weakrefs
        pointing back into the class so they can understand each other's contents
        """
-       #self.__dict__ = Config.__shared_state
-       #if not Config.has_loaded:
-       self.__load(api)
+
+       self.__dict__ = Config.__shared_state
+       if not Config.has_loaded:
+          self.__load(api)
            
 
    def __load(self,api):
 
-       #Config.has_loaded  = True
+       Config.has_loaded  = True
 
        self.api           = api
        self._distros      = distros.Distros(weakref.proxy(self))
diff --git a/cobbler/pxegen.py b/cobbler/pxegen.py
index 32c67b96..012689b4 100644
--- a/cobbler/pxegen.py
+++ b/cobbler/pxegen.py
@@ -489,6 +489,12 @@ class PXEGen:
         del blended["ks_meta"]
         blended.update(ksmeta) # make available at top level
 
+        (success, templates) = utils.input_string_or_hash(templates)
+
+        if not success:
+            return results
+
+
         for template in templates.keys():
             dest = templates[template]
             
diff --git a/cobbler/remote.py b/cobbler/remote.py
index 035e9059..937be77c 100644
--- a/cobbler/remote.py
+++ b/cobbler/remote.py
@@ -78,11 +78,6 @@ class CobblerXMLRPCInterface:
     def ping(self):
         return True
 
-    def update(self,token=None):
-        # ensure the config is up to date as of /now/
-        self.api.deserialize()
-        return True
-
     def get_user_from_token(self,token):
         if not TOKEN_CACHE.has_key(token):
             raise CX(_("invalid token: %s") % token)
@@ -256,7 +251,6 @@ class CobblerXMLRPCInterface:
         implications.
         READ: https://fedorahosted.org/cobbler/wiki/AutoRegistration
         """
-        self._refresh()
 
         if mac is None:
             # don't go further if not being called by anaconda
@@ -297,7 +291,6 @@ class CobblerXMLRPCInterface:
         """
         self._log("disable_netboot",token=token,name=name)
         # used by nopxe.cgi
-        self._refresh()
         if not self.api.settings().pxe_just_once:
             # feature disabled!
             return False
@@ -335,16 +328,6 @@ class CobblerXMLRPCInterface:
 
         return True
 
-    def _refresh(self):
-        """
-        Internal function to reload cobbler's configuration from disk.  This is used to prevent any out
-        of band management (the cobbler CLI, or yaml hacking, etc) from resulting in the
-        cobbler state of XMLRPC API's daemon being different from the actual on-disk state.
-        """
-        self.api.clear() 
-        self.api.deserialize()
-
-
     def version(self,token=None,**rest):
         """
         Return the cobbler version for compatibility testing with remote applications.
@@ -496,8 +479,7 @@ class CobblerXMLRPCInterface:
         Same as get_distro_as_rendered.
         """
         self._log("get_distro_as_rendered",name=name,token=token)
-        self._refresh()
-        obj = self.api.distros().find(name=name)
+        obj = self.api.find_distro(name=name)
         if obj is not None:
             return self._fix_none(utils.blender(self.api, True, obj))
         return self._fix_none({})
@@ -515,8 +497,7 @@ class CobblerXMLRPCInterface:
         Same as get_profile_as_rendered
         """
         self._log("get_profile_as_rendered", name=name, token=token)
-        self._refresh()
-        obj = self.api.profiles().find(name=name)
+        obj = self.api.find_profile(name=name)
         if obj is not None:
             return self._fix_none(utils.blender(self.api, True, obj))
         return self._fix_none({})
@@ -534,8 +515,7 @@ class CobblerXMLRPCInterface:
         Same as get_system_as_rendered.
         """
         self._log("get_system_as_rendered",name=name,token=token)
-        self._refresh()
-        obj = self.api.systems().find(name=name)
+        obj = self.api.find_system(name=name)
         if obj is not None:
            return self._fix_none(utils.blender(self.api, True, obj))
         return self._fix_none({})
@@ -553,8 +533,7 @@ class CobblerXMLRPCInterface:
         Same as get_repo_as_rendered.
         """
         self._log("get_repo_as_rendered",name=name,token=token)
-        self._refresh()
-        obj = self.api.repos().find(name=name)
+        obj = self.api.find_repo(name=name)
         if obj is not None:
             return self._fix_none(utils.blender(self.api, True, obj))
         return self._fix_none({})
@@ -572,8 +551,7 @@ class CobblerXMLRPCInterface:
         Same as get_image_as_rendered.
         """
         self._log("get_image_as_rendered",name=name,token=token)
-        self._refresh()
-        obj = self.api.images().find(name=name)
+        obj = self.api.find_image(name=name)
         if obj is not None:
             return self._fix_none(utils.blender(self.api, True, obj))
         return self._fix_none({})
@@ -585,7 +563,6 @@ class CobblerXMLRPCInterface:
         Used in the webui
         """
         self._log("get_random_mac",token=None)
-        self._refresh()
         return utils.get_random_mac(self.api)
 
     def _fix_none(self,data):
@@ -945,7 +922,6 @@ class CobblerReadWriteXMLRPCInterface(CobblerXMLRPCInterface):
         """
         self._log("get_distro_handle",token=token,name=name)
         self.check_access(token,"get_distro_handle")
-        self._refresh()
         found = self.api.distros().find(name)
         return self.__store_object(found)   
 
@@ -957,7 +933,6 @@ class CobblerReadWriteXMLRPCInterface(CobblerXMLRPCInterface):
         """
         self._log("get_profile_handle",token=token,name=name)
         self.check_access(token,"get_profile_handle")
-        self._refresh()
         found = self.api.profiles().find(name)
         return self.__store_object(found)   
 
@@ -969,7 +944,6 @@ class CobblerReadWriteXMLRPCInterface(CobblerXMLRPCInterface):
         """
         self._log("get_system_handle",name=name,token=token)
         self.check_access(token,"get_system_handle")
-        self._refresh()
         found = self.api.systems().find(name)
         return self.__store_object(found)   
 
@@ -981,7 +955,6 @@ class CobblerReadWriteXMLRPCInterface(CobblerXMLRPCInterface):
         """
         self._log("get_repo_handle",name=name,token=token)
         self.check_access(token,"get_repo_handle")
-        self._refresh()
         found = self.api.repos().find(name)
         return self.__store_object(found)   
 
@@ -993,7 +966,6 @@ class CobblerReadWriteXMLRPCInterface(CobblerXMLRPCInterface):
         """
         self._log("get_image_handle",name=name,token=token)
         self.check_access(token,"get_image_handle")
-        self._refresh()
         found = self.api.images().find(name)
         return self.__store_object(found)
 
@@ -1001,69 +973,64 @@ class CobblerReadWriteXMLRPCInterface(CobblerXMLRPCInterface):
         """
         Saves a newly created or modified distro object to disk.
         """
-        self._refresh()
         self._log("save_distro",object_id=object_id,token=token)
         obj = self.__get_object(object_id)
         self.check_access(token,"save_distro",obj)
         if editmode == "new":
-            return self.api.distros().add(obj,save=True,check_for_duplicate_names=True)
+            return self.api.add_distro(obj,check_for_duplicate_names=True)
         else:
-            return self.api.distros().add(obj,save=True)
+            return self.api.add_distro(obj)
 
     def save_profile(self,object_id,token,editmode="bypass"):
         """
         Saves a newly created or modified profile object to disk.
         """
-        self._refresh()
         self._log("save_profile",token=token,object_id=object_id)
         obj = self.__get_object(object_id)
         self.check_access(token,"save_profile",obj)
         if editmode == "new":
-           return self.api.profiles().add(obj,save=True,check_for_duplicate_names=True)
+           return self.api.add_profile(obj,check_for_duplicate_names=True)
         else:
-           return self.api.profiles().add(obj,save=True)
+           return self.api.add_profile(obj)
 
     def save_system(self,object_id,token,editmode="bypass"):
         """
         Saves a newly created or modified system object to disk.
         """
-        self._refresh()
         self._log("save_system",token=token,object_id=object_id)
         obj = self.__get_object(object_id)
         self.check_access(token,"save_system",obj)
         if editmode == "new":
-           return self.api.systems().add(obj,save=True,check_for_duplicate_names=True,check_for_duplicate_netinfo=True)
+           return self.api.add_system(obj,check_for_duplicate_names=True,check_for_duplicate_netinfo=True)
         elif editmode == "edit":
-           return self.api.systems().add(obj,save=True,check_for_duplicate_netinfo=True)
+           return self.api.add_system(obj,check_for_duplicate_netinfo=True)
         else:
-           return self.api.systems().add(obj,save=True)
+           return self.api.add_system(obj)
            
 
     def save_repo(self,object_id,token=None,editmode="bypass"):
         """
         Saves a newly created or modified repo object to disk.
         """
-        self._refresh()
         self._log("save_repo",object_id=object_id,token=token)
         obj = self.__get_object(object_id)
         self.check_access(token,"save_repo",obj)
         if editmode == "new":
-           return self.api.repos().add(obj,save=True,check_for_duplicate_names=True)
+           return self.api.add_repo(obj,check_for_duplicate_names=True)
         else:
-           return self.api.repos().add(obj,save=True)
+           return self.api.add_repo(obj)
 
     def save_image(self,object_id,token=None,editmode="bypass"):
         """
         Saves a newly created or modified repo object to disk.
         """
-        self._refresh()
         self._log("save_image",object_id=object_id,token=token)
         obj = self.__get_object(object_id)
         self.check_access(token,"save_image",obj)
         if editmode == "new":
-           return self.api.images().add(obj,save=True,check_for_duplicate_names=True)
+           return self.api.add_image(obj,check_for_duplicate_names=True)
         else:
-           return self.api.images().add(obj,save=True)
+           return self.api.add_image(obj)
 
     ## FIXME: refactor out all of the boilerplate stuff like ^^
 
@@ -1072,35 +1039,30 @@ class CobblerReadWriteXMLRPCInterface(CobblerXMLRPCInterface):
         All copy methods are pretty much the same.  Get an object handle, pass in the new
         name for it.
         """
-        self._refresh()
         self._log("copy_distro",object_id=object_id,token=token)
         self.check_access(token,"copy_distro")
         obj = self.__get_object(object_id)
         return self.api.copy_distro(obj,newname)
 
-    def copy_profile(self,object_id,token=None):
-        self._refresh()
+    def copy_profile(self,object_id,newname,token=None):
         self._log("copy_profile",object_id=object_id,token=token)
         self.check_access(token,"copy_profile")
         obj = self.__get_object(object_id)
         return self.api.copy_profile(obj,newname)
 
-    def copy_system(self,object_id,token=None):
-        self._refresh()
+    def copy_system(self,object_id,newname,token=None):
         self._log("copy_system",object_id=object_id,token=token)
         self.check_access(token,"copy_system")
         obj = self.__get_object(object_id)
         return self.api.copy_system(obj,newname)
 
-    def copy_repo(self,object_id,token=None):
-        self._refresh()
+    def copy_repo(self,object_id,newname,token=None):
         self._log("copy_repo",object_id=object_id,token=token)
         self.check_access(token,"copy_repo")
         obj = self.__get_object(object_id)
         return self.api.copy_repo(obj,newname)
 
-    def copy_image(self,object_id,token=None):
-        self._refresh()
+    def copy_image(self,object_id,newname,token=None):
         self._log("copy_image",object_id=object_id,token=token)
         self.check_access(token,"copy_image")
         obj = self.__get_object(object_id)
@@ -1112,35 +1074,30 @@ class CobblerReadWriteXMLRPCInterface(CobblerXMLRPCInterface):
         name for it.  Rename will modify dependencies to point them at the new
         object.  
         """
-        self._refresh()
         self._log("rename_distro",object_id=object_id,token=token)
         self.api.deserialize() # FIXME: make this unneeded
         obj = self.__get_object(object_id)
         return self.api.rename_distro(obj,newname)
 
     def rename_profile(self,object_id,newname,token=None):
-        self._refresh()
         self._log("rename_profile",object_id=object_id,token=token)
         self.check_access(token,"rename_profile")
         obj = self.__get_object(object_id)
         return self.api.rename_profile(obj,newname)
 
     def rename_system(self,object_id,newname,token=None):
-        self._refresh()
         self._log("rename_system",object_id=object_id,token=token)
         self.check_access(token,"rename_system")
         obj = self.__get_object(object_id)
         return self.api.rename_system(obj,newname)
 
     def rename_repo(self,object_id,newname,token=None):
-        self._refresh()
         self._log("rename_repo",object_id=object_id,token=token)
         self.check_access(token,"rename_repo")
         obj = self.__get_object(object_id)
         return self.api.rename_repo(obj,newname)
     
     def rename_image(self,object_id,newname,token=None):
-        self._refresh()
         self._log("rename_image",object_id=object_id,token=token)
         self.check_access(token,"rename_image")
         self.api.deserialize() # FIXME: make this unneeded
@@ -1209,7 +1166,10 @@ class CobblerReadWriteXMLRPCInterface(CobblerXMLRPCInterface):
         """
         self._log("remove_distro (%s)" % recursive,name=name,token=token)
         self.check_access(token, "remove_distro", name)
-        rc = self.api._config.distros().remove(name,recursive=True)
+        distro = self.api.find_distro(name)
+        if distro is None:
+            return False
+        rc = self.api.remove_distro(distro,recursive=True)
         return rc
 
     def remove_profile(self,name,token,recursive=1):
@@ -1218,7 +1178,10 @@ class CobblerReadWriteXMLRPCInterface(CobblerXMLRPCInterface):
         """
         self._log("remove_profile (%s)" % recursive,name=name,token=token)
         self.check_access(token, "remove_profile", name)
-        rc = self.api._config.profiles().remove(name,recursive=True)
+        profile = self.api.find_profile(name)
+        if profile is None:
+            return False
+        rc = self.api.remove_profile(profile,recursive=True)
         return rc
 
     def remove_system(self,name,token,recursive=1):
@@ -1228,7 +1191,10 @@ class CobblerReadWriteXMLRPCInterface(CobblerXMLRPCInterface):
         """
         self._log("remove_system (%s)" % recursive,name=name,token=token)
         self.check_access(token, "remove_system", name)
-        rc = self.api._config.systems().remove(name,recursive=True)
+        system = self.api.find_system(name)
+        if system is None:
+            return False
+        rc = self.api.remove_system(system)
         return rc
 
     def remove_repo(self,name,token,recursive=1):
@@ -1238,7 +1204,10 @@ class CobblerReadWriteXMLRPCInterface(CobblerXMLRPCInterface):
         """
         self._log("remove_repo (%s)" % recursive,name=name,token=token)
         self.check_access(token, "remove_repo", name)
-        rc = self.api._config.repos().remove(name,recursive=True)
+        repo = self.api.find_repo(name)
+        if repo is None:
+            return False
+        rc = self.api.remove_repo(repo, recursive=True)
         return rc
 
     def remove_image(self,name,token,recursive=1):
@@ -1248,7 +1217,8 @@ class CobblerReadWriteXMLRPCInterface(CobblerXMLRPCInterface):
         """
         self._log("remove_image (%s)" % recursive,name=name,token=token)
         self.check_access(token, "remove_image", name)
-        rc = self.api._config.images().remove(name,recursive=True)
+        image = self.api.find_image(name)
+        rc = self.api.remove_image(image, recursive=True)
         return rc
 
     def read_or_write_kickstart_template(self,kickstart_file,is_read,new_data,token):
@@ -1260,6 +1230,7 @@ class CobblerReadWriteXMLRPCInterface(CobblerXMLRPCInterface):
         Also if living in /etc/cobbler the file must be a kickstart file.
         """
 
+
         if is_read:
            what = "read_kickstart_template"
         else:
@@ -1437,9 +1408,6 @@ def test_xmlrpc_ro():
    # reposync is required in order to create the repo config files
    api.reposync(name="repo0")
    
-   # verify we have the new config in cobblerd
-   server.update()
-
    # FIXME: the following tests do not yet look to see that all elements
    # retrieved match what they were created with, but we presume this
    # all works.  It is not a high priority item to test but do not assume
@@ -1527,7 +1495,6 @@ def test_xmlrpc_ro():
    # compatible profiles, etc
 
    assert server.ping() == True
-   assert server.update() == True
 
    assert server.get_size("distros") == 1
    assert server.get_size("profiles") == 1
@@ -1747,16 +1714,25 @@ def test_xmlrpc_rw():
    assert iid != None
 
    # test renames
-   server.rename_distro(did, "distro2", token)
-   # note: have to get new handles after rename (??)
+   rc = server.rename_distro(did, "distro2", token)
+   assert rc == True
+   # object has changed due to parent rename, get a new handle
    pid = server.get_profile_handle("profile1", token)
    assert pid != None
-   server.rename_profile(pid, "profile2", token)
+   rc = server.rename_profile(pid, "profile2", token)
+   assert rc == True
+   # object has changed due to parent rename, get a new handle
    sid = server.get_system_handle("system1", token)
    assert sid != None
-   server.rename_system(sid, "system2", token)
-   server.rename_repo(rid, "repo2", token)
-   server.rename_image(iid, "image2", token)
+   rc = server.rename_system(sid, "system2", token)
+   assert rc == True
+   rc = server.rename_repo(rid, "repo2", token)
+   assert rc == True
+   rc = server.rename_image(iid, "image2", token)
+   assert rc == True
+   
+   # FIXME: make the following code unneccessary
+   api.clear()
    api.deserialize()
 
    assert api.find_distro("distro2") != None
@@ -1767,11 +1743,15 @@ def test_xmlrpc_rw():
 
    # BOOKMARK: currently here in terms of test testing.
 
-   assert api.find_distro("distro1") is None
-   assert api.find_profile("profile1") is None
-   assert api.find_repo("repo1") is None
-   assert api.find_image("image1") is None
-   assert api.find_system("system1") is None
+   for d in api.distros():
+      print "FOUND DISTRO: %s" % d.name
+
+
+   assert api.find_distro("distro1") == None
+   assert api.find_profile("profile1") == None
+   assert api.find_repo("repo1") == None
+   assert api.find_image("image1") == None
+   assert api.find_system("system1") == None
    
    did = server.get_distro_handle("distro2", token)
    assert did != None
@@ -1809,15 +1789,15 @@ def test_xmlrpc_rw():
    server.remove_distro("distro1", token)
    server.remove_repo("repo1", token)
    server.remove_image("image1", token)
+
    server.remove_system("system2", token)
    server.remove_profile("profile2", token)
    server.remove_distro("distro2", token)
    server.remove_repo("repo2", token)
    server.remove_image("image2", token)
 
-   # FIXME: reduce boilerplate code here
-
-   assert api.find_distro("distro1") is None
+   d1 = api.find_distro("distro1")
+   assert d1 is None
    assert api.find_profile("profile1") is None
    assert api.find_repo("repo1") is None
    assert api.find_image("image1") is None
diff --git a/cobbler/serializer.py b/cobbler/serializer.py
index dab3bf2d..f12a15d9 100644
--- a/cobbler/serializer.py
+++ b/cobbler/serializer.py
@@ -28,6 +28,7 @@ import fcntl
 import traceback
 import sys
 import signal
+import time
 
 from cexceptions import *
 import api as cobbler_api
@@ -69,7 +70,14 @@ def __grab_lock():
         traceback.print_exc()
         sys.exit(7)
 
-def __release_lock():
+def __release_lock(with_changes=False):
+    if with_changes:
+        # this file is used to know when the last config change
+        # was made -- allowing the API to work more smoothly without
+        # a lot of unneccessary reloads.  
+        fd = open("/var/lib/cobbler/.mtime","w")
+        fd.write("%f" % time.time())
+        fd.close()
     if LOCK_ENABLED:
         LOCK_HANDLE = open("/var/lib/cobbler/lock","r")
         fcntl.flock(LOCK_HANDLE.fileno(), fcntl.LOCK_UN)
@@ -99,7 +107,7 @@ def serialize_item(collection, item):
         rc = storage_module.serialize(collection)
     else:
         rc = save_fn(collection,item)
-    __release_lock()
+    __release_lock(with_changes=True)
     return rc
 
 def serialize_delete(collection, item):
@@ -113,7 +121,7 @@ def serialize_delete(collection, item):
         rc = storage_module.serialize(collection)
     else:
         rc = delete_fn(collection,item)
-    __release_lock()
+    __release_lock(with_changes=True)
     return rc
 
 def deserialize(obj,topological=True):
diff --git a/cobbler/test_basic.py b/cobbler/test_basic.py
index 33a4cebd..a9cd1408 100644
--- a/cobbler/test_basic.py
+++ b/cobbler/test_basic.py
@@ -31,7 +31,6 @@ FAKE_INITRD3="initrd-1.8.18-3.9999_FAKE.img"
 FAKE_KERNEL="vmlinuz-2.6.15-1.2054_FAKE"
 FAKE_KERNEL2="vmlinuz-2.5.16-2.2055_FAKE"
 FAKE_KERNEL3="vmlinuz-1.8.18-3.9999_FAKE"
-FAKE_KICKSTART="http://127.0.0.1/fake.ks"
 
 cleanup_dirs = []
 
@@ -64,9 +63,11 @@ class BootTest(unittest.TestCase):
         self.make_basic_config()
 
     def tearDown(self):
+
         d1 = self.api.find_distro("D1")
         if d1:
             self.api.remove_distro(d1,recursive=True)
+
         d2 = self.api.find_distro("testdistro0")
         if d2:
             self.api.remove_distro(d2,recursive=True)
@@ -75,7 +76,7 @@ class BootTest(unittest.TestCase):
         if testrepo:
             testrepo = self.api.remove_repo(testrepo)
 
-        testimage = self.api.find_repo("testimage")
+        testimage = self.api.find_repo("testimage0")
         if testimage:
             self.api.remove_image(testimage)
 
@@ -93,17 +94,17 @@ class BootTest(unittest.TestCase):
         profile = self.api.new_profile()
         self.assertTrue(profile.set_name("testprofile0"))
         self.assertTrue(profile.set_distro("testdistro0"))
-        self.assertTrue(profile.set_kickstart(FAKE_KICKSTART))
+        self.assertTrue(profile.set_kickstart("/etc/cobbler/sample_end.ks"))
         self.assertTrue(self.api.add_profile(profile))
         self.assertTrue(self.api.find_profile(name="testprofile0"))
 
         system = self.api.new_system()
-        self.assertTrue(system.set_name("drwily.rdu.redhat.com"))
+        self.assertTrue(system.set_name("testsystem0"))
         self.assertTrue(system.set_mac_address("BB:EE:EE:EE:EE:FF","intf0"))
         self.assertTrue(system.set_ip_address("192.51.51.50","intf0"))
         self.assertTrue(system.set_profile("testprofile0"))
         self.assertTrue(self.api.add_system(system))
-        self.assertTrue(self.api.find_system(name="drwily.rdu.redhat.com"))
+        self.assertTrue(self.api.find_system(name="testsystem0"))
 
         repo = self.api.new_repo()
         try:
@@ -113,15 +114,51 @@ class BootTest(unittest.TestCase):
         fd = open("/tmp/test_example_cobbler_repo/test.file", "w+")
         fd.write("hello!")
         fd.close()
-        self.assertTrue(repo.set_name("test_repo"))
+        self.assertTrue(repo.set_name("testrepo0"))
         self.assertTrue(repo.set_mirror("/tmp/test_example_cobbler_repo"))
         self.assertTrue(self.api.add_repo(repo))
 
         image = self.api.new_image()
-        self.assertTrue(image.set_name("test_image"))
+        self.assertTrue(image.set_name("testimage0"))
         self.assertTrue(image.set_file("/etc/hosts")) # meaningless path
         self.assertTrue(self.api.add_image(image))
 
+
+class RenameTest(BootTest):
+
+    def __tester(self, finder, renamer, name1, name2):
+
+        x = finder(name1)
+        assert x is not None
+
+        renamer(x, name2)
+        x = finder(name1)
+        y = finder(name2)
+        assert x is None
+        assert y is not None
+        
+        renamer(y, name1) 
+        x = finder(name1)
+        y = finder(name2)
+        assert x is not None
+        assert y is None 
+
+    def test_distro_renames(self):
+        self.__tester(self.api.find_distro, self.api.rename_distro, "testdistro0", "testdistro1")
+
+    def test_profile_renames(self):
+        self.__tester(self.api.find_profile, self.api.rename_profile, "testprofile0", "testprofile1")
+
+    def test_system_renames(self):
+        self.__tester(self.api.find_system, self.api.rename_system, "testsystem0", "testsystem1")
+
+    def testrepo_renames(self):
+        self.__tester(self.api.find_repo, self.api.rename_repo, "testrepo0", "testrepo1")
+
+    def test_image_renames(self):
+        self.__tester(self.api.find_image, self.api.rename_image, "testimage0", "testimage1")
+
+
 class DuplicateNamesAndIpPrevention(BootTest):
 
     """
@@ -136,8 +173,8 @@ class DuplicateNamesAndIpPrevention(BootTest):
         # find things we are going to test with
         distro1 = self.api.find_distro(name="testdistro0")
         profile1 = self.api.find_profile(name="testprofile0")
-        system1 = self.api.find_system(name="drwily.rdu.redhat.com")
-        repo1 = self.api.find_repo(name="test_repo")
+        system1 = self.api.find_system(name="testsystem0")
+        repo1 = self.api.find_repo(name="testrepo0")
 
         # make sure we can't overwrite a previous distro with
         # the equivalent of an "add" (not an edit) on the
@@ -175,7 +212,7 @@ class DuplicateNamesAndIpPrevention(BootTest):
 
         # repeat the check for systems (just names this time)
         system2 = self.api.new_system()
-        self.assertTrue(system2.set_name("drwily.rdu.redhat.com"))
+        self.assertTrue(system2.set_name("testsystem0"))
         self.assertTrue(system2.set_profile("testprofile0"))
         # this should fail
         try:
@@ -189,7 +226,7 @@ class DuplicateNamesAndIpPrevention(BootTest):
 
         # repeat the check for repos
         repo2 = self.api.new_repo()
-        self.assertTrue(repo2.set_name("test_repo"))
+        self.assertTrue(repo2.set_name("testrepo0"))
         self.assertTrue(repo2.set_mirror("http://imaginary"))
         # self.failUnlessRaises(CobblerException,self.api.add_repo,[repo,check_for_duplicate_names=True])
         try:
@@ -257,8 +294,8 @@ class Ownership(BootTest):
         # find things we are going to test with
         distro = self.api.find_distro(name="testdistro0")
         profile = self.api.find_profile(name="testprofile0")
-        system = self.api.find_system(name="drwily.rdu.redhat.com")
-        repo = self.api.find_repo(name="test_repo")
+        system = self.api.find_system(name="testsystem0")
+        repo = self.api.find_repo(name="testrepo0")
 
         # as we didn't specify an owner for objects, the default
         # ownership should be as specified in settings
@@ -307,8 +344,8 @@ class Ownership(BootTest):
 
         xo = self.api.find_distro("testdistro0")
         xn = "testdistro0"
-        ro = self.api.find_repo("test_repo")
-        rn = "test_repo"
+        ro = self.api.find_repo("testrepo0")
+        rn = "testrepo0"
 
         # WARNING: complex test explanation follows! 
         # we must ensure those who can edit the kickstart are only those
@@ -393,17 +430,15 @@ class MultiNIC(BootTest):
         self.assertTrue(system.set_ip_address("192.168.1.26","intf4"))
         self.assertTrue(system.set_subnet("255.255.255.0","intf4"))
         self.assertTrue(system.set_dhcp_tag("tag2","intf5"))
-        self.assertTrue(self.api.systems().add(system))
-        # mixing in some higher level API calls with some lower level internal stuff
-        # just to make sure it's all good.
-        self.assertTrue(self.api.find_system(hostname="zero"))
-        self.assertTrue(self.api.systems().find(mac_address="EE:FF:DD:CC:DD:CC"))
-        self.assertTrue(self.api.systems().find(ip_address="127.0.0.5"))
+        self.assertTrue(self.api.add_system(system))
+        self.assertTrue(self.api.find_system(hostname="fooserver"))
+        self.assertTrue(self.api.find_system(mac_address="EE:FF:DD:CC:DD:CC"))
+        self.assertTrue(self.api.find_system(ip_address="127.0.0.5"))
         self.assertTrue(self.api.find_system(virt_bridge="zero"))
-        self.assertTrue(self.api.systems().find(gateway="192.168.1.25"))
-        self.assertTrue(self.api.systems().find(subnet="255.255.255.0"))
+        self.assertTrue(self.api.find_system(gateway="192.168.1.25"))
+        self.assertTrue(self.api.find_system(subnet="255.255.255.0"))
         self.assertTrue(self.api.find_system(dhcp_tag="tag2"))
-        self.assertTrue(self.api.systems().find(dhcp_tag="zero"))
+        self.assertTrue(self.api.find_system(dhcp_tag="zero"))
 
         # verify that systems has exactly 5 interfaces
         self.assertTrue(len(system.interfaces.keys()) == 6)
@@ -455,11 +490,11 @@ class Utilities(BootTest):
         self.assertTrue(utils.is_mac("00:C0:B7:7E:55:50"))
         self.assertTrue(utils.is_mac("00:c0:b7:7E:55:50"))
         self.assertFalse(utils.is_mac("00.D0.B7.7E.55.50"))
-        self.assertFalse(utils.is_mac("drwily.rdu.redhat.com"))
+        self.assertFalse(utils.is_mac("testsystem0"))
         self.assertTrue(utils.is_ip("127.0.0.1"))
         self.assertTrue(utils.is_ip("192.168.1.1"))
         self.assertFalse(utils.is_ip("00:C0:B7:7E:55:50"))
-        self.assertFalse(utils.is_ip("drwily.rdu.redhat.com"))
+        self.assertFalse(utils.is_ip("testsystem0"))
 
     def test_some_random_find_commands(self):
         # initial setup...
@@ -488,7 +523,7 @@ class Utilities(BootTest):
         self.assertTrue(distro.set_name("testdistro2"))
         self.failUnlessRaises(CobblerException,distro.set_kernel,"filedoesntexist")
         self.assertTrue(distro.set_initrd(self.fk_initrd))
-        self.failUnlessRaises(CobblerException, self.api.distros().add, distro)
+        self.failUnlessRaises(CobblerException, self.api.add_distro, distro)
         self.assertFalse(self.api.distros().find(name="testdistro2"))
 
     def test_invalid_distro_non_referenced_initrd(self):
@@ -496,15 +531,15 @@ class Utilities(BootTest):
         self.assertTrue(distro.set_name("testdistro3"))
         self.assertTrue(distro.set_kernel(self.fk_kernel))
         self.failUnlessRaises(CobblerException, distro.set_initrd, "filedoesntexist")
-        self.failUnlessRaises(CobblerException, self.api.distros().add, distro)
+        self.failUnlessRaises(CobblerException, self.api.add_distro, distro)
         self.assertFalse(self.api.distros().find(name="testdistro3"))
 
     def test_invalid_profile_non_referenced_distro(self):
         profile = self.api.new_profile()
         self.assertTrue(profile.set_name("testprofile11"))
         self.failUnlessRaises(CobblerException, profile.set_distro, "distrodoesntexist")
-        self.assertTrue(profile.set_kickstart(FAKE_KICKSTART))
-        self.failUnlessRaises(CobblerException, self.api.profiles().add, profile)
+        self.assertTrue(profile.set_kickstart("/etc/cobbler/sample.ks"))
+        self.failUnlessRaises(CobblerException, self.api.add_profile, profile)
         self.assertFalse(self.api.profiles().find(name="testprofile2"))
 
     def test_invalid_profile_kickstart_not_url(self):
@@ -513,7 +548,7 @@ class Utilities(BootTest):
         self.assertTrue(profile.set_distro("testdistro0"))
         self.failUnlessRaises(CobblerException, profile.set_kickstart, "kickstartdoesntexist")
         # since kickstarts are optional, you can still add it
-        self.assertTrue(self.api.profiles().add(profile))
+        self.assertTrue(self.api.add_profile(profile))
         self.assertTrue(self.api.profiles().find(name="testprofile12"))
         # now verify the other kickstart forms would still work
         self.assertTrue(profile.set_kickstart("http://bar"))
@@ -534,7 +569,7 @@ class Utilities(BootTest):
         self.assertTrue(profile.set_virt_cpus("2"))
         self.failUnlessRaises(Exception, profile.set_virt_cpus, "3.14")
         self.failUnlessRaises(Exception, profile.set_virt_cpus, "6.02*10^23")
-        self.assertTrue(self.api.profiles().add(profile))
+        self.assertTrue(self.api.add_profile(profile))
 
     def test_inheritance_and_variable_propogation(self):
 
@@ -561,7 +596,7 @@ class Utilities(BootTest):
         self.assertTrue(profile.set_distro("testdistro0"))
         self.assertTrue(profile.set_kickstart("http://127.0.0.1/foo"))
         self.assertTrue(profile.set_repos(["testrepo"]))
-        self.assertTrue(self.api.profiles().add(profile))
+        self.assertTrue(self.api.add_profile(profile))
 
         # disable this test as it's not a valid repo yet
         # self.api.reposync()
@@ -571,7 +606,7 @@ class Utilities(BootTest):
         self.assertTrue(system.set_name("foo"))
         self.assertTrue(system.set_profile("testprofile12b2"))
         self.assertTrue(system.set_ksmeta({"asdf" : "jkl" }))
-        self.assertTrue(self.api.systems().add(system))
+        self.assertTrue(self.api.add_system(system))
         profile = self.api.profiles().find("testprofile12b2")
         ksmeta = profile.ks_meta
         self.assertFalse(ksmeta.has_key("asdf"))
@@ -584,7 +619,7 @@ class Utilities(BootTest):
         profile2 = self.api.new_profile(is_subobject=True)
         profile2.set_name("testprofile12b3")
         profile2.set_parent("testprofile12b2")
-        self.assertTrue(self.api.profiles().add(profile2))
+        self.api.add_profile(profile2)
         # disable this test as syncing an invalid repo will fail
         # self.api.reposync()
         self.api.sync()
@@ -596,7 +631,7 @@ class Utilities(BootTest):
         self.assertTrue(system2.set_name("foo2"))
         self.assertTrue(system2.set_profile("testprofile12b3"))
         self.assertTrue(system2.set_ksmeta({"narf" : "troz"}))
-        self.assertTrue(self.api.systems().add(system2))
+        self.assertTrue(self.api.add_system(system2))
         # disable this test as invalid repos don't sync
         # self.api.reposync()
         self.api.sync()
@@ -616,19 +651,19 @@ class Utilities(BootTest):
         
         repo2 = self.api.new_repo()
         try:
-           os.makedirs("/tmp/cobbler_test_repo")
+           os.makedirs("/tmp/cobbler_test/repo0")
         except:
            pass
-        fd = open("/tmp/cobbler_test_repo/file.test","w+")
+        fd = open("/tmp/cobbler_test/repo0/file.test","w+")
         fd.write("Hi!")
         fd.close()
         self.assertTrue(repo2.set_name("testrepo2"))
-        self.assertTrue(repo2.set_mirror("/tmp/cobbler_test_repo"))
+        self.assertTrue(repo2.set_mirror("/tmp/cobbler_test/repo0"))
         self.assertTrue(self.api.repos().add(repo2))
         profile2 = self.api.profiles().find("testprofile12b3")
         # note: side check to make sure we can also set to string values
         profile2.set_repos("testrepo2")       
-        self.api.profiles().add(profile2) # save it 
+        self.api.add_profile(profile2) # save it 
 
         # random bug testing: run sync several times and ensure cardinality doesn't change
         #self.api.reposync()
@@ -680,7 +715,7 @@ class Utilities(BootTest):
 
         profile2 = self.api.profiles().find("testprofile12b3")
         profile2.set_ksmeta({"canyouseethis" : "yes" })
-        self.assertTrue(self.api.profiles().add(profile2))
+        self.assertTrue(self.api.add_profile(profile2))
         system2 = self.api.systems().find("foo2")
         data = utils.blender(self.api, False, system2)
         self.assertTrue(data.has_key("ks_meta"))
@@ -691,7 +726,7 @@ class Utilities(BootTest):
         
         profile = self.api.profiles().find("testprofile12b2")
         profile.set_ksmeta({"canyouseethisalso" : "yes" })
-        self.assertTrue(self.api.profiles().add(profile))
+        self.assertTrue(self.api.add_profile(profile))
         system2 = self.api.systems().find("foo2")
         data = utils.blender(self.api, False, system2)
         self.assertTrue(data.has_key("ks_meta"))
@@ -718,7 +753,7 @@ class Utilities(BootTest):
         name = "00:16:41:14:B7:71"
         self.assertTrue(system.set_name(name))
         self.assertTrue(system.set_profile("testprofile0"))
-        self.assertTrue(self.api.systems().add(system))
+        self.assertTrue(self.api.add_system(system))
         self.assertTrue(self.api.systems().find(name=name))
         self.assertTrue(self.api.systems().find(mac_address="00:16:41:14:B7:71"))
         self.assertFalse(self.api.systems().find(mac_address="thisisnotamac"))
@@ -728,14 +763,14 @@ class Utilities(BootTest):
         name = "192.168.1.54"
         self.assertTrue(system.set_name(name))
         self.assertTrue(system.set_profile("testprofile0"))
-        self.assertTrue(self.api.systems().add(system))
+        self.assertTrue(self.api.add_system(system))
         self.assertTrue(self.api.systems().find(name=name))
 
     def test_invalid_system_non_referenced_profile(self):
         system = self.api.new_system()
-        self.assertTrue(system.set_name("drwily.rdu.redhat.com"))
+        self.assertTrue(system.set_name("testsystem0"))
         self.failUnlessRaises(CobblerException, system.set_profile, "profiledoesntexist")
-        self.failUnlessRaises(CobblerException, self.api.systems().add, system)
+        self.failUnlessRaises(CobblerException, self.api.add_system, system)
 
 class SyncContents(BootTest):
 
@@ -748,22 +783,22 @@ class SyncContents(BootTest):
         self.assertTrue(distro.set_name("D1"))
         self.assertTrue(distro.set_kernel(fake_file))
         self.assertTrue(distro.set_initrd(fake_file))
-        self.assertTrue(self.api.distros().add(distro, with_copy=True))
-        self.assertTrue(self.api.distros().find(name="D1"))
+        self.assertTrue(self.api.add_distro(distro))
+        self.assertTrue(self.api.find_distro(name="D1"))
 
         profile = self.api.new_profile()
         self.assertTrue(profile.set_name("P1"))
         self.assertTrue(profile.set_distro("D1"))
         self.assertTrue(profile.set_kickstart(fake_file))
-        self.assertTrue(self.api.profiles().add(profile, with_copy=True))
-        self.assertTrue(self.api.profiles().find(name="P1"))
+        self.assertTrue(self.api.add_profile(profile))
+        assert self.api.find_profile(name="P1") != None
 
         system = self.api.new_system()
         self.assertTrue(system.set_name("S1"))
         self.assertTrue(system.set_mac_address("BB:EE:EE:EE:EE:FF","intf0"))
         self.assertTrue(system.set_profile("P1"))
-        self.assertTrue(self.api.systems().add(system, with_copy=True))
-        self.assertTrue(self.api.systems().find(name="S1"))
+        self.assertTrue(self.api.add_system(system))
+        assert self.api.find_system(name="S1") != None
 
         # ensure that the system after being added has the right template data
         # in /tftpboot
@@ -789,6 +824,7 @@ class SyncContents(BootTest):
         else:
             fh = open("/tftpboot/pxelinux.cfg/%s" % converted)
         data = fh.read()
+        print "DEBUG DATA: %s" % data
         self.assertTrue(data.find("/op/ks/") != -1)
         fh.close()
 
@@ -796,17 +832,17 @@ class SyncContents(BootTest):
 class Deletions(BootTest):
 
     def test_invalid_delete_profile_doesnt_exist(self):
-        self.failUnlessRaises(CobblerException, self.api.profiles().remove, "doesnotexist")
+        assert self.api.profiles().remove("doesnotexist") == False
 
     def test_invalid_delete_profile_would_orphan_systems(self):
         self.make_basic_config()
         self.failUnlessRaises(CobblerException, self.api.profiles().remove, "testprofile0")
 
     def test_invalid_delete_system_doesnt_exist(self):
-        self.failUnlessRaises(CobblerException, self.api.systems().remove, "doesnotexist")
+        assert self.api.systems().remove("doesnotexist") == False
 
     def test_invalid_delete_distro_doesnt_exist(self):
-        self.failUnlessRaises(CobblerException, self.api.distros().remove, "doesnotexist")
+        assert self.api.distros().remove("doesnotexist") == False
 
     def test_invalid_delete_distro_would_orphan_profile(self):
         self.make_basic_config()
@@ -815,11 +851,11 @@ class Deletions(BootTest):
     def test_working_deletes(self):
         self.api.clear()
         self.make_basic_config()
-        self.assertTrue(self.api.systems().remove("drwily.rdu.redhat.com"))
+        self.assertTrue(self.api.systems().remove("testsystem0"))
         self.api.serialize()
         self.assertTrue(self.api.profiles().remove("testprofile0"))
         self.assertTrue(self.api.distros().remove("testdistro0"))
-        self.assertFalse(self.api.systems().find(name="drwily.rdu.redhat.com"))
+        self.assertFalse(self.api.systems().find(name="testsystem0"))
         self.assertFalse(self.api.profiles().find(name="testprofile0"))
         self.assertFalse(self.api.distros().find(name="testdistro0"))
 
diff --git a/cobbler/webui/CobblerWeb.py b/cobbler/webui/CobblerWeb.py
index 14e2041e..f58142ea 100644
--- a/cobbler/webui/CobblerWeb.py
+++ b/cobbler/webui/CobblerWeb.py
@@ -62,7 +62,6 @@ class CobblerWeb(object):
                 self.remote.token_check(self.token)
                 self.username = self.remote.get_user_from_token(self.token)
                 # ensure config is up2date
-                self.remote.update(self.token)
                 return True
             except Exception, e:
                 if str(e).find("invalid token") != -1:
@@ -82,7 +81,6 @@ class CobblerWeb(object):
                 return False
             self.password = None # don't need it anymore, get rid of it
             # ensure configuration is up2date
-            self.remote.update(self.token)
             return True
         
         # login failed