Merge lp:~diegosarmentero/ubuntuone-client/search-filter into lp:ubuntuone-client

[Diego Sarmentero]

- Search and filter for u1 files (LP: #1056189, #1056197).

This will be used from control panel, instead of having the data of the files inside u1 duplicated there, and this will be fix the problems to keep that data up to date, and check if the files are already in the server (as the two bug reports describe).

[lp:~diegosarmentero/ubuntuone-client/search-filter]

1348. By Diego Sarmentero on 2012-10-22

adding missing files

1349. By Diego Sarmentero on 2012-10-22

delete unnecesary fake

1350. By Diego Sarmentero on 2012-10-23

removing line for testing purposes

1351. By Diego Sarmentero on 2012-10-23

docstring fixed

[Roberto Alsina (ralsina)]

review: Approve

[lp:~diegosarmentero/ubuntuone-client/search-filter]

1352. By Diego Sarmentero on 2012-10-23

fix string

[Mike McCracken (mikemc)]

I don't really agree with replacing spaces with '.+'.

The old share_links_search does a substring search in just the
basename, while this matches the whole path, which I think is a good
idea.

However, I was expecting this to also be substring search, but you are
replacing spaces in the search string with '.+', which means the
behavior is a little unexpected wrt. spaces in the search text.

Here's a test to be added to test_fsm.py in FSMSearchTestCase that shows what I mean:

    def test_get_paths_by_pattern_with_spaces(self):
        """Test that spaces in a pattern are handled as expected."""
        mdid = 'id'
        path = '/my/path/to/a/file/deep/in/the/woods/called/a file'
        mdobj = {'server_hash': 'asdqwe123'}
        mdid2 = 'id2'
        path2 = '/my/path/to/anythingyouwant-to-defile'
        mdobj2 = {'server_hash': 'asdqwe456'}
        self.fsm._idx_path = {path: mdid, path2: mdid2}
        self.fsm.fs = {mdid: mdobj, mdid2: mdobj2}
        expected = [path]
        # expectations
        paths = "(%s|%s)" % ('/my/path/', '/home/')
        pattern = paths + ".*/.*%s.*$"
        keywords = '.+'.join(re.escape('a file').split('\\ '))
        print "keywords:", keywords
        search = pattern % keywords
        result = self.fsm.get_paths_by_pattern(search)
        print "result from get_paths_by_pattern:", result
        self.assertEqual(result, expected)

I would expect "a file" to not match "anythingyouwant-to-defile". It
matches both:

Here's what that test prints:
keywords: a.+file
searching through /my/path/to/a/file/deep/in/the/woods/called/a file id
match with p= /my/path/to/a/file/deep/in/the/woods/called/a file
searching through /my/path/to/anythingyouwant-to-defile id2
match with p= /my/path/to/anythingyouwant-to-defile
result from get_paths_by_pattern: ['/my/path/to/a/file/deep/in/the/woods/called/a file', '/my/path/to/anythingyouwant-to-defile']
Traceback (most recent call last):
  File "/Users/mmccrack/Documents/Canonical/Source/test-improve-buildout/scripts/devsetup/parts/ubuntuone-client/tests/syncdaemon/test_fsm.py", line 4361, in test_get_paths_by_pattern_with_spaces
    self.assertEqual(result, expected)
  File "/Users/mmccrack/Documents/Canonical/Source/test-improve-buildout/scripts/devsetup/eggs/Twisted-11.1.0-py2.7-macosx-10.7-x86_64.egg/twisted/trial/unittest.py", line 270, in assertEqual
    % (msg, pformat(first), pformat(second)))
twisted.trial.unittest.FailTest: not equal:
a = ['/my/path/to/a/file/deep/in/the/woods/called/a file',
 '/my/path/to/anythingyouwant-to-defile']
b = ['/my/path/to/a/file/deep/in/the/woods/called/a file']

review: Needs Fixing

[Mike McCracken (mikemc)]

