Merge "Rename module name from glusterfs to gluster"

9 files changed, 131 insertions, 129 deletions

diff --git a/MANIFEST.in b/MANIFEST.in
index 8b15060..51e5afe 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -2,7 +2,7 @@ include README.md LICENSE
 include functional_tests.sh unittests.sh
 include test-requirements.txt
 include tox.ini
-recursive-include glusterfs *.py
+recursive-include gluster *.py
 recursive-include test *.py
 include test/test.conf
 graft doc
diff --git a/glusterfs/__init__.py b/gluster/__init__.py
index 900183b..4562ec8 100644
--- a/glusterfs/__init__.py
+++ b/gluster/__init__.py
@@ -12,6 +12,8 @@
 # implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from pkgutil import extend_path
+__path__ = extend_path(__path__, __name__)
 
 
 class PkgInfo(object):
diff --git a/glusterfs/api.py b/gluster/api.py
index 803a778..803a778 100755
--- a/glusterfs/api.py
+++ b/gluster/api.py
diff --git a/glusterfs/gfapi.py b/gluster/gfapi.py
index 42c4aef..3f7a068 100755
--- a/glusterfs/gfapi.py
+++ b/gluster/gfapi.py
@@ -17,7 +17,7 @@ import ctypes
 import os
 import stat
 import errno
-from glusterfs import api
+from gluster import api
 
 
 class File(object):
@@ -332,8 +332,8 @@ class Volume(object):
         Return list of entries in a given directory 'path'.
         "." and ".." are not included, and the list is not sorted.
         """
-        d = self.opendir(path)
         dir_list = []
+        d = self.opendir(path)
         while True:
             ent = d.next()
             if not isinstance(ent, api.Dirent):
diff --git a/setup.py b/setup.py
index 080a7f4..2b06ead 100644
--- a/setup.py
+++ b/setup.py
@@ -16,7 +16,7 @@
 
 from setuptools import setup
 
-from glusterfs import __canonical_version__ as version
+from gluster import __canonical_version__ as version
 
 
 name = 'gfapi'
@@ -30,7 +30,7 @@ setup(
     author='Red Hat, Inc.',
     author_email='gluster-users@gluster.org',
     url='http://www.gluster.org',
-    packages=['glusterfs', ],
+    packages=['gluster', ],
     test_suite='nose.collector',
     classifiers=[
         'Development Status :: 5 - Production/Stable'
diff --git a/test/functional/libgfapi-python-tests.py b/test/functional/libgfapi-python-tests.py
index 4dbdf2d..a49e626 100644
--- a/test/functional/libgfapi-python-tests.py
+++ b/test/functional/libgfapi-python-tests.py
@@ -18,7 +18,7 @@ import os
 import types
 import errno
 
-from glusterfs import gfapi
+from gluster import gfapi
 from test import get_test_config
 from ConfigParser import NoSectionError, NoOptionError
 
diff --git a/test/unit/gluster/test_gfapi.py b/test/unit/gluster/test_gfapi.py
index 8451b51..f03f61a 100644
--- a/test/unit/gluster/test_gfapi.py
+++ b/test/unit/gluster/test_gfapi.py
@@ -14,13 +14,13 @@
 # limitations under the License.
 
 import unittest
-import glusterfs
+import gluster
 import os
 import stat
 import errno
 
-from glusterfs import gfapi
-from glusterfs import api
+from gluster import gfapi
+from gluster import api
 from nose import SkipTest
 from mock import Mock, patch
 from contextlib import nested
@@ -57,11 +57,11 @@ class TestFile(unittest.TestCase):
         cls.fd = None
 
     def setUp(self):
-        self._saved_glfs_close = glusterfs.gfapi.api.glfs_close
-        glusterfs.gfapi.api.glfs_close = _mock_glfs_close
+        self._saved_glfs_close = gluster.gfapi.api.glfs_close
+        gluster.gfapi.api.glfs_close = _mock_glfs_close
 
     def tearDown(self):
-        glusterfs.gfapi.api.glfs_close = self._saved_glfs_close
+        gluster.gfapi.api.glfs_close = self._saved_glfs_close
 
     def test_fchmod_success(self):
         mock_glfs_fchmod = Mock()
@@ -82,7 +82,7 @@ class TestFile(unittest.TestCase):
         mock_glfs_fchown = Mock()
         mock_glfs_fchown.return_value = 0
 
-        with patch("glusterfs.gfapi.api.glfs_fchown", mock_glfs_fchown):
+        with patch("gluster.gfapi.api.glfs_fchown", mock_glfs_fchown):
             ret = self.fd.fchown(9, 11)
             self.assertEquals(ret, 0)
 
@@ -90,14 +90,14 @@ class TestFile(unittest.TestCase):
         mock_glfs_fchown = Mock()
         mock_glfs_fchown.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_fchown", mock_glfs_fchown):
+        with patch("gluster.gfapi.api.glfs_fchown", mock_glfs_fchown):
             self.assertRaises(OSError, self.fd.fchown, 9, 11)
 
     def test_dup(self):
         mock_glfs_dup = Mock()
         mock_glfs_dup.return_value = 2
 
-        with patch("glusterfs.gfapi.api.glfs_dup", mock_glfs_dup):
+        with patch("gluster.gfapi.api.glfs_dup", mock_glfs_dup):
             f = self.fd.dup()
             self.assertTrue(isinstance(f, gfapi.File))
             self.assertEqual(f.originalpath, "fakefile")
@@ -107,7 +107,7 @@ class TestFile(unittest.TestCase):
         mock_glfs_fdatasync = Mock()
         mock_glfs_fdatasync.return_value = 4
 
-        with patch("glusterfs.gfapi.api.glfs_fdatasync", mock_glfs_fdatasync):
+        with patch("gluster.gfapi.api.glfs_fdatasync", mock_glfs_fdatasync):
             ret = self.fd.fdatasync()
             self.assertEquals(ret, 4)
 
@@ -115,14 +115,14 @@ class TestFile(unittest.TestCase):
         mock_glfs_fdatasync = Mock()
         mock_glfs_fdatasync.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_fdatasync", mock_glfs_fdatasync):
+        with patch("gluster.gfapi.api.glfs_fdatasync", mock_glfs_fdatasync):
             self.assertRaises(OSError, self.fd.fdatasync)
 
     def test_fstat_success(self):
         mock_glfs_fstat = Mock()
         mock_glfs_fstat.return_value = 0
 
-        with patch("glusterfs.gfapi.api.glfs_fstat", mock_glfs_fstat):
+        with patch("gluster.gfapi.api.glfs_fstat", mock_glfs_fstat):
             s = self.fd.fstat()
             self.assertTrue(isinstance(s, api.Stat))
 
@@ -130,14 +130,14 @@ class TestFile(unittest.TestCase):
         mock_glfs_fstat = Mock()
         mock_glfs_fstat.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_fstat", mock_glfs_fstat):
+        with patch("gluster.gfapi.api.glfs_fstat", mock_glfs_fstat):
             self.assertRaises(OSError, self.fd.fstat)
 
     def test_fsync_success(self):
         mock_glfs_fsync = Mock()
         mock_glfs_fsync.return_value = 4
 
-        with patch("glusterfs.gfapi.api.glfs_fsync", mock_glfs_fsync):
+        with patch("gluster.gfapi.api.glfs_fsync", mock_glfs_fsync):
             ret = self.fd.fsync()
             self.assertEquals(ret, 4)
 
@@ -145,14 +145,14 @@ class TestFile(unittest.TestCase):
         mock_glfs_fsync = Mock()
         mock_glfs_fsync.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_fsync", mock_glfs_fsync):
+        with patch("gluster.gfapi.api.glfs_fsync", mock_glfs_fsync):
             self.assertRaises(OSError, self.fd.fsync)
 
     def test_lseek_success(self):
         mock_glfs_lseek = Mock()
         mock_glfs_lseek.return_value = 20
 
-        with patch("glusterfs.gfapi.api.glfs_lseek", mock_glfs_lseek):
+        with patch("gluster.gfapi.api.glfs_lseek", mock_glfs_lseek):
             o = self.fd.lseek(20, os.SEEK_SET)
             self.assertEqual(o, 20)
 
@@ -161,7 +161,7 @@ class TestFile(unittest.TestCase):
             rbuf.value = "hello"
             return 5
 
-        with patch("glusterfs.gfapi.api.glfs_read", _mock_glfs_read):
+        with patch("gluster.gfapi.api.glfs_read", _mock_glfs_read):
             b = self.fd.read(5)
             self.assertEqual(b.value, "hello")
 
@@ -169,14 +169,14 @@ class TestFile(unittest.TestCase):
         mock_glfs_read = Mock()
         mock_glfs_read.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_read", mock_glfs_read):
+        with patch("gluster.gfapi.api.glfs_read", mock_glfs_read):
             self.assertRaises(OSError, self.fd.read, 5)
 
     def test_read_fail_empty_buffer(self):
         mock_glfs_read = Mock()
         mock_glfs_read.return_value = 0
 
-        with patch("glusterfs.gfapi.api.glfs_read", mock_glfs_read):
+        with patch("gluster.gfapi.api.glfs_read", mock_glfs_read):
             b = self.fd.read(5)
             self.assertEqual(b, 0)
 
@@ -196,7 +196,7 @@ class TestFile(unittest.TestCase):
         mock_glfs_write = Mock()
         mock_glfs_write.return_value = 5
 
-        with patch("glusterfs.gfapi.api.glfs_write", mock_glfs_write):
+        with patch("gluster.gfapi.api.glfs_write", mock_glfs_write):
             ret = self.fd.write("hello")
             self.assertEqual(ret, 5)
 
@@ -204,7 +204,7 @@ class TestFile(unittest.TestCase):
         mock_glfs_write = Mock()
         mock_glfs_write.return_value = 3
 
-        with patch("glusterfs.gfapi.api.glfs_write", mock_glfs_write):
+        with patch("gluster.gfapi.api.glfs_write", mock_glfs_write):
             b = bytearray(3)
             ret = self.fd.write(b)
             self.assertEqual(ret, 3)
@@ -213,61 +213,61 @@ class TestFile(unittest.TestCase):
         mock_glfs_write = Mock()
         mock_glfs_write.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_write", mock_glfs_write):
+        with patch("gluster.gfapi.api.glfs_write", mock_glfs_write):
             self.assertRaises(OSError, self.fd.write, "hello")
 
     def test_fallocate_success(self):
-        raise SkipTest("need to solve issue with dependency on libgfapi.so")
+        raise SkipTest("need to solve issue with dependency on gluster.so")
         mock_glfs_fallocate = Mock()
         mock_glfs_fallocate.return_value = 0
 
-        with patch("glusterfs.gfapi.api.glfs_fallocate", mock_glfs_fallocate):
+        with patch("gluster.gfapi.api.glfs_fallocate", mock_glfs_fallocate):
             ret = self.fd.fallocate(0, 0, 1024)
             self.assertEqual(ret, 0)
 
     def test_fallocate_fail_exception(self):
-        raise SkipTest("need to solve issue with dependency on libgfapi.so")
+        raise SkipTest("need to solve issue with dependency on gluster.so")
         mock_glfs_fallocate = Mock()
         mock_glfs_fallocate.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_fallocate", mock_glfs_fallocate):
+        with patch("gluster.gfapi.api.glfs_fallocate", mock_glfs_fallocate):
             self.assertRaises(OSError, self.fd.fallocate, 0, 0, 1024)
 
     def test_discard_success(self):
-        raise SkipTest("need to solve issue with dependency on libgfapi.so")
+        raise SkipTest("need to solve issue with dependency on gluster.so")
         mock_glfs_discard = Mock()
         mock_glfs_discard.return_value = 0
 
-        with patch("glusterfs.gfapi.api.glfs_discard", mock_glfs_discard):
+        with patch("gluster.gfapi.api.glfs_discard", mock_glfs_discard):
             ret = self.fd.discard(1024, 1024)
             self.assertEqual(ret, 0)
 
     def test_discard_fail_exception(self):
-        raise SkipTest("need to solve issue with dependency on libgfapi.so")
+        raise SkipTest("need to solve issue with dependency on gluster.so")
         mock_glfs_discard = Mock()
         mock_glfs_discard.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_discard", mock_glfs_discard):
+        with patch("gluster.gfapi.api.glfs_discard", mock_glfs_discard):
             self.assertRaises(OSError, self.fd.discard, 1024, 1024)
 
 
 class TestDir(unittest.TestCase):
 
     def setUp(self):
-        self._saved_glfs_closedir = glusterfs.gfapi.api.glfs_closedir
-        glusterfs.gfapi.api.glfs_closedir = _mock_glfs_closedir
+        self._saved_glfs_closedir = gluster.gfapi.api.glfs_closedir
+        gluster.gfapi.api.glfs_closedir = _mock_glfs_closedir
 
     def tearDown(self):
-        glusterfs.gfapi.api.glfs_closedir = self._saved_glfs_closedir
+        gluster.gfapi.api.glfs_closedir = self._saved_glfs_closedir
 
     def test_next_success(self):
-        raise SkipTest("need to solve issue with dependency on libgfapi.so")
+        raise SkipTest("need to solve issue with dependency on gluster.so")
 
         def mock_glfs_readdir_r(fd, ent, cursor):
             cursor.contents = "bla"
             return 0
 
-        with patch("glusterfs.gfapi.api.glfs_readdir_r", mock_glfs_readdir_r):
+        with patch("gluster.gfapi.api.glfs_readdir_r", mock_glfs_readdir_r):
             fd = gfapi.Dir(2)
             ent = fd.next()
             self.assertTrue(isinstance(ent, gfapi.Dirent))
@@ -277,33 +277,33 @@ class TestVolume(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls._saved_glfs_new = glusterfs.gfapi.api.glfs_new
-        glusterfs.gfapi.api.glfs_new = _mock_glfs_new
+        cls._saved_glfs_new = gluster.gfapi.api.glfs_new
+        gluster.gfapi.api.glfs_new = _mock_glfs_new
 
         cls._saved_glfs_set_volfile_server = \
-            glusterfs.gfapi.api.glfs_set_volfile_server
-        glusterfs.gfapi.api.glfs_set_volfile_server = \
+            gluster.gfapi.api.glfs_set_volfile_server
+        gluster.gfapi.api.glfs_set_volfile_server = \
             _mock_glfs_set_volfile_server
 
-        cls._saved_glfs_fini = glusterfs.gfapi.api.glfs_fini
-        glusterfs.gfapi.api.glfs_fini = _mock_glfs_fini
+        cls._saved_glfs_fini = gluster.gfapi.api.glfs_fini
+        gluster.gfapi.api.glfs_fini = _mock_glfs_fini
 
-        cls._saved_glfs_close = glusterfs.gfapi.api.glfs_close
-        glusterfs.gfapi.api.glfs_close = _mock_glfs_close
+        cls._saved_glfs_close = gluster.gfapi.api.glfs_close
+        gluster.gfapi.api.glfs_close = _mock_glfs_close
 
-        cls._saved_glfs_closedir = glusterfs.gfapi.api.glfs_closedir
-        glusterfs.gfapi.api.glfs_closedir = _mock_glfs_closedir
+        cls._saved_glfs_closedir = gluster.gfapi.api.glfs_closedir
+        gluster.gfapi.api.glfs_closedir = _mock_glfs_closedir
         cls.vol = gfapi.Volume("mockhost", "test")
 
     @classmethod
     def tearDownClass(cls):
         cls.vol = None
-        glusterfs.gfapi.api.glfs_new = cls._saved_glfs_new
-        glusterfs.gfapi.api.glfs_set_volfile_server = \
+        gluster.gfapi.api.glfs_new = cls._saved_glfs_new
+        gluster.gfapi.api.glfs_set_volfile_server = \
             cls._saved_glfs_set_volfile_server
-        glusterfs.gfapi.api.glfs_fini = cls._saved_glfs_fini
-        glusterfs.gfapi.api.glfs_close = cls._saved_glfs_close
-        glusterfs.gfapi.api.glfs_closedir = cls._saved_glfs_closedir
+        gluster.gfapi.api.glfs_fini = cls._saved_glfs_fini
+        gluster.gfapi.api.glfs_close = cls._saved_glfs_close
+        gluster.gfapi.api.glfs_closedir = cls._saved_glfs_closedir
 
     def test_chmod_success(self):
         mock_glfs_chmod = Mock()
@@ -324,7 +324,7 @@ class TestVolume(unittest.TestCase):
         mock_glfs_chown = Mock()
         mock_glfs_chown.return_value = 0
 
-        with patch("glusterfs.gfapi.api.glfs_chown", mock_glfs_chown):
+        with patch("gluster.gfapi.api.glfs_chown", mock_glfs_chown):
             ret = self.vol.chown("file.txt", 9, 11)
             self.assertEquals(ret, 0)
 
@@ -332,14 +332,14 @@ class TestVolume(unittest.TestCase):
         mock_glfs_chown = Mock()
         mock_glfs_chown.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_chown", mock_glfs_chown):
+        with patch("gluster.gfapi.api.glfs_chown", mock_glfs_chown):
             self.assertRaises(OSError, self.vol.chown, "file.txt", 9, 11)
 
     def test_creat_success(self):
         mock_glfs_creat = Mock()
         mock_glfs_creat.return_value = 2
 
-        with patch("glusterfs.api.client.glfs_creat", mock_glfs_creat):
+        with patch("gluster.api.client.glfs_creat", mock_glfs_creat):
             with self.vol.open("file.txt", os.O_CREAT, 0644) as fd:
                 self.assertTrue(isinstance(fd, gfapi.File))
                 self.assertEqual(mock_glfs_creat.call_count, 1)
@@ -351,7 +351,7 @@ class TestVolume(unittest.TestCase):
         mock_glfs_stat = Mock()
         mock_glfs_stat.return_value = 0
 
-        with patch("glusterfs.gfapi.api.glfs_stat", mock_glfs_stat):
+        with patch("gluster.gfapi.api.glfs_stat", mock_glfs_stat):
             ret = self.vol.exists("file.txt")
             self.assertTrue(ret)
 
@@ -359,7 +359,7 @@ class TestVolume(unittest.TestCase):
         mock_glfs_stat = Mock()
         mock_glfs_stat.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_stat", mock_glfs_stat):
+        with patch("gluster.gfapi.api.glfs_stat", mock_glfs_stat):
             ret = self.vol.exists("file.txt")
             self.assertFalse(ret)
 
@@ -369,7 +369,7 @@ class TestVolume(unittest.TestCase):
         s.st_mode = stat.S_IFDIR
         mock_glfs_stat.return_value = s
 
-        with patch("glusterfs.gfapi.Volume.stat", mock_glfs_stat):
+        with patch("gluster.gfapi.Volume.stat", mock_glfs_stat):
             ret = self.vol.isdir("dir")
             self.assertTrue(ret)
 
@@ -379,7 +379,7 @@ class TestVolume(unittest.TestCase):
         s.st_mode = stat.S_IFREG
         mock_glfs_stat.return_value = s
 
-        with patch("glusterfs.gfapi.Volume.stat", mock_glfs_stat):
+        with patch("gluster.gfapi.Volume.stat", mock_glfs_stat):
             ret = self.vol.isdir("file")
             self.assertFalse(ret)
 
@@ -387,7 +387,7 @@ class TestVolume(unittest.TestCase):
         mock_glfs_stat = Mock()
         mock_glfs_stat.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_stat", mock_glfs_stat):
+        with patch("gluster.gfapi.api.glfs_stat", mock_glfs_stat):
             ret = self.vol.isdir("dirdoesnotexist")
             self.assertFalse(ret)
 
@@ -397,7 +397,7 @@ class TestVolume(unittest.TestCase):
         s.st_mode = stat.S_IFREG
         mock_glfs_stat.return_value = s
 
-        with patch("glusterfs.gfapi.Volume.stat", mock_glfs_stat):
+        with patch("gluster.gfapi.Volume.stat", mock_glfs_stat):
             ret = self.vol.isfile("file")
             self.assertTrue(ret)
 
@@ -407,7 +407,7 @@ class TestVolume(unittest.TestCase):
         s.st_mode = stat.S_IFDIR
         mock_glfs_stat.return_value = s
 
-        with patch("glusterfs.gfapi.Volume.stat", mock_glfs_stat):
+        with patch("gluster.gfapi.Volume.stat", mock_glfs_stat):
             ret = self.vol.isfile("dir")
             self.assertFalse(ret)
 
@@ -415,7 +415,7 @@ class TestVolume(unittest.TestCase):
         mock_glfs_stat = Mock()
         mock_glfs_stat.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_stat", mock_glfs_stat):
+        with patch("gluster.gfapi.api.glfs_stat", mock_glfs_stat):
             ret = self.vol.isfile("filedoesnotexist")
             self.assertFalse(ret)
 
@@ -425,7 +425,7 @@ class TestVolume(unittest.TestCase):
         s.st_mode = stat.S_IFLNK
         mock_glfs_lstat.return_value = s
 
-        with patch("glusterfs.gfapi.Volume.lstat", mock_glfs_lstat):
+        with patch("gluster.gfapi.Volume.lstat", mock_glfs_lstat):
             ret = self.vol.islink("solnk")
             self.assertTrue(ret)
 
@@ -435,7 +435,7 @@ class TestVolume(unittest.TestCase):
         s.st_mode = stat.S_IFREG
         mock_glfs_lstat.return_value = s
 
-        with patch("glusterfs.gfapi.Volume.lstat", mock_glfs_lstat):
+        with patch("gluster.gfapi.Volume.lstat", mock_glfs_lstat):
             ret = self.vol.islink("file")
             self.assertFalse(ret)
 
@@ -443,7 +443,7 @@ class TestVolume(unittest.TestCase):
         mock_glfs_lstat = Mock()
         mock_glfs_lstat.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_lstat", mock_glfs_lstat):
+        with patch("gluster.gfapi.api.glfs_lstat", mock_glfs_lstat):
             ret = self.vol.islink("linkdoesnotexist")
             self.assertFalse(ret)
 
@@ -452,7 +452,7 @@ class TestVolume(unittest.TestCase):
             buf.value = "fake_xattr"
             return 10
 
-        with patch("glusterfs.gfapi.api.glfs_getxattr", mock_glfs_getxattr):
+        with patch("gluster.gfapi.api.glfs_getxattr", mock_glfs_getxattr):
             buf = self.vol.getxattr("file.txt", "key1", 32)
             self.assertEquals("fake_xattr", buf)
 
@@ -460,7 +460,7 @@ class TestVolume(unittest.TestCase):
         mock_glfs_getxattr = Mock()
         mock_glfs_getxattr.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_getxattr", mock_glfs_getxattr):
+        with patch("gluster.gfapi.api.glfs_getxattr", mock_glfs_getxattr):
             self.assertRaises(IOError, self.vol.getxattr, "file.txt",
                               "key1", 32)
 
@@ -480,9 +480,9 @@ class TestVolume(unittest.TestCase):
         mock_Dir_next = Mock()
         mock_Dir_next.side_effect = [dirent1, dirent2, dirent3, None]
 
-        with nested(patch("glusterfs.gfapi.api.glfs_opendir",
+        with nested(patch("gluster.gfapi.api.glfs_opendir",
                           mock_glfs_opendir),
-                    patch("glusterfs.gfapi.Dir.next", mock_Dir_next)):
+                    patch("gluster.gfapi.Dir.next", mock_Dir_next)):
             d = self.vol.listdir("testdir")
             self.assertEqual(len(d), 2)
             self.assertEqual(d[0], 'mockfile')
@@ -491,7 +491,7 @@ class TestVolume(unittest.TestCase):
         mock_glfs_opendir = Mock()
         mock_glfs_opendir.return_value = None
 
-        with patch("glusterfs.gfapi.api.glfs_opendir", mock_glfs_opendir):
+        with patch("gluster.gfapi.api.glfs_opendir", mock_glfs_opendir):
             self.assertRaises(OSError, self.vol.listdir, "test.txt")
 
     def test_listxattr_success(self):
@@ -499,7 +499,7 @@ class TestVolume(unittest.TestCase):
             buf.raw = "key1\0key2\0"
             return 10
 
-        with patch("glusterfs.gfapi.api.glfs_listxattr", mock_glfs_listxattr):
+        with patch("gluster.gfapi.api.glfs_listxattr", mock_glfs_listxattr):
             xattrs = self.vol.listxattr("file.txt")
             self.assertTrue("key1" in xattrs)
             self.assertTrue("key2" in xattrs)
@@ -508,14 +508,14 @@ class TestVolume(unittest.TestCase):
         mock_glfs_listxattr = Mock()
         mock_glfs_listxattr.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_listxattr", mock_glfs_listxattr):
+        with patch("gluster.gfapi.api.glfs_listxattr", mock_glfs_listxattr):
             self.assertRaises(IOError, self.vol.listxattr, "file.txt")
 
     def test_lstat_success(self):
         mock_glfs_lstat = Mock()
         mock_glfs_lstat.return_value = 0
 
-        with patch("glusterfs.gfapi.api.glfs_lstat", mock_glfs_lstat):
+        with patch("gluster.gfapi.api.glfs_lstat", mock_glfs_lstat):
             s = self.vol.lstat("file.txt")
             self.assertTrue(isinstance(s, api.Stat))
 
@@ -523,14 +523,14 @@ class TestVolume(unittest.TestCase):
         mock_glfs_lstat = Mock()
         mock_glfs_lstat.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_lstat", mock_glfs_lstat):
+        with patch("gluster.gfapi.api.glfs_lstat", mock_glfs_lstat):
             self.assertRaises(OSError, self.vol.lstat, "file.txt")
 
     def test_stat_success(self):
         mock_glfs_stat = Mock()
         mock_glfs_stat.return_value = 0
 
-        with patch("glusterfs.gfapi.api.glfs_stat", mock_glfs_stat):
+        with patch("gluster.gfapi.api.glfs_stat", mock_glfs_stat):
             s = self.vol.stat("file.txt")
             self.assertTrue(isinstance(s, api.Stat))
 
@@ -538,14 +538,14 @@ class TestVolume(unittest.TestCase):
         mock_glfs_stat = Mock()
         mock_glfs_stat.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_stat", mock_glfs_stat):
+        with patch("gluster.gfapi.api.glfs_stat", mock_glfs_stat):
             self.assertRaises(OSError, self.vol.stat, "file.txt")
 
     def test_statvfs_success(self):
         mock_glfs_statvfs = Mock()
         mock_glfs_statvfs.return_value = 0
 
-        with patch("glusterfs.gfapi.api.glfs_statvfs", mock_glfs_statvfs):
+        with patch("gluster.gfapi.api.glfs_statvfs", mock_glfs_statvfs):
             s = self.vol.statvfs("/")
             self.assertTrue(isinstance(s, api.Statvfs))
 
@@ -553,7 +553,7 @@ class TestVolume(unittest.TestCase):
         mock_glfs_statvfs = Mock()
         mock_glfs_statvfs.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_statvfs", mock_glfs_statvfs):
+        with patch("gluster.gfapi.api.glfs_statvfs", mock_glfs_statvfs):
             self.assertRaises(OSError, self.vol.statvfs, "/")
 
     def test_makedirs_success(self):
@@ -563,8 +563,8 @@ class TestVolume(unittest.TestCase):
         mock_exists = Mock()
         mock_exists.side_effect = (False, True, False)
 
-        with nested(patch("glusterfs.gfapi.api.glfs_mkdir", mock_glfs_mkdir),
-                    patch("glusterfs.gfapi.Volume.exists", mock_exists)):
+        with nested(patch("gluster.gfapi.api.glfs_mkdir", mock_glfs_mkdir),
+                    patch("gluster.gfapi.Volume.exists", mock_exists)):
             self.vol.makedirs("dir1/", 0775)
             self.assertEqual(mock_glfs_mkdir.call_count, 1)
             mock_glfs_mkdir.assert_any_call(self.vol.fs, "dir1/", 0775)
@@ -577,8 +577,8 @@ class TestVolume(unittest.TestCase):
         mock_exists = Mock()
         mock_exists.side_effect = [False, True, False]
 
-        with nested(patch("glusterfs.gfapi.api.glfs_mkdir", mock_glfs_mkdir),
-                    patch("glusterfs.gfapi.Volume.exists", mock_exists)):
+        with nested(patch("gluster.gfapi.api.glfs_mkdir", mock_glfs_mkdir),
+                    patch("gluster.gfapi.Volume.exists", mock_exists)):
             self.vol.makedirs("./dir1/dir2", 0775)
             self.assertEqual(mock_glfs_mkdir.call_count, 2)
             mock_glfs_mkdir.assert_any_call(self.vol.fs, "./dir1", 0775)
@@ -592,15 +592,15 @@ class TestVolume(unittest.TestCase):
         mock_exists = Mock()
         mock_exists.return_value = False
 
-        with nested(patch("glusterfs.gfapi.api.glfs_mkdir", mock_glfs_mkdir),
-                    patch("glusterfs.gfapi.Volume.exists", mock_exists)):
+        with nested(patch("gluster.gfapi.api.glfs_mkdir", mock_glfs_mkdir),
+                    patch("gluster.gfapi.Volume.exists", mock_exists)):
             self.assertRaises(OSError, self.vol.makedirs, "dir1/dir2", 0775)
 
     def test_mkdir_success(self):
         mock_glfs_mkdir = Mock()
         mock_glfs_mkdir.return_value = 0
 
-        with patch("glusterfs.gfapi.api.glfs_mkdir", mock_glfs_mkdir):
+        with patch("gluster.gfapi.api.glfs_mkdir", mock_glfs_mkdir):
             ret = self.vol.mkdir("testdir", 0775)
             self.assertEquals(ret, 0)
 
@@ -608,14 +608,14 @@ class TestVolume(unittest.TestCase):
         mock_glfs_mkdir = Mock()
         mock_glfs_mkdir.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_mkdir", mock_glfs_mkdir):
+        with patch("gluster.gfapi.api.glfs_mkdir", mock_glfs_mkdir):
             self.assertRaises(OSError, self.vol.mkdir, "testdir", 0775)
 
     def test_open_with_statement_success(self):
         mock_glfs_open = Mock()
         mock_glfs_open.return_value = 2
 
-        with patch("glusterfs.api.client.glfs_open", mock_glfs_open):
+        with patch("gluster.api.client.glfs_open", mock_glfs_open):
             with self.vol.open("file.txt", os.O_WRONLY) as fd:
                 self.assertTrue(isinstance(fd, gfapi.File))
                 self.assertEqual(mock_glfs_open.call_count, 1)
@@ -630,14 +630,14 @@ class TestVolume(unittest.TestCase):
             with self.vol.open("file.txt", os.O_WRONLY) as fd:
                 self.assertEqual(fd, None)
 
-        with patch("glusterfs.api.client.glfs_open", mock_glfs_open):
+        with patch("gluster.api.client.glfs_open", mock_glfs_open):
             self.assertRaises(OSError, assert_open)
 
     def test_open_direct_success(self):
         mock_glfs_open = Mock()
         mock_glfs_open.return_value = 2
 
-        with patch("glusterfs.api.client.glfs_open", mock_glfs_open):
+        with patch("gluster.api.client.glfs_open", mock_glfs_open):
             fd = self.vol.open("file.txt", os.O_WRONLY)
             self.assertTrue(isinstance(fd, gfapi.File))
             self.assertEqual(mock_glfs_open.call_count, 1)
@@ -647,14 +647,14 @@ class TestVolume(unittest.TestCase):
         mock_glfs_open = Mock()
         mock_glfs_open.return_value = None
 
-        with patch("glusterfs.api.client.glfs_open", mock_glfs_open):
+        with patch("gluster.api.client.glfs_open", mock_glfs_open):
             self.assertRaises(OSError, self.vol.open, "file.txt", os.O_RDONLY)
 
     def test_opendir_success(self):
         mock_glfs_opendir = Mock()
         mock_glfs_opendir.return_value = 2
 
-        with patch("glusterfs.gfapi.api.glfs_opendir", mock_glfs_opendir):
+        with patch("gluster.gfapi.api.glfs_opendir", mock_glfs_opendir):
             d = self.vol.opendir("testdir")
             self.assertTrue(isinstance(d, gfapi.Dir))
 
@@ -662,14 +662,14 @@ class TestVolume(unittest.TestCase):
         mock_glfs_opendir = Mock()
         mock_glfs_opendir.return_value = None
 
-        with patch("glusterfs.gfapi.api.glfs_opendir", mock_glfs_opendir):
+        with patch("gluster.gfapi.api.glfs_opendir", mock_glfs_opendir):
             self.assertRaises(OSError, self.vol.opendir, "testdir")
 
     def test_rename_success(self):
         mock_glfs_rename = Mock()
         mock_glfs_rename.return_value = 0
 
-        with patch("glusterfs.gfapi.api.glfs_rename", mock_glfs_rename):
+        with patch("gluster.gfapi.api.glfs_rename", mock_glfs_rename):
             ret = self.vol.rename("file.txt", "newfile.txt")
             self.assertEquals(ret, 0)
 
@@ -677,7 +677,7 @@ class TestVolume(unittest.TestCase):
         mock_glfs_rename = Mock()
         mock_glfs_rename.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_rename", mock_glfs_rename):
+        with patch("gluster.gfapi.api.glfs_rename", mock_glfs_rename):
             self.assertRaises(OSError, self.vol.rename,
                               "file.txt", "newfile.txt")
 
@@ -685,7 +685,7 @@ class TestVolume(unittest.TestCase):
         mock_glfs_rmdir = Mock()
         mock_glfs_rmdir.return_value = 0
 
-        with patch("glusterfs.gfapi.api.glfs_rmdir", mock_glfs_rmdir):
+        with patch("gluster.gfapi.api.glfs_rmdir", mock_glfs_rmdir):
             ret = self.vol.rmdir("testdir")
             self.assertEquals(ret, 0)
 
@@ -693,14 +693,14 @@ class TestVolume(unittest.TestCase):
         mock_glfs_rmdir = Mock()
         mock_glfs_rmdir.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_rmdir", mock_glfs_rmdir):
+        with patch("gluster.gfapi.api.glfs_rmdir", mock_glfs_rmdir):
             self.assertRaises(OSError, self.vol.rmdir, "testdir")
 
     def test_unlink_success(self):
         mock_glfs_unlink = Mock()
         mock_glfs_unlink.return_value = 0
 
-        with patch("glusterfs.gfapi.api.glfs_unlink", mock_glfs_unlink):
+        with patch("gluster.gfapi.api.glfs_unlink", mock_glfs_unlink):
             ret = self.vol.unlink("file.txt")
             self.assertEquals(ret, 0)
 
@@ -708,14 +708,14 @@ class TestVolume(unittest.TestCase):
         mock_glfs_unlink = Mock()
         mock_glfs_unlink.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_unlink", mock_glfs_unlink):
+        with patch("gluster.gfapi.api.glfs_unlink", mock_glfs_unlink):
             self.assertRaises(OSError, self.vol.unlink, "file.txt")
 
     def test_removexattr_success(self):
         mock_glfs_removexattr = Mock()
         mock_glfs_removexattr.return_value = 0
 
-        with patch("glusterfs.gfapi.api.glfs_removexattr",
+        with patch("gluster.gfapi.api.glfs_removexattr",
                    mock_glfs_removexattr):
             ret = self.vol.removexattr("file.txt", "key1")
             self.assertEquals(ret, 0)
@@ -724,7 +724,7 @@ class TestVolume(unittest.TestCase):
         mock_glfs_removexattr = Mock()
         mock_glfs_removexattr.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_removexattr",
+        with patch("gluster.gfapi.api.glfs_removexattr",
                    mock_glfs_removexattr):
             self.assertRaises(IOError, self.vol.removexattr, "file.txt",
                               "key1")
@@ -747,11 +747,11 @@ class TestVolume(unittest.TestCase):
         mock_islink = Mock()
         mock_islink.return_value = False
 
-        with nested(patch("glusterfs.gfapi.Volume.listdir", mock_listdir),
-                    patch("glusterfs.gfapi.Volume.isdir", mock_isdir),
-                    patch("glusterfs.gfapi.Volume.islink", mock_islink),
-                    patch("glusterfs.gfapi.Volume.unlink", mock_unlink),
-                    patch("glusterfs.gfapi.Volume.rmdir", mock_rmdir)):
+        with nested(patch("gluster.gfapi.Volume.listdir", mock_listdir),
+                    patch("gluster.gfapi.Volume.isdir", mock_isdir),
+                    patch("gluster.gfapi.Volume.islink", mock_islink),
+                    patch("gluster.gfapi.Volume.unlink", mock_unlink),
+                    patch("gluster.gfapi.Volume.rmdir", mock_rmdir)):
             self.vol.rmtree("dir1")
             mock_rmdir.assert_any_call("dir1/dir2")
             mock_unlink.assert_called_once_with("dir1/file")
@@ -764,15 +764,15 @@ class TestVolume(unittest.TestCase):
         mock_islink = Mock()
         mock_islink.return_value = False
 
-        with nested(patch("glusterfs.gfapi.Volume.listdir", mock_listdir),
-                    patch("glusterfs.gfapi.Volume.islink", mock_islink)):
+        with nested(patch("gluster.gfapi.Volume.listdir", mock_listdir),
+                    patch("gluster.gfapi.Volume.islink", mock_islink)):
             self.assertRaises(OSError, self.vol.rmtree, "dir1")
 
     def test_rmtree_islink_exception(self):
         mock_islink = Mock()
         mock_islink.return_value = True
 
-        with patch("glusterfs.gfapi.Volume.islink", mock_islink):
+        with patch("gluster.gfapi.Volume.islink", mock_islink):
             self.assertRaises(OSError, self.vol.rmtree, "dir1")
 
     def test_rmtree_ignore_unlink_rmdir_exception(self):
@@ -793,11 +793,11 @@ class TestVolume(unittest.TestCase):
         mock_islink = Mock()
         mock_islink.return_value = False
 
-        with nested(patch("glusterfs.gfapi.Volume.listdir", mock_listdir),
-                    patch("glusterfs.gfapi.Volume.isdir", mock_isdir),
-                    patch("glusterfs.gfapi.Volume.islink", mock_islink),
-                    patch("glusterfs.gfapi.Volume.unlink", mock_unlink),
-                    patch("glusterfs.gfapi.Volume.rmdir", mock_rmdir)):
+        with nested(patch("gluster.gfapi.Volume.listdir", mock_listdir),
+                    patch("gluster.gfapi.Volume.isdir", mock_isdir),
+                    patch("gluster.gfapi.Volume.islink", mock_islink),
+                    patch("gluster.gfapi.Volume.unlink", mock_unlink),
+                    patch("gluster.gfapi.Volume.rmdir", mock_rmdir)):
             self.vol.rmtree("dir1", True)
             mock_rmdir.assert_any_call("dir1/dir2")
             mock_unlink.assert_called_once_with("dir1/file")
@@ -837,7 +837,7 @@ class TestVolume(unittest.TestCase):
         mock_glfs_setxattr = Mock()
         mock_glfs_setxattr.return_value = 0
 
-        with patch("glusterfs.gfapi.api.glfs_setxattr", mock_glfs_setxattr):
+        with patch("gluster.gfapi.api.glfs_setxattr", mock_glfs_setxattr):
             ret = self.vol.setxattr("file.txt", "key1", "hello", 5)
             self.assertEquals(ret, 0)
 
@@ -845,7 +845,7 @@ class TestVolume(unittest.TestCase):
         mock_glfs_setxattr = Mock()
         mock_glfs_setxattr.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_setxattr", mock_glfs_setxattr):
+        with patch("gluster.gfapi.api.glfs_setxattr", mock_glfs_setxattr):
             self.assertRaises(IOError, self.vol.setxattr, "file.txt",
                               "key1", "hello", 5)
 
@@ -853,7 +853,7 @@ class TestVolume(unittest.TestCase):
         mock_glfs_symlink = Mock()
         mock_glfs_symlink.return_value = 0
 
-        with patch("glusterfs.gfapi.api.glfs_symlink", mock_glfs_symlink):
+        with patch("gluster.gfapi.api.glfs_symlink", mock_glfs_symlink):
             ret = self.vol.symlink("file.txt", "filelink")
             self.assertEquals(ret, 0)
 
@@ -861,7 +861,7 @@ class TestVolume(unittest.TestCase):
         mock_glfs_symlink = Mock()
         mock_glfs_symlink.return_value = -1
 
-        with patch("glusterfs.gfapi.api.glfs_symlink", mock_glfs_symlink):
+        with patch("gluster.gfapi.api.glfs_symlink", mock_glfs_symlink):
             self.assertRaises(OSError, self.vol.symlink, "file.txt",
                               "filelink")
 
@@ -874,8 +874,8 @@ class TestVolume(unittest.TestCase):
         mock_isdir = Mock()
         mock_isdir.side_effect = [True, False]
 
-        with nested(patch("glusterfs.gfapi.Volume.listdir", mock_listdir),
-                    patch("glusterfs.gfapi.Volume.isdir", mock_isdir)):
+        with nested(patch("gluster.gfapi.Volume.listdir", mock_listdir),
+                    patch("gluster.gfapi.Volume.isdir", mock_isdir)):
             for (path, dirs, files) in self.vol.walk("dir1"):
                 self.assertEqual(dirs, ['dir2'])
                 self.assertEqual(files, ['file'])
@@ -888,7 +888,7 @@ class TestVolume(unittest.TestCase):
         def mock_onerror(err):
             self.assertTrue(isinstance(err, OSError))
 
-        with patch("glusterfs.gfapi.Volume.listdir", mock_listdir):
+        with patch("gluster.gfapi.Volume.listdir", mock_listdir):
             for (path, dirs, files) in self.vol.walk("dir1",
                                                      onerror=mock_onerror):
                 pass
diff --git a/tox.ini b/tox.ini
index 78e2818..fa5663d 100644
--- a/tox.ini
+++ b/tox.ini
@@ -14,7 +14,7 @@ deps =
   --download-cache={homedir}/.pipcache
   -r{toxinidir}/test-requirements.txt
 changedir = {toxinidir}/test/unit
-commands = nosetests -v --exe --with-xunit --with-coverage --cover-package glusterfs --cover-erase --cover-xml --cover-html --cover-branches --with-html-output {posargs}
+commands = nosetests -v --exe --with-xunit --with-coverage --cover-package gluster --cover-erase --cover-xml --cover-html --cover-branches --with-html-output {posargs}
 
 [tox:jenkins]
 downloadcache = ~/cache/pip
@@ -29,8 +29,8 @@ deps =
   -r{toxinidir}/test-requirements.txt
 changedir = {toxinidir}
 commands =
-  flake8
-  flake8 glusterfs test
+  flake8 setup.py
+  flake8 gluster test
 
 [testenv:cover]
 setenv = NOSE_WITH_COVERAGE=1
diff --git a/unittests.sh b/unittests.sh
index 9da3643..e5a4c8e 100755
--- a/unittests.sh
+++ b/unittests.sh
@@ -17,7 +17,7 @@
 
 
 cd $(dirname $0)/test/unit
-nosetests -v --exe --with-coverage --cover-package glusterfs --cover-erase --cover-html --cover-branches $@
+nosetests -v --exe --with-coverage --cover-package gluster --cover-erase --cover-html --cover-branches $@
 
 saved_status=$?
 rm -f .coverage