more explicit error catching

also fixed some unused imports along the way

IPython/html/services/contents/contentmanager.py

@@ -1,147 +1,203 b''
 """A base class contents manager.
 
 Authors:
 
 * Zach Sailer
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2013  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import datetime
 import io
 import os
 import glob
 import shutil
-import ast
-import base64
+import errno
 
 from tornado import web
 
 from IPython.config.configurable import LoggingConfigurable
-from IPython.nbformat import current
-from IPython.utils.traitlets import List, Dict, Unicode, TraitError
+from IPython.utils.traitlets import Unicode, TraitError
 from IPython.utils import tz
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class ContentManager(LoggingConfigurable):
     
     content_dir = Unicode(os.getcwdu(), config=True, help="""
             The directory to use for contents.
             """)
 
     def get_os_path(self, fname=None, path='/'):
         """Given a notebook name and a server URL path, return its file system
         path.
         
         Parameters
         ----------
         fname : string
             The name of a notebook file with the .ipynb extension
         path : string
             The relative URL path (with '/' as separator) to the named
             notebook.
             
         Returns
         -------
         path : string
             A file system path that combines notebook_dir (location where
             server started), the relative path, and the filename with the
             current operating system's url.
         """
         parts = path.split('/')
         parts = [p for p in parts if p != ''] # remove duplicate splits
         if fname is not None:
             parts += [fname]
         path = os.path.join(self.content_dir, *parts)
         return path
 
     def get_content_names(self, content_path='/'):
         """Returns list of names in the server's root + relative
         location given by 'content_path'."""
         names = os.listdir(self.get_os_path(None, content_path))
         return names
 
     def list_contents(self, content_path='/'):
         """Returns a list of dictionaries including info for all
         contents in the location given by 'content_path'.
         
         Parameters
         ----------
         content_path: str
             the relative path/location of the desired files.
         
         Returns
         -------
         contents: list of dicts
             a the contents of each dict includes information for each item 
             in the named location given by 'content_path'.
         """
         names = self.get_content_names(content_path)
         contents = list()
         dirs = list()
         notebooks = list()
         for name in names:
             if os.path.isdir(name) == True:
                 dirs.append(os.path.split(name)[1])
             elif os.path.splitext(name)[1] == '.ipynb':
                 notebooks.append(os.path.split(name)[1])        
             else:
                 contents.append(os.path.split(name)[1])        
         return dirs, notebooks, contents
 
     def list_contents(self, content_path):
         """List all contents in the named path."""
         dir_names, notebook_names, content_names = self.get_content_names(content_path)
         content_mapping = []
         for name in dir_names:
             model = self.content_model(name, content_path, type='dir')
             content_mapping.append(model)
         for name in content_names:
             model = self.content_model(name, content_path, type='file')
             content_mapping.append(model)
         for name in notebook_names:
             model = self.content_model(name, content_path, type='notebook')
             content_mapping.append(model)
         return content_mapping
 
     def get_path_by_name(self, name, content_path):
         """Return a full path to content"""
         path = os.path.join(self.content_dir, content_path, name)
         return path
 
     def content_info(self, name, content_path):
         """Read the content of a named file"""
         file_type = os.path.splitext(os.path.basename(name))[1]
         full_path = self.get_path_by_name(name, content_path)
         info = os.stat(full_path)
         size = info.st_size
         last_modified = tz.utcfromtimestamp(info.st_mtime)
         return last_modified, file_type, size
 
     def content_model(self, name, content_path, type=None):
         """Create a dict standard model for any file (other than notebooks)"""
         last_modified, file_type, size = self.content_info(name, content_path)
         model = {"name": name,
                     "path": content_path,
                     "type": type,
                     "MIME-type": "",
                     "last_modified (UTC)": last_modified.ctime(),
                     "size": size}
         return model
 
-    def delete_content(self, content_path):
-        """Delete a file"""
-        os.unlink(os.path.join(self.content_dir, content_path))
+    def create_folder(self, name, path):
+        """
+        Parameters
+        ----------
+        name : str
+            The name you want give to the folder thats created. 
+            If this is None, it will assign an incremented name
+            'new_folder'.
+        path : str
+            The relative location to put the created folder.
+            
+        Returns
+        -------
+            The name of the created folder.
+        """
+        if name is None:
+            name = self.increment_filename("new_folder", path)
+        new_path = self.get_os_path(name, path)
+        # Raise an error if the file exists
+        try:
+            os.makedirs(new_path)
+        except OSError as e:
+            if e.errno == errno.EEXIST:
+                raise web.HTTPError(409, u'Directory already exists.')
+            elif e.errno == errno.EACCES:
+                raise web.HTTPError(403, u'Create dir: permission denied.')
+            else:
+                raise web.HTTPError(400, str(e))
+        return name
         
+    def increment_filename(self, basename, content_path='/'):
+        """Return a non-used filename of the form basename<int>.
+
+        This searches through the filenames (basename0, basename1, ...)
+        until is find one that is not already being used. It is used to
+        create Untitled and Copy names that are unique.
+        """
+        i = 0
+        while True:
+            name = u'%s%i' % (basename,i)
+            path = self.get_os_path(name, content_path)
+            if not os.path.isdir(path):
+                break
+            else:
+                i = i+1
+        return name
+
+    def delete_content(self, name=None, content_path='/'):
+        """Delete a file or folder in the named location. 
+        Raises an error if the named file/folder doesn't exist
+        """
+        path = self.get_os_path(name, content_path)
+        if path != self.content_dir:
+            try:
+                shutil.rmtree(path)
+            except OSError as e:
+                if e.errno == errno.ENOENT:
+                    raise web.HTTPError(404, u'Directory or file does not exist.')
+                else:
+                    raise web.HTTPError(400, str(e))
+        else:
+            raise web.HTTPError(403, "Cannot delete root directory where notebook server lives.")

IPython/html/services/contents/tests/test_contentmanger.py

@@ -1,111 +1,115 b''
 """Tests for the content manager."""
 
 import os
 from unittest import TestCase
 from tempfile import NamedTemporaryFile
 
 from IPython.utils.tempdir import TemporaryDirectory
 from IPython.utils.traitlets import TraitError
 
 from ..contentmanager import ContentManager
 
 
 class TestContentManager(TestCase):
 
     def test_new_folder(self):
         with TemporaryDirectory() as td:
             # Test that a new directory/folder is created
             cm = ContentManager(content_dir=td)
             name = cm.new_folder(None, '/')
             path = cm.get_os_path(name, '/')
             self.assertTrue(os.path.isdir(path))
             
             # Test that a new directory is created with
             # the name given.
             name = cm.new_folder('foo')
             path = cm.get_os_path(name)
             self.assertTrue(os.path.isdir(path))
             
             # Test that a new directory/folder is created
             # in the '/foo' subdirectory
             name1 = cm.new_folder(None, '/foo/')
             path1 = cm.get_os_path(name1, '/foo/')
             self.assertTrue(os.path.isdir(path1))
 
             # make another file and make sure it incremented
             # the name and does not write over another file.
             name2 = cm.new_folder(None, '/foo/')
             path2 = cm.get_os_path(name, '/foo/')
             self.assertEqual(name2, 'new_folder1')
             
             # Test that an HTTP Error is raised when the user
             # tries to create a new folder with a name that 
             # already exists
             bad_name = 'new_folder1'
             self.assertRaises(HTTPError, cm.new_folder, name=bad_name, path='/foo/')
 
     def test_delete_folder(self):
         with TemporaryDirectory() as td:
             # Create a folder
             cm = ContentManager(content_dir=td)
             name = cm.new_folder('test_folder', '/')
             path = cm.get_os_path(name, '/')
             
             # Raise an exception when trying to delete a 
             # folder that does not exist.
-            self.assertRaises(TraitError, cm.delete_content, name='non_existing_folder', content_path='/')
+            self.assertRaises(HTTPError, cm.delete_content, name='non_existing_folder', content_path='/')
             
             # Create a subfolder in the folder created above. 
             # *Recall 'name' = 'test_folder' (the new path for
             # subfolder)
             name01 = cm.new_folder(None, name)
             path01 = cm.get_os_path(name01, name)
             # Try to delete a subfolder that does not exist.
-            self.assertRaises(TraitError, cm.delete_content, name='non_existing_folder', content_path='/')
+            self.assertRaises(HTTPError, cm.delete_content, name='non_existing_folder', content_path='/')
             # Delete the created subfolder
             cm.delete_content(name01, name)
             self.assertFalse(os.path.isdir(path01))
             
             # Delete the created folder
             cm.delete_content(name, '/')
             self.assertFalse(os.path.isdir(path))
             
+            self.assertRaises(HTTPError, cm.delete_content, name=None, content_path='/')
+            self.assertRaises(HTTPError, cm.delete_content, name='/', content_path='/')
+            
+            
     def test_get_content_names(self):
         with TemporaryDirectory() as td:
             # Create a few folders and subfolders
             cm = ContentManager(content_dir=td)
             name1 = cm.new_folder('fold1', '/')
             name2 = cm.new_folder('fold2', '/')
             name3 = cm.new_folder('fold3', '/')
             name01 = cm.new_folder('fold01', 'fold1')
             name02 = cm.new_folder('fold02', 'fold1')
             name03 = cm.new_folder('fold03', 'fold1')
             
             # List the names in the root folder
             names = cm.get_content_names('/')
             expected = ['fold1', 'fold2', 'fold3']
             self.assertEqual(set(names), set(expected))
             
             # List the names in the subfolder 'fold1'.
             names = cm.get_content_names('fold1')
             expected = ['fold01', 'fold02', 'fold03']
             self.assertEqual(set(names), set(expected))
 
     def test_content_model(self):
         with TemporaryDirectory() as td:
             # Create a few folders and subfolders
             cm = ContentManager(content_dir=td)
             name1 = cm.new_folder('fold1', '/')
             name2 = cm.new_folder('fold2', '/')
             name01 = cm.new_folder('fold01', 'fold1')
             name02 = cm.new_folder('fold02', 'fold1')
             
             # Check to see if the correct model and list of 
             # model dicts are returned for root directory
             # and subdirectory.
             contents = cm.list_contents('/')
             contents1 = cm.list_contents('fold1')
             self.assertEqual(type(contents), type(list()))
             self.assertEqual(type(contents[0]), type(dict()))
             self.assertEqual(contents[0]['path'], '/')
             self.assertEqual(contents1[0]['path'], 'fold1')