Hmm, my example test is kind of dumb, since it's pointing out something in the test, not in the method it's testing… I should probably have put it in test_files_search.py, but you get the point…

[Mike McCracken (mikemc)]

I've changed my mind.

For reference: I'm OK with matching fuzzy things, and I was mostly concerned with the order in which they appear, I wanted to be sure the least-surprising match showed up first.

However the only example I found where that might happen was if we have a search pattern with a space, and the files list has a pattern with no space that matches that pattern because of our fuzzy changes. In this case, though, when we sort the matching paths at the end of get_paths_by_pattern, the paths with spaces are sorted first anyway.

So even though using multiple regexes to control the order of matches is only a little slower in real terms, I can't think of a case in which it's necessary.

review: Approve

=== modified file 'contrib/testing/testcase.py'
--- contrib/testing/testcase.py	2012-10-02 19:52:03 +0000
+++ contrib/testing/testcase.py	2012-10-23 17:07:21 +0000
@@ -50,6 +50,7 @@
     config,
     action_queue,
     event_queue,
+    files_search,
     filesystem_manager as fs_manager,
     interaction_interfaces,
     interfaces,
@@ -254,6 +255,7 @@
 
         self.eventlog_listener = None
         self.status_listener = FakeStatusListener()
+        self.search = files_search.SearchFiles(self.fs)
 
     def _connect_aq(self, _):
         """Connect the fake action queue."""

=== modified file 'tests/platform/ipc/test_external_interface.py'
--- tests/platform/ipc/test_external_interface.py	2012-08-10 12:49:46 +0000
+++ tests/platform/ipc/test_external_interface.py	2012-10-23 17:07:21 +0000
@@ -275,6 +275,15 @@
             in_signature='s', out_signature='a{ss}')
 
     @defer.inlineCallbacks
+    def test_search_files(self):
+        """Test get_metadata."""
+        result = ['path']
+        yield self.assert_method_called(self.service.file_system,
+                                        'search_files', result, 'file')
+        self.assert_remote_method('search_files',
+            in_signature='s', out_signature='as')
+
+    @defer.inlineCallbacks
     def test_get_metadata_by_node(self):
         """Test get_metadata_by_node."""
         result = {'node_id': 'test'}

=== modified file 'tests/platform/test_tools.py'
--- tests/platform/test_tools.py	2012-08-10 12:49:46 +0000
+++ tests/platform/test_tools.py	2012-10-23 17:07:21 +0000
@@ -203,6 +203,26 @@
         self.assertEqual('node_id', result['node_id'])
 
     @defer.inlineCallbacks
+    def test_search_files(self):
+        """Check that get_metadata works as expected."""
+        mdid = 'id'
+        path = os.path.join(self.root_dir, u'path/to/file_test')
+        mdobj = {'server_hash': 'asdqwe123'}
+        mdid2 = 'id2'
+        path2 = os.path.join(self.root_dir, u'path/to/my_files')
+        mdobj2 = {'server_hash': 'asdqwe456'}
+        mdid3 = 'id3'
+        path3 = u'/home2/to/my_files'
+        mdobj3 = {'server_hash': 'asdqwe456'}
+        self.fs._idx_path = {path: mdid, path2: mdid2, path3: mdid3}
+        self.fs.fs = {mdid: mdobj, mdid2: mdobj2, mdid3: mdobj3}
+
+        result = yield self.tool.search_files('file')
+        expected = [os.path.join(self.root_dir, 'path/to/file_test'),
+            os.path.join(self.root_dir, 'path/to/my_files')]
+        self.assertEqual(result, expected)
+
+    @defer.inlineCallbacks
     def test_quit_when_running(self):
         """Test the quit method when the daemon is running."""
         self.patch(tools, 'is_already_running',

=== added file 'tests/syncdaemon/test_files_search.py'
--- tests/syncdaemon/test_files_search.py	1970-01-01 00:00:00 +0000
+++ tests/syncdaemon/test_files_search.py	2012-10-23 17:07:21 +0000
@@ -0,0 +1,87 @@
+# -*- coding: utf-8 *-*
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+"""Test the files search module."""
+
+from twisted.internet import defer
+from twisted.trial.unittest import TestCase
+
+from ubuntuone.syncdaemon import files_search
+
+
+class FakeVolumeManager(object):
+    """Fake VolumeManager."""
+
+    def get_folders(self):
+        """Return the u1 folders."""
+        return ('/home/u1/', '/home/.local/udfs/', '/home/.local/shared',
+            '/home/.local/shares')
+
+
+class FakeFilesystemManager(object):
+    """Fake FilesystemManager."""
+
+    def __init__(self):
+        self.pattern = ''
+        self.vm = FakeVolumeManager()
+
+    def get_paths_by_pattern(self, pattern):
+        """Store the pattern received."""
+        self.pattern = pattern
+
+
+class FilesystemManagerTestCase(TestCase):
+    """Test the SyncMenu."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(FilesystemManagerTestCase, self).setUp()
+        self.fsm = FakeFilesystemManager()
+        self.search = files_search.SearchFiles(self.fsm)
+        root, udf_dir, shared_dir, _ = self.fsm.vm.get_folders()
+        paths = "(%s|%s|%s)" % (root, udf_dir, shared_dir)
+        self.basic_pattern = paths + ".*/.*%s.*$"
+
+    def test_simple_string(self):
+        """Check the pattern is the same string."""
+        pattern = 'filename'
+        self.search.search(pattern)
+        expected = self.basic_pattern % pattern
+        self.assertEqual(expected, self.fsm.pattern)
+
+    def test_escaped_string(self):
+        """Check the pattern is the same string."""
+        self.search.search('file_name')
+        expected = self.basic_pattern % 'file\\_name'
+        self.assertEqual(expected, self.fsm.pattern)
+
+    def test_string_with_space(self):
+        """Check the pattern is the same string."""
+        self.search.search('file name')
+        expected = self.basic_pattern % 'file.+name'
+        self.assertEqual(expected, self.fsm.pattern)

=== modified file 'tests/syncdaemon/test_fsm.py'
--- tests/syncdaemon/test_fsm.py	2012-08-08 13:21:13 +0000
+++ tests/syncdaemon/test_fsm.py	2012-10-23 17:07:21 +0000
@@ -32,6 +32,7 @@
 
 import errno
 import os
+import re
 import time
 
 from mocker import MockerTestCase, ANY
@@ -4299,3 +4300,109 @@
         self.mocker.result(path)
         self.mocker.replay()
         self.assertRaises(KeyError, self.fsm.dir_content, path)
+
+
+class FSMSearchTestCase(BaseTwistedTestCase):
+    """Base test case for FSM."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Setup the test."""
+        yield super(FSMSearchTestCase, self).setUp()
+        self.shares_dir = self.mktemp('shares')
+        self.root_dir = self.mktemp('root')
+        self.fsmdir = self.mktemp("fsmdir")
+        self.partials_dir = self.mktemp("partials")
+        self.tritcask_path = self.mktemp("tritcask")
+
+        self.db = Tritcask(self.tritcask_path)
+        self.addCleanup(self.db.shutdown)
+        self.fsm = FileSystemManager(self.fsmdir, self.partials_dir,
+                                     FakeVolumeManager(self.root_dir), self.db)
+
+    def test_get_paths_by_pattern(self):
+        """Check that we obtain the files that correspond to the filter."""
+        mdid = 'id'
+        path = '/my/path/to/file_test'
+        mdobj = {'server_hash': 'asdqwe123'}
+        mdid2 = 'id2'
+        path2 = '/my/path/to/my_photos'
+        mdobj2 = {'server_hash': 'asdqwe456'}
+        self.fsm._idx_path = {path: mdid, path2: mdid2}
+        self.fsm.fs = {mdid: mdobj, mdid2: mdobj2}
+        expected = ['/my/path/to/file_test']
+        # expectations
+        paths = "(%s|%s)" % ('/my/path/', '/home/')
+        pattern = paths + ".*/.*%s.*$"
+        keywords = '.+'.join(re.escape('file').split('\\ '))
+        search = pattern % keywords
+        result = self.fsm.get_paths_by_pattern(search)
+        self.assertEqual(result, expected)
+
+    def test_get_paths_by_pattern_valid_folders(self):
+        """Search for the pattern in the valid folders."""
+        mdid = 'id'
+        path = '/my/path/to/file_test'
+        mdobj = {'server_hash': 'asdqwe123'}
+        mdid2 = 'id2'
+        path2 = '/home/to/my_files'
+        mdobj2 = {'server_hash': 'asdqwe456'}
+        mdid3 = 'id3'
+        path3 = '/home2/to/my_files'
+        mdobj3 = {'server_hash': 'asdqwe456'}
+        self.fsm._idx_path = {path: mdid, path2: mdid2, path3: mdid3}
+        self.fsm.fs = {mdid: mdobj, mdid2: mdobj2, mdid3: mdobj3}
+        expected = ['/home/to/my_files', '/my/path/to/file_test']
+        # expectations
+        paths = "(%s|%s)" % ('/my/path/', '/home/')
+        pattern = paths + ".*/.*%s.*$"
+        keywords = '.+'.join(re.escape('file').split('\\ '))
+        search = pattern % keywords
+        result = self.fsm.get_paths_by_pattern(search)
+        self.assertEqual(result, expected)
+
+    def test_get_paths_by_pattern_not_in_server(self):
+        """Check that we ignore the files that are not still in the server.."""
+        mdid = 'id'
+        path = '/my/path/to/file_test'
+        mdobj = {'server_hash': 'asdqwe123'}
+        mdid2 = 'id2'
+        path2 = '/home/to/my_files'
+        mdobj2 = {'server_hash': ''}
+        mdid3 = 'id3'
+        path3 = '/home2/to/my_files'
+        mdobj3 = {'server_hash': 'asdqwe456'}
+        self.fsm._idx_path = {path: mdid, path2: mdid2, path3: mdid3}
+        self.fsm.fs = {mdid: mdobj, mdid2: mdobj2, mdid3: mdobj3}
+        expected = ['/my/path/to/file_test']
+        # expectations
+        paths = "(%s|%s)" % ('/my/path/', '/home/')
+        pattern = paths + ".*/.*%s.*$"
+        keywords = '.+'.join(re.escape('file').split('\\ '))
+        search = pattern % keywords
+        result = self.fsm.get_paths_by_pattern(search)
+        self.assertEqual(result, expected)
+
+    def test_get_paths_by_pattern_sorted_result(self):
+        """Search that we obtained the paths sorted.."""
+        mdid = 'id'
+        path = '/my/path/to/file_test'
+        mdobj = {'server_hash': 'asdqwe123'}
+        mdid2 = 'id2'
+        path2 = '/home/to/my_files'
+        mdobj2 = {'server_hash': 'asdqwe456'}
+        mdid3 = 'id3'
+        path3 = '/home2/to/my_files'
+        mdobj3 = {'server_hash': 'asdqwe456'}
+        self.fsm._idx_path = {path: mdid, path2: mdid2, path3: mdid3}
+        self.fsm.fs = {mdid: mdobj, mdid2: mdobj2, mdid3: mdobj3}
+        expected = ['/my/path/to/file_test', '/home/to/my_files']
+        # expectations
+        paths = "(%s|%s)" % ('/my/path/', '/home/')
+        pattern = paths + ".*/.*%s.*$"
+        keywords = '.+'.join(re.escape('file').split('\\ '))
+        search = pattern % keywords
+        result = self.fsm.get_paths_by_pattern(search)
+        self.assertNotEqual(result, expected)
+        expected = sorted(expected)
+        self.assertEqual(result, expected)
\ No newline at end of file

=== modified file 'ubuntuone/platform/ipc/ipc_client.py'
--- ubuntuone/platform/ipc/ipc_client.py	2012-09-06 22:19:37 +0000
+++ ubuntuone/platform/ipc/ipc_client.py	2012-10-23 17:07:21 +0000
@@ -213,6 +213,10 @@
          * int: bytes written
         """
 
+    @remote
+    def search_files(self, name):
+        """Returns a list of the files that contain name in the path."""
+
     @signal
     def on_content_queue_changed(self):
         """Emit ContentQueueChanged."""

=== modified file 'ubuntuone/platform/ipc/linux.py'
--- ubuntuone/platform/ipc/linux.py	2012-08-13 14:34:36 +0000
+++ ubuntuone/platform/ipc/linux.py	2012-10-23 17:07:21 +0000
@@ -411,6 +411,12 @@
         """Return a list of dirty nodes."""
         return self.service.file_system.get_dirty_nodes()
 
+    @dbus.service.method(DBUS_IFACE_FS_NAME,
+                         in_signature='s', out_signature='as')
+    def search_files(self, pattern):
+        """Return the files (as a list) that contain pattern in the path."""
+        return self.service.file_system.search_files(pattern)
+
 
 class Shares(DBusExposedObject):
     """An interface to interact with shares."""

=== modified file 'ubuntuone/platform/ipc/perspective_broker.py'
--- ubuntuone/platform/ipc/perspective_broker.py	2012-09-06 22:19:37 +0000
+++ ubuntuone/platform/ipc/perspective_broker.py	2012-10-23 17:07:21 +0000
@@ -491,6 +491,7 @@
         'get_metadata_by_node',
         'get_metadata_and_quick_tree_synced',
         'get_dirty_nodes',
+        'search_files',
     ]
 
     def get_metadata(self, path):
@@ -515,6 +516,10 @@
         """Return a list of dirty nodes."""
         return self.service.file_system.get_dirty_nodes()
 
+    def search_files(self, pattern):
+        """Search for the occurrence of pattern in the files names."""
+        return self.service.file_system.search_files(pattern)
+
 
 class Shares(IPCExposedObject):
     """An interface to interact with shares."""

=== modified file 'ubuntuone/platform/tools/__init__.py'
--- ubuntuone/platform/tools/__init__.py	2012-10-05 12:44:28 +0000
+++ ubuntuone/platform/tools/__init__.py	2012-10-23 17:07:21 +0000
@@ -482,6 +482,11 @@
         """Get metadata for 'path'."""
         return self.proxy.call_method('file_system', 'get_metadata', path)
 
+    @log_call(logger.debug)
+    def search_files(self, pattern):
+        """Get the files that matches the pattern."""
+        return self.proxy.call_method('file_system', 'search_files', pattern)
+
     @defer.inlineCallbacks
     @log_call(logger.debug)
     def change_public_access(self, path, is_public):

=== added file 'ubuntuone/syncdaemon/files_search.py'
--- ubuntuone/syncdaemon/files_search.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/syncdaemon/files_search.py	2012-10-23 17:07:21 +0000
@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2011-2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+"""Searchs for files inside the U1 folder."""
+
+import re
+
+
+class SearchFiles(object):
+    """Seearch for specific patterns in the U1 files names."""
+
+    def __init__(self, fs):
+        self.fs = fs
+        root, udf_dir, shared_dir, _ = self.fs.vm.get_folders()
+        paths = "(%s|%s|%s)" % (root, udf_dir, shared_dir)
+        self.pattern = paths + ".*/.*%s.*$"
+
+    def search(self, pattern=''):
+        """Search for the files that contains name."""
+        keywords = '.+'.join(re.escape(pattern).split('\\ '))
+        search = self.pattern % keywords
+        results = self.fs.get_paths_by_pattern(search)
+        return results
\ No newline at end of file

=== modified file 'ubuntuone/syncdaemon/filesystem_manager.py'
--- ubuntuone/syncdaemon/filesystem_manager.py	2012-08-08 13:21:13 +0000
+++ ubuntuone/syncdaemon/filesystem_manager.py	2012-10-23 17:07:21 +0000
@@ -33,6 +33,7 @@
 from __future__ import with_statement
 
 import os
+import re
 import time
 import functools
 import itertools
@@ -324,7 +325,7 @@
 
     def __init__(self, data_dir, partials_dir, vm, db):
         if not isinstance(data_dir, basestring):
-            raise TypeError("data_dir should be a string instead of %s" % \
+            raise TypeError("data_dir should be a string instead of %s" %
                             type(data_dir))
         fsmdir = os.path.join(data_dir, 'fsm')
         self._trash_dir = os.path.join(data_dir, 'trash')
@@ -1363,6 +1364,21 @@
 
         return all_paths
 
+    def get_paths_by_pattern(self, search):
+        """Return a list of  paths that match the pattern."""
+        pattern = re.compile(search)
+
+        def _get_matching():
+            """Find the paths that match"""
+            for p, m in self._idx_path.iteritems():
+                #basename = os.path.basename(p)
+                if pattern.match(p):
+                    mdobj = self.fs[m]
+                    if mdobj["server_hash"]:
+                        yield p
+
+        return sorted(_get_matching())
+
     def delete_to_trash(self, mdid, parent_id):
         """Move the node to the trash."""
         mdobj = self.fs[mdid]

=== modified file 'ubuntuone/syncdaemon/interaction_interfaces.py'
--- ubuntuone/syncdaemon/interaction_interfaces.py	2012-09-14 22:46:21 +0000
+++ ubuntuone/syncdaemon/interaction_interfaces.py	2012-10-23 17:07:21 +0000
@@ -401,6 +401,12 @@
             dirty_nodes.append(self._mdobj_dict(mdobj))
         return dirty_nodes
 
+    @unicode_to_bytes
+    @log_call(logger.debug)
+    def search_files(self, pattern):
+        """Search for the occurrence of pattern in the files names."""
+        return self.main.search.search(pattern)
+
 
 class SyncdaemonShares(SyncdaemonObject):
     """An interface to interact with shares."""

=== modified file 'ubuntuone/syncdaemon/main.py'
--- ubuntuone/syncdaemon/main.py	2012-09-20 12:56:32 +0000
+++ ubuntuone/syncdaemon/main.py	2012-10-23 17:07:21 +0000
@@ -39,6 +39,7 @@
     action_queue,
     config,
     event_queue,
+    files_search,
     filesystem_manager,
     hash_queue,
     events_nanny,
@@ -156,6 +157,8 @@
         self.mark = task.LoopingCall(self.log_mark)
         self.mark.start(mark_interval)
 
+        self.search = files_search.SearchFiles(self.fs)
+
     def start_event_logger(self):
         """Start the event logger if it's available for this platform."""
         self.eventlog_listener = event_logging.get_listener(self.fs, self.vm)

=== modified file 'ubuntuone/syncdaemon/volume_manager.py'
--- ubuntuone/syncdaemon/volume_manager.py	2012-08-06 19:18:57 +0000
+++ ubuntuone/syncdaemon/volume_manager.py	2012-10-23 17:07:21 +0000
@@ -506,6 +506,11 @@
         """Request the list of volumes to the server."""
         self.m.action_q.list_volumes()
 
+    def get_folders(self):
+        """Get the list of folders where the data is stored."""
+        return (self.m.root_dir, self._udfs_dir, self._shared_dir,
+            self._shares_dir)
+
     def handle_AQ_LIST_VOLUMES(self, volumes):
         """Handle AQ_LIST_VOLUMES event."""
         self.log.debug('handle_AQ_LIST_VOLUMES: handling volumes list.')