1
=== modified file 'data/CMakeLists.txt'
2
--- data/CMakeLists.txt	2016-10-07 18:58:30 +0000
3
+++ data/CMakeLists.txt	2016-11-16 17:34:14 +0000
4
@@ -8,7 +8,7 @@
5
8
        DESTINATION ${CMAKE_INSTALL_DATADIR}/upstart/sessions)
8
        DESTINATION ${CMAKE_INSTALL_DATADIR}/upstart/sessions)
6
9
install(FILES libertine-lxc-sudo
9
install(FILES libertine-lxc-sudo
7
10
        DESTINATION ${CMAKE_INSTALL_SYSCONFDIR}/sudoers.d)
10
        DESTINATION ${CMAKE_INSTALL_SYSCONFDIR}/sudoers.d)
9
11
install(FILES com.canonical.libertine.LxcManager.service
11
install(FILES com.canonical.libertine.LxcManager.service com.canonical.libertine.ContainerManager.service
10
12
        DESTINATION ${CMAKE_INSTALL_DATADIR}/dbus-1/services)
12
        DESTINATION ${CMAKE_INSTALL_DATADIR}/dbus-1/services)
11
13
13
12
14
configure_file("python3-libertine-chroot.click-hook.in"
14
configure_file("python3-libertine-chroot.click-hook.in"
13
15
15
14
=== added file 'data/com.canonical.libertine.ContainerManager.service'
15
--- data/com.canonical.libertine.ContainerManager.service	1970-01-01 00:00:00 +0000
16
+++ data/com.canonical.libertine.ContainerManager.service	2016-11-16 17:34:14 +0000
17
@@ -0,0 +1,3 @@
18
1
[D-BUS Service]
19
2
Name=com.canonical.libertine.ContainerManager
20
3
Exec=/usr/bin/libertined --cache-output
21
0
4
22
=== modified file 'debian/libertine-tools.install'
23
--- debian/libertine-tools.install	2016-10-26 20:48:08 +0000
24
+++ debian/libertine-tools.install	2016-11-16 17:34:14 +0000
25
@@ -1,4 +1,6 @@
26
1
usr/bin/libertine-container-manager
1
usr/bin/libertine-container-manager
27
2
usr/bin/libertine-launch
2
usr/bin/libertine-launch
28
3
usr/bin/libertined
29
4
usr/share/dbus-1/services/com.canonical.libertine.ContainerManager.service
30
3
usr/share/bash-completion/completions/libertine-container-manager
5
usr/share/bash-completion/completions/libertine-container-manager
31
4
usr/share/man
6
usr/share/man
32
5
7
33
=== modified file 'debian/python3-libertine.install'
34
--- debian/python3-libertine.install	2016-10-13 18:28:34 +0000
35
+++ debian/python3-libertine.install	2016-11-16 17:34:14 +0000
36
@@ -4,4 +4,5 @@
37
4
usr/lib/python*/*/libertine/Libertine.py
4
usr/lib/python*/*/libertine/Libertine.py
38
5
usr/lib/python*/*/libertine/__init__.py
5
usr/lib/python*/*/libertine/__init__.py
39
6
usr/lib/python*/*/libertine/launcher
6
usr/lib/python*/*/libertine/launcher
40
7
usr/lib/python*/*/libertine/service
41
7
usr/lib/python*/*/libertine/utils.py
8
usr/lib/python*/*/libertine/utils.py
42
8
9
43
=== modified file 'python/libertine/ChrootContainer.py'
44
--- python/libertine/ChrootContainer.py	2016-11-16 16:38:16 +0000
45
+++ python/libertine/ChrootContainer.py	2016-11-16 17:34:14 +0000
46
@@ -64,8 +64,10 @@
47
64
        container_root = os.path.join(utils.get_libertine_containers_dir_path(), self.container_id)
64
        container_root = os.path.join(utils.get_libertine_containers_dir_path(), self.container_id)
48
65
        try:
65
        try:
49
66
            shutil.rmtree(container_root)
66
            shutil.rmtree(container_root)
50
67
            return True
51
67
        except Exception as e:
68
        except Exception as e:
52
68
            print("%s" % e)
69
            print("%s" % e)
53
70
            return False
54
69
71
55
70
    def create_libertine_container(self, password=None, multiarch=False, verbosity=1):
72
    def create_libertine_container(self, password=None, multiarch=False, verbosity=1):
56
71
        # Create the actual chroot
73
        # Create the actual chroot
57
@@ -147,7 +149,7 @@
58
147
    def update_packages(self, verbosity=1):
149
    def update_packages(self, verbosity=1):
59
148
        retcode = super().update_packages(verbosity)
150
        retcode = super().update_packages(verbosity)
60
149
        self._run_ldconfig(verbosity)
151
        self._run_ldconfig(verbosity)
62
150
        return retcode
152
        return retcode == 0
63
151
153
64
152
    def install_package(self, package_name, verbosity=1, no_dialog=False, update_cache=True):
154
    def install_package(self, package_name, verbosity=1, no_dialog=False, update_cache=True):
65
153
        returncode = super().install_package(package_name, verbosity, no_dialog, update_cache)
155
        returncode = super().install_package(package_name, verbosity, no_dialog, update_cache)
66
154
156
67
=== modified file 'python/libertine/ContainersConfig.py'
68
--- python/libertine/ContainersConfig.py	2016-11-09 18:25:33 +0000
69
+++ python/libertine/ContainersConfig.py	2016-11-16 17:34:14 +0000
70
@@ -28,6 +28,7 @@
71
28
    if (os.path.exists(container_config_file) and
28
    if (os.path.exists(container_config_file) and
72
29
        os.path.getsize(container_config_file) != 0):
29
        os.path.getsize(container_config_file) != 0):
73
30
        with open(container_config_file, 'r') as fd:
30
        with open(container_config_file, 'r') as fd:
74
31
            fcntl.flock(fd, fcntl.LOCK_EX)
75
31
            container_list = json.load(fd)
32
            container_list = json.load(fd)
76
32
33
77
33
    return container_list
34
    return container_list
78
@@ -41,18 +42,18 @@
79
41
        container_list["_warning"] = "This file is automatically generated by Libertine and should not be manually edited."
42
        container_list["_warning"] = "This file is automatically generated by Libertine and should not be manually edited."
80
42
43
81
43
    with open(container_config_file, 'w') as fd:
44
    with open(container_config_file, 'w') as fd:
83
44
        fcntl.lockf(fd, fcntl.LOCK_EX)
45
        fcntl.flock(fd, fcntl.LOCK_EX)
84
45
        json.dump(container_list, fd, sort_keys=True, indent=4)
46
        json.dump(container_list, fd, sort_keys=True, indent=4)
85
46
        fd.write('\n')
47
        fd.write('\n')
86
47
        fcntl.lockf(fd, fcntl.LOCK_UN)
87
48
48
88
49
49
89
50
def container_config_hash():
50
def container_config_hash():
90
51
    checksum = md5()
51
    checksum = md5()
91
52
    container_config_file = libertine.utils.get_libertine_database_file_path()
52
    container_config_file = libertine.utils.get_libertine_database_file_path()
92
53
    if (os.path.exists(container_config_file) and os.path.getsize(container_config_file) != 0):
53
    if (os.path.exists(container_config_file) and os.path.getsize(container_config_file) != 0):
95
54
        with open(container_config_file, "rb") as f:
54
        with open(container_config_file, "rb") as fd:
96
55
            for chunk in iter(lambda: f.read(128 * checksum.block_size), b""):
55
            fcntl.flock(fd, fcntl.LOCK_EX)
97
56
            for chunk in iter(lambda: fd.read(128 * checksum.block_size), b""):
98
56
                checksum.update(chunk)
57
                checksum.update(chunk)
99
57
    return checksum.hexdigest()
58
    return checksum.hexdigest()
100
58
59
101
@@ -90,7 +91,8 @@
102
90
            return container[key]
91
            return container[key]
103
91
92
104
92
    def _get_array_object_value_by_key(self, container_id, array_key, object_key, matcher, key):
93
    def _get_array_object_value_by_key(self, container_id, array_key, object_key, matcher, key):
106
93
        for item in self._get_value_by_key(container_id, array_key):
94
        items = self._get_value_by_key(container_id, array_key) or []
107
95
        for item in items:
108
94
            if item[object_key] == matcher:
96
            if item[object_key] == matcher:
109
95
                return item[key]
97
                return item[key]
110
96
98
111
97
99
112
=== modified file 'python/libertine/HostInfo.py'
113
--- python/libertine/HostInfo.py	2016-07-07 20:00:10 +0000
114
+++ python/libertine/HostInfo.py	2016-11-16 17:34:14 +0000
115
@@ -36,7 +36,7 @@
116
36
36
117
37
        return distinfo.get('CODENAME', 'n/a')
37
        return distinfo.get('CODENAME', 'n/a')
118
38
38
120
39
    def is_distro_valid(self, distro, force):
39
    def is_distro_valid(self, distro, force=False):
121
40
        if force:
40
        if force:
122
41
            return UbuntuDistroInfo().valid(distro)
41
            return UbuntuDistroInfo().valid(distro)
123
42
42
124
43
43
125
=== modified file 'python/libertine/Libertine.py'
126
--- python/libertine/Libertine.py	2016-11-10 16:36:05 +0000
127
+++ python/libertine/Libertine.py	2016-11-16 17:34:14 +0000
128
@@ -166,7 +166,7 @@
129
166
        :param verbosity: the chattiness of the output on a range from 0 to 2
166
        :param verbosity: the chattiness of the output on a range from 0 to 2
130
167
        """
167
        """
131
168
        self.update_apt_cache(verbosity)
168
        self.update_apt_cache(verbosity)
133
169
        return self.run_in_container(apt_command_prefix(verbosity) + '--force-yes dist-upgrade')
169
        return self.run_in_container(apt_command_prefix(verbosity) + '--force-yes dist-upgrade') == 0
134
170
170
135
171
    def install_package(self, package_name, verbosity=1, no_dialog=False, update_cache=True):
171
    def install_package(self, package_name, verbosity=1, no_dialog=False, update_cache=True):
136
172
        """
172
        """
137
173
173
138
=== modified file 'python/libertine/LxcContainer.py'
139
--- python/libertine/LxcContainer.py	2016-11-10 20:43:40 +0000
140
+++ python/libertine/LxcContainer.py	2016-11-16 17:34:14 +0000
141
@@ -199,9 +199,12 @@
142
199
        return super().update_packages(verbosity)
199
        return super().update_packages(verbosity)
143
200
200
144
201
    def destroy_libertine_container(self):
201
    def destroy_libertine_container(self):
148
202
        if self.container.defined:
202
        if not self.container.defined:
149
203
            self.container.stop()
203
            return False
150
204
            self.container.destroy()
204
151
205
        self.container.stop()
152
206
        self.container.destroy()
153
207
        return True
154
205
208
155
206
    def create_libertine_container(self, password=None, multiarch=False, verbosity=1):
209
    def create_libertine_container(self, password=None, multiarch=False, verbosity=1):
156
207
        if password is None:
210
        if password is None:
157
208
211
158
=== added directory 'python/libertine/service'
159
=== added file 'python/libertine/service/__init__.py'
160
=== added file 'python/libertine/service/apt.py'
161
--- python/libertine/service/apt.py	1970-01-01 00:00:00 +0000
162
+++ python/libertine/service/apt.py	2016-11-16 17:34:14 +0000
163
@@ -0,0 +1,77 @@
164
1
# Copyright 2016 Canonical Ltd.
165
2
#
166
3
# This program is free software: you can redistribute it and/or modify
167
4
# it under the terms of the GNU General Public License as published by
168
5
# the Free Software Foundation; version 3 of the License.
169
6
#
170
7
# This program is distributed in the hope that it will be useful,
171
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
172
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
173
10
# GNU General Public License for more details.
174
11
#
175
12
# You should have received a copy of the GNU General Public License
176
13
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
177
14
178
15
import apt
179
16
import re
180
17
181
18
import gi
182
19
gi.require_version('Libertine', '1')
183
20
from gi.repository import Libertine
184
21
185
22
from libertine import utils
186
23
from os import path
187
24
from threading import Lock
188
25
189
26
190
27
class AptCache(object):
191
28
    """
192
29
    Class to find app information using apt-cache
193
30
    """
194
31
    def __init__(self, container_id):
195
32
        super(AptCache, self).__init__()
196
33
        self._container = container_id
197
34
        self._cache = None
198
35
        self._lock = Lock()
199
36
200
37
    def search(self, query):
201
38
        self._load()
202
39
203
40
        pkg_keys = [key for key in self._cache.keys() if re.match(query, key)]
204
41
        apps = []
205
42
        for key in pkg_keys:
206
43
            apps.append(self._app_to_dict(key))
207
44
        return apps
208
45
209
46
    def app_info(self, app_id):
210
47
        self._load()
211
48
        return self._app_to_dict(app_id)
212
49
213
50
    def _app_to_dict(self, app_id):
214
51
        app_data = {}
215
52
        if app_id in self._cache.keys():
216
53
            app = self._cache[app_id]
217
54
            app_data["name"] = app.name
218
55
            app_data["id"] = app.name
219
56
            app_data["package"] = app.name
220
57
            if len(app.versions) > 0:
221
58
                app_data["summary"] = app.versions[0].summary
222
59
                app_data["website"] = app.versions[0].homepage
223
60
                app_data["description"] = app.versions[0].description
224
61
            app_data["package"] = app.name
225
62
226
63
        return app_data
227
64
228
65
    def _load(self):
229
66
        with self._lock:
230
67
            if self._cache is None:
231
68
                try:
232
69
                    utils.get_logger().debug("Trying aptcache for container %s" % self._container)
233
70
                    container_path = Libertine.container_path(self._container)
234
71
                    if not container_path or not path.exists(container_path):
235
72
                        raise PermissionError
236
73
237
74
                    self._cache = apt.Cache(rootdir=container_path)
238
75
                except PermissionError:
239
76
                    utils.get_logger().debug("Trying system aptcache")
240
77
                    self._cache = apt.Cache()
241
0
78
242
=== added file 'python/libertine/service/container.py'
243
--- python/libertine/service/container.py	1970-01-01 00:00:00 +0000
244
+++ python/libertine/service/container.py	2016-11-16 17:34:14 +0000
245
@@ -0,0 +1,139 @@
246
1
# Copyright 2016 Canonical Ltd.
247
2
#
248
3
# This program is free software: you can redistribute it and/or modify
249
4
# it under the terms of the GNU General Public License as published by
250
5
# the Free Software Foundation; version 3 of the License.
251
6
#
252
7
# This program is distributed in the hope that it will be useful,
253
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
254
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
255
10
# GNU General Public License for more details.
256
11
#
257
12
# You should have received a copy of the GNU General Public License
258
13
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
259
14
260
15
from libertine.service.tasks import *
261
16
from libertine import utils
262
17
from libertine.service import apt
263
18
264
19
265
20
class Container(object):
266
21
    def __init__(self, container_id, config, lock, connection, callback):
267
22
        self._id = container_id
268
23
        self._connection = connection
269
24
        self._callback = callback
270
25
        self._config = config
271
26
        self._lock = lock
272
27
        self._tasks = []
273
28
        self._cache = apt.AptCache(self.id)
274
29
275
30
    def _cleanup_task(self, task):
276
31
        utils.get_logger().debug("cleaning up tasks for container '%s'" % self.id)
277
32
278
33
        if task in self._tasks:
279
34
            self._tasks.remove(task)
280
35
281
36
        if len(self._tasks) == 0:
282
37
            self._callback(self)
283
38
284
39
    @property
285
40
    def id(self):
286
41
        return self._id
287
42
288
43
    @property
289
44
    def tasks(self):
290
45
        return [task.id for task in self._tasks if task.running]
291
46
292
47
    def search(self, query):
293
48
        utils.get_logger().debug("search container '%s' for package '%s'" % (self.id, query))
294
49
295
50
        task = SearchTask(self.id, self._cache, query, self._connection, self._cleanup_task)
296
51
        self._tasks.append(task)
297
52
        task.start()
298
53
299
54
        return task.id
300
55
301
56
    def app_info(self, package_name):
302
57
        utils.get_logger().debug("get info for package '%s' in container '%s'" % (package_name, self.id))
303
58
304
59
        related_task_ids = [t.id for t in self._tasks if t.package == package_name and t.running]
305
60
        task = AppInfoTask(self.id, self._cache, package_name, related_task_ids, self._config, self._connection, self._cleanup_task)
306
61
307
62
        self._tasks.append(task)
308
63
        task.start()
309
64
        return task.id
310
65
311
66
    def install(self, package_name):
312
67
        utils.get_logger().debug("Install package '%s' from container '%s'" % (package_name, self.id))
313
68
314
69
        tasks = [t for t in self._tasks if t.matches(package_name, InstallTask) and t.running]
315
70
        if len(tasks) > 0:
316
71
            utils.get_logger().debug("Install already in progress for '%s':'%s'" % (package_name, self.id))
317
72
            return tasks[0].id
318
73
319
74
        task = InstallTask(package_name, self.id, self._config, self._lock, self._connection, self._cleanup_task)
320
75
        self._tasks.append(task)
321
76
        task.start()
322
77
        return task.id
323
78
324
79
    def remove(self, package_name):
325
80
        utils.get_logger().debug("Remove package '%s' from container '%s'" % (package_name, self.id))
326
81
327
82
        tasks = [t for t in self._tasks if t.matches(package_name, RemoveTask) and t.running]
328
83
        if len(tasks) > 0:
329
84
            utils.get_logger().debug("Remove already in progress for '%s':'%s'" % (package_name, self.id))
330
85
            return tasks[0].id
331
86
332
87
        task = RemoveTask(package_name, self.id, self._config, self._lock, self._connection, self._cleanup_task)
333
88
        self._tasks.append(task)
334
89
        task.start()
335
90
        return task.id
336
91
337
92
    def create(self, container_name, distro, container_type, enable_multiarch):
338
93
        utils.get_logger().debug("Create container with ID '%s'" % self.id)
339
94
340
95
        tasks = [t for t in self._tasks if t.matches(self.id, CreateTask) and t.running]
341
96
        if len(tasks) > 0:
342
97
            utils.get_logger().debug("Create already in progress for '%s'" % self.id)
343
98
            return tasks[0].id
344
99
345
100
        task = CreateTask(self.id, container_name, distro, container_type, enable_multiarch,
346
101
                          self._config, self._lock, self._connection, self._cleanup_task)
347
102
        self._tasks.append(task)
348
103
        task.start()
349
104
        return task.id
350
105
351
106
    def destroy(self):
352
107
        utils.get_logger().debug("Destroy container with ID '%s'" % self.id)
353
108
354
109
        tasks = [t for t in self._tasks if t.matches(self.id, DestroyTask) and t.running]
355
110
        if len(tasks) > 0:
356
111
            utils.get_logger().debug("Destroy already in progress for '%s'" % self.id)
357
112
            return tasks[0].id
358
113
359
114
        task = DestroyTask(self.id, self._config, self._lock, self._connection, self._cleanup_task)
360
115
        self._tasks.append(task)
361
116
        task.start()
362
117
        return task.id
363
118
364
119
    def update(self):
365
120
        utils.get_logger().debug("Update container with ID '%s'" % self.id)
366
121
367
122
        tasks = [t for t in self._tasks if t.matches(self.id, UpdateTask) and t.running]
368
123
        if len(tasks) > 0:
369
124
            utils.get_logger().debug("Update already in progress for '%s'" % self.id)
370
125
            return tasks[0].id
371
126
372
127
        task = UpdateTask(self.id, self._config, self._lock, self._connection, self._cleanup_task)
373
128
        self._tasks.append(task)
374
129
        task.start()
375
130
        return task.id
376
131
377
132
    def list_apps(self):
378
133
        utils.get_logger().debug("List all apps in container '%s'" % self.id)
379
134
380
135
        task = ListAppsTask(self.id, self._config, self._connection, self._cleanup_task)
381
136
382
137
        self._tasks.append(task)
383
138
        task.start()
384
139
        return task.id
385
0
140
386
=== added file 'python/libertine/service/manager.py'
387
--- python/libertine/service/manager.py	1970-01-01 00:00:00 +0000
388
+++ python/libertine/service/manager.py	2016-11-16 17:34:14 +0000
389
@@ -0,0 +1,115 @@
390
1
# Copyright 2016 Canonical Ltd.
391
2
#
392
3
# This program is free software: you can redistribute it and/or modify
393
4
# it under the terms of the GNU General Public License as published by
394
5
# the Free Software Foundation; version 3 of the License.
395
6
#
396
7
# This program is distributed in the hope that it will be useful,
397
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
398
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
399
10
# GNU General Public License for more details.
400
11
#
401
12
# You should have received a copy of the GNU General Public License
402
13
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
403
14
404
15
import dbus
405
16
import dbus.service
406
17
import libertine.service.task_dispatcher
407
18
from dbus.mainloop.glib import DBusGMainLoop
408
19
from libertine.service import container
409
20
from libertine import utils
410
21
411
22
412
23
LIBERTINE_MANAGER_NAME = "com.canonical.libertine.Service"
413
24
LIBERTINE_MANAGER_INTERFACE = LIBERTINE_MANAGER_NAME
414
25
LIBERTINE_STORE_PATH = "/Manager"
415
26
416
27
417
28
class Manager(dbus.service.Object):
418
29
    def __init__(self):
419
30
        utils.get_logger().debug("creating service")
420
31
        DBusGMainLoop(set_as_default=True)
421
32
        try:
422
33
            bus_name = dbus.service.BusName(LIBERTINE_MANAGER_NAME,
423
34
                                            bus=dbus.SessionBus(),
424
35
                                            do_not_queue=True)
425
36
        except dbus.exceptions.NameExistsException:
426
37
            utils.get_logger().warning("service is already running")
427
38
            raise
428
39
429
40
        super().__init__(bus_name, LIBERTINE_STORE_PATH)
430
41
431
42
        self._dispatcher = libertine.service.task_dispatcher.TaskDispatcher(self.connection)
432
43
433
44
    # Information
434
45
435
46
    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
436
47
                         in_signature='ss',
437
48
                         out_signature='o')
438
49
    def search(self, container_id, search_string):
439
50
        utils.get_logger().debug("search('{}', '{}') called".format(container_id, search_string))
440
51
        return self._dispatcher.search(container_id, search_string)
441
52
442
53
    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
443
54
                         in_signature='ss',
444
55
                         out_signature='o')
445
56
    def app_info(self, container_id, app_id):
446
57
        utils.get_logger().debug("app_info('{}', '{}') called".format(container_id, app_id))
447
58
        return self._dispatcher.app_info(container_id, app_id)
448
59
449
60
    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
450
61
                         in_signature='s',
451
62
                         out_signature='o')
452
63
    def container_info(self, container_id):
453
64
        utils.get_logger().debug("container_info('{}')".format(container_id))
454
65
        return self._dispatcher.container_info(container_id)
455
66
456
67
    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
457
68
                         in_signature='s',
458
69
                         out_signature='o')
459
70
    def list_apps(self, container_id):
460
71
        utils.get_logger().debug("list_apps('{}')".format(container_id))
461
72
        return self._dispatcher.list_apps(container_id)
462
73
463
74
    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
464
75
                         out_signature='o')
465
76
    def list(self):
466
77
        utils.get_logger().debug("list()")
467
78
        return self._dispatcher.list()
468
79
469
80
    # Operations
470
81
471
82
    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
472
83
                         in_signature='ssssb',
473
84
                         out_signature='o')
474
85
    def create(self, container_id, container_name='', distro='', container_type='', enable_multiarch=False):
475
86
        utils.get_logger().debug("create('{}', '{}', '{}', '{}', '{}')".format(container_id, container_name, distro, container_type, enable_multiarch))
476
87
        return self._dispatcher.create(container_id, container_name, distro, container_type, enable_multiarch)
477
88
478
89
    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
479
90
                         in_signature='s',
480
91
                         out_signature='o')
481
92
    def destroy(self, container_id):
482
93
        utils.get_logger().debug("destroy('{}')".format(container_id))
483
94
        return self._dispatcher.destroy(container_id)
484
95
485
96
    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
486
97
                         in_signature='s',
487
98
                         out_signature='o')
488
99
    def update(self, container_id):
489
100
        utils.get_logger().debug("update('{}')".format(container_id))
490
101
        return self._dispatcher.update(container_id)
491
102
492
103
    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
493
104
                         in_signature='ss',
494
105
                         out_signature='o')
495
106
    def install(self, container_id, package_name):
496
107
        utils.get_logger().debug("install('%s', '%s')" % (container_id, package_name))
497
108
        return self._dispatcher.install(container_id, package_name)
498
109
499
110
    @dbus.service.method(LIBERTINE_MANAGER_INTERFACE,
500
111
                         in_signature='ss',
501
112
                         out_signature='o')
502
113
    def remove(self, container_id, package_name):
503
114
        utils.get_logger().debug("remove('%s', '%s')" % (container_id, package_name))
504
115
        return self._dispatcher.remove(container_id, package_name)
505
0
116
506
=== added file 'python/libertine/service/progress.py'
507
--- python/libertine/service/progress.py	1970-01-01 00:00:00 +0000
508
+++ python/libertine/service/progress.py	2016-11-16 17:34:14 +0000
509
@@ -0,0 +1,83 @@
510
1
# Copyright 2016 Canonical Ltd.
511
2
#
512
3
# This program is free software: you can redistribute it and/or modify
513
4
# it under the terms of the GNU General Public License as published by
514
5
# the Free Software Foundation; version 3 of the License.
515
6
#
516
7
# This program is distributed in the hope that it will be useful,
517
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
518
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
519
10
# GNU General Public License for more details.
520
11
#
521
12
# You should have received a copy of the GNU General Public License
522
13
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
523
14
524
15
import dbus.service
525
16
import threading
526
17
from libertine import utils
527
18
from time import time
528
19
529
20
DOWNLOAD_INTERFACE = "com.canonical.applications.Download"
530
21
PROGRESS_INTERFACE = "com.canonical.libertine.Progress"
531
22
532
23
class Progress(dbus.service.Object):
533
24
    def __init__(self, connection):
534
25
        utils.get_logger().debug("creating a Progress object")
535
26
        self._finished = False
536
27
        self._result = []
537
28
        self._error = ''
538
29
        dbus.service.Object.__init__(self, conn=connection, object_path=("/Progress/%s" % hex(int(time()*10000000))[2:]))
539
30
540
31
        self.emit_processing()
541
32
542
33
    @property
543
34
    def id(self):
544
35
        return self._object_path
545
36
546
37
    def emit_processing(self):
547
38
        if not self.done:
548
39
            self.processing(self.id)
549
40
            threading.Timer(0.5, self.emit_processing).start()
550
41
551
42
    @property
552
43
    def done(self):
553
44
        return self._finished
554
45
555
46
    @dbus.service.signal(DOWNLOAD_INTERFACE)
556
47
    def processing(self, path):
557
48
        utils.get_logger().debug("emit processing('%s')" % path)
558
49
559
50
    @dbus.service.signal(DOWNLOAD_INTERFACE)
560
51
    def finished(self, path):
561
52
        utils.get_logger().debug("emit finished('%s')" % path)
562
53
        self._finished = True
563
54
564
55
    @dbus.service.signal(DOWNLOAD_INTERFACE)
565
56
    def progress(self, received, total):
566
57
        utils.get_logger().debug("emit progress(%d, %d)" % (received, total))
567
58
568
59
    @dbus.service.signal(DOWNLOAD_INTERFACE)
569
60
    def error(self, message):
570
61
        utils.get_logger().error("emit error(%s)" % message)
571
62
        self._error = message
572
63
        self._finished = True
573
64
574
65
    @dbus.service.signal(PROGRESS_INTERFACE)
575
66
    def data(self, message):
576
67
        utils.get_logger().debug("emit data(%s)" % message)
577
68
        self._result.append(message)
578
69
579
70
    @dbus.service.method(PROGRESS_INTERFACE, out_signature='b')
580
71
    def running(self):
581
72
        utils.get_logger().debug("running()")
582
73
        return not self.done
583
74
584
75
    @dbus.service.method(PROGRESS_INTERFACE, out_signature='s')
585
76
    def result(self):
586
77
        utils.get_logger().debug("result()")
587
78
        return "\n".join(self._result)
588
79
589
80
    @dbus.service.method(PROGRESS_INTERFACE, out_signature='s')
590
81
    def last_error(self):
591
82
        utils.get_logger().debug("last_error()")
592
83
        return self._error
593
0
84
594
=== added file 'python/libertine/service/task_dispatcher.py'
595
--- python/libertine/service/task_dispatcher.py	1970-01-01 00:00:00 +0000
596
+++ python/libertine/service/task_dispatcher.py	2016-11-16 17:34:14 +0000
597
@@ -0,0 +1,114 @@
598
1
# Copyright 2016 Canonical Ltd.
599
2
#
600
3
# This program is free software: you can redistribute it and/or modify
601
4
# it under the terms of the GNU General Public License as published by
602
5
# the Free Software Foundation; version 3 of the License.
603
6
#
604
7
# This program is distributed in the hope that it will be useful,
605
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
606
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
607
10
# GNU General Public License for more details.
608
11
#
609
12
# You should have received a copy of the GNU General Public License
610
13
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
611
14
612
15
613
16
import libertine.ContainersConfig
614
17
from libertine.service.container import Container
615
18
from libertine.service.tasks import *
616
19
from threading import Lock
617
20
from libertine import utils
618
21
619
22
620
23
class TaskDispatcher(object):
621
24
    def __init__(self, connection):
622
25
        self._connection = connection
623
26
        self._config = libertine.ContainersConfig.ContainersConfig()
624
27
        self._lock = Lock()
625
28
        self._containerless_tasks = []
626
29
        self._tasks = []
627
30
        self._containers = []
628
31
629
32
    def _cleanup_task(self, task):
630
33
        utils.get_logger().debug("cleaning up containerless task '%s'" % task.id)
631
34
        if task in self._tasks:
632
35
            self._tasks.remove(task)
633
36
634
37
    def _cleanup_container(self, container):
635
38
        utils.get_logger().debug("cleaning up container '%s'" % container)
636
39
        if container in self._containers:
637
40
            self._containers.remove(container)
638
41
639
42
    def _find_or_create_container(self, container_id):
640
43
        utils.get_logger().debug("finding or creating container '%s'" % container_id)
641
44
        container = self._find_container(container_id)
642
45
        if container is not None:
643
46
            utils.get_logger().debug("using existing container '%s'" % container_id)
644
47
            return container
645
48
        container = Container(container_id, self._config, self._lock, self._connection, self._cleanup_container)
646
49
        self._containers.append(container)
647
50
648
51
        return container
649
52
650
53
    def _find_container(self, container_id):
651
54
        containers = [c for c in self._containers if c.id == container_id]
652
55
        if len(containers) > 0:
653
56
            return containers[0]
654
57
655
58
    # Tasks (usually) run within a container
656
59
657
60
    def search(self, container_id, query):
658
61
        utils.get_logger().debug("dispatching search in container '%s' for package '%s'" % (container_id, query))
659
62
        return self._find_or_create_container(container_id).search(query)
660
63
661
64
    def app_info(self, container_id, app_id):
662
65
        utils.get_logger().debug("dispatching app_info in container '%s' for package '%s'" % (container_id, app_id))
663
66
        return self._find_or_create_container(container_id).app_info(app_id)
664
67
665
68
    def install(self, container_id, package_name):
666
69
        utils.get_logger().debug("dispatching install of package '%s' from container '%s'" % (package_name, container_id))
667
70
        return self._find_or_create_container(container_id).install(package_name)
668
71
669
72
    def remove(self, container_id, package_name):
670
73
        utils.get_logger().debug("dispatching remove of package '%s' from container '%s'" % (package_name, container_id))
671
74
        return self._find_or_create_container(container_id).remove(package_name)
672
75
673
76
    def create(self, container_id, container_name, distro, container_type, enable_multiarch):
674
77
        utils.get_logger().debug("dispatching create of container '%s'" % container_id)
675
78
        return self._find_or_create_container(container_id).create(container_name, distro, container_type, enable_multiarch)
676
79
677
80
    def destroy(self, container_id):
678
81
        utils.get_logger().debug("dispatching destroy container '%s'" % container_id)
679
82
        return self._find_or_create_container(container_id).destroy()
680
83
681
84
    def update(self, container_id):
682
85
        utils.get_logger().debug("dispatching update container '%s'" % container_id)
683
86
        return self._find_or_create_container(container_id).update()
684
87
685
88
    def list_apps(self, container_id):
686
89
        utils.get_logger().debug("dispatching list all apps in container '%s'" % container_id)
687
90
        return self._find_or_create_container(container_id).list_apps()
688
91
689
92
    # Containerless Tasks
690
93
691
94
    def container_info(self, container_id):
692
95
        utils.get_logger().debug("dispatching get info for container '%s'" % container_id)
693
96
694
97
        related_task_ids = []
695
98
        container = self._find_container(container_id)
696
99
        if container is not None:
697
100
            related_task_ids = container.tasks
698
101
        task = ContainerInfoTask(container_id, related_task_ids, self._config, self._connection, self._cleanup_task)
699
102
        self._tasks.append(task)
700
103
        task.start()
701
104
702
105
        return task.id
703
106
704
107
    def list(self):
705
108
        utils.get_logger().debug("dispatching list all containers")
706
109
707
110
        task = ListTask(self._connection, self._cleanup_task)
708
111
        self._tasks.append(task)
709
112
        task.start()
710
113
711
114
        return task.id
712
0
115
713
=== added directory 'python/libertine/service/tasks'
714
=== added file 'python/libertine/service/tasks/__init__.py'
715
--- python/libertine/service/tasks/__init__.py	1970-01-01 00:00:00 +0000
716
+++ python/libertine/service/tasks/__init__.py	2016-11-16 17:34:14 +0000
717
@@ -0,0 +1,39 @@
718
1
# Copyright 2016 Canonical Ltd.
719
2
#
720
3
# This program is free software: you can redistribute it and/or modify it
721
4
# under the terms of the GNU General Public License version 3, as published
722
5
# by the Free Software Foundation.
723
6
#
724
7
# This program is distributed in the hope that it will be useful, but
725
8
# WITHOUT ANY WARRANTY; without even the implied warranties of
726
9
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
727
10
# PURPOSE.  See the GNU General Public License for more details.
728
11
#
729
12
# You should have received a copy of the GNU General Public License along
730
13
# with this program.  If not, see <http://www.gnu.org/licenses/>.
731
14
732
15
from .base_task import BaseTask
733
16
from .app_info_task import AppInfoTask
734
17
from .container_info_task import ContainerInfoTask
735
18
from .create_task import CreateTask
736
19
from .destroy_task import DestroyTask
737
20
from .install_task import InstallTask
738
21
from .remove_task import RemoveTask
739
22
from .search_task import SearchTask
740
23
from .update_task import UpdateTask
741
24
from .list_task import ListTask
742
25
from .list_apps_task import ListAppsTask
743
26
744
27
__all__ = [
745
28
          'AppInfoTask',
746
29
          'BaseTask',
747
30
          'ContainerInfoTask',
748
31
          'CreateTask',
749
32
          'DestroyTask',
750
33
          'InstallTask',
751
34
          'RemoveTask',
752
35
          'SearchTask',
753
36
          'UpdateTask',
754
37
          'ListTask',
755
38
          'ListAppsTask'
756
39
          ]
757
0
40
758
=== added file 'python/libertine/service/tasks/app_info_task.py'
759
--- python/libertine/service/tasks/app_info_task.py	1970-01-01 00:00:00 +0000
760
+++ python/libertine/service/tasks/app_info_task.py	2016-11-16 17:34:14 +0000
761
@@ -0,0 +1,35 @@
762
1
# Copyright 2016 Canonical Ltd.
763
2
#
764
3
# This program is free software: you can redistribute it and/or modify
765
4
# it under the terms of the GNU General Public License as published by
766
5
# the Free Software Foundation; version 3 of the License.
767
6
#
768
7
# This program is distributed in the hope that it will be useful,
769
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
770
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
771
10
# GNU General Public License for more details.
772
11
#
773
12
# You should have received a copy of the GNU General Public License
774
13
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
775
14
776
15
777
16
from .base_task import BaseTask
778
17
from libertine import utils
779
18
780
19
781
20
class AppInfoTask(BaseTask):
782
21
    def __init__(self, container_id, cache, app_id, tasks, config, connection, callback):
783
22
        super().__init__(lock=None, container_id=container_id, config=config, connection=connection, callback=callback)
784
23
        self._cache = cache
785
24
        self._app_id = app_id
786
25
        self._tasks = tasks
787
26
788
27
    def _run(self):
789
28
        app = self._cache.app_info(self._app_id)
790
29
        if app == {}:
791
30
            self._progress.error("Could not find app info for '%s' in container '%s'" % (self._app_id, self._container))
792
31
            return
793
32
794
33
        app['status'] = self._config.get_package_install_status(self._container, app['package']) or ''
795
34
        app['task_ids'] = self._tasks
796
35
        self._progress.data(str(app))
797
0
36
798
=== added file 'python/libertine/service/tasks/base_task.py'
799
--- python/libertine/service/tasks/base_task.py	1970-01-01 00:00:00 +0000
800
+++ python/libertine/service/tasks/base_task.py	2016-11-16 17:34:14 +0000
801
@@ -0,0 +1,94 @@
802
1
# Copyright 2016 Canonical Ltd.
803
2
#
804
3
# This program is free software: you can redistribute it and/or modify
805
4
# it under the terms of the GNU General Public License as published by
806
5
# the Free Software Foundation; version 3 of the License.
807
6
#
808
7
# This program is distributed in the hope that it will be useful,
809
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
810
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
811
10
# GNU General Public License for more details.
812
11
#
813
12
# You should have received a copy of the GNU General Public License
814
13
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
815
14
816
15
import libertine.service.progress
817
16
import threading
818
17
from abc import ABCMeta, abstractmethod
819
18
from libertine import utils
820
19
821
20
822
21
class BaseTask(metaclass=ABCMeta):
823
22
    """
824
23
    Abstract class for performing long-running, synchronous operations on a
825
24
    Libertine container. Child classes must implement _run, which will execute
826
25
    in a separate thread. Override _before to implement pre-execution actions
827
26
    without locking; if _before returns False, _run will not be executed.
828
27
    """
829
28
    def __init__(self, lock, container_id, config, connection, callback):
830
29
        self._lock = lock
831
30
        self._container = container_id
832
31
        self._config = config
833
32
        self._callback = callback
834
33
        self._connection = connection
835
34
        self._progress = None
836
35
        self._instant_callback = False
837
36
838
37
    def matches(self, container, klass):
839
38
        return self._container == container and self.__class__ == klass
840
39
841
40
    @property
842
41
    def id(self):
843
42
        if self._progress is not None:
844
43
            return self._progress.id
845
44
        else:
846
45
            return None
847
46
848
47
    @property
849
48
    def container(self):
850
49
        return self._container or ''
851
50
852
51
    @property
853
52
    def package(self):
854
53
        return ''
855
54
856
55
    @property
857
56
    def running(self):
858
57
        return not self._progress.done
859
58
860
59
    def _delayed_callback(self):
861
60
        if self._instant_callback:
862
61
            self._callback(self)
863
62
        else:
864
63
            threading.Timer(30, lambda: self._callback(self)).start()
865
64
866
65
    def start(self):
867
66
        self._progress = libertine.service.progress.Progress(self._connection)
868
67
        thread = threading.Thread(target=self.run)
869
68
        thread.start()
870
69
        return thread
871
70
872
71
    def run(self):
873
72
        if not self._before():
874
73
            self._progress.finished(self.container)
875
74
            self._delayed_callback()
876
75
            return
877
76
878
77
        if self._lock is not None:
879
78
            with self._lock:
880
79
                self._run()
881
80
        else:
882
81
            self._run()
883
82
884
83
        if self.running:
885
84
            self._progress.finished(self.container)
886
85
            utils.refresh_libertine_scope()
887
86
888
87
        self._delayed_callback()
889
88
890
89
    @abstractmethod
891
90
    def _run(self):
892
91
        pass
893
92
894
93
    def _before(self):
895
94
        return True
896
0
95
897
=== added file 'python/libertine/service/tasks/container_info_task.py'
898
--- python/libertine/service/tasks/container_info_task.py	1970-01-01 00:00:00 +0000
899
+++ python/libertine/service/tasks/container_info_task.py	2016-11-16 17:34:14 +0000
900
@@ -0,0 +1,29 @@
901
1
# Copyright 2016 Canonical Ltd.
902
2
#
903
3
# This program is free software: you can redistribute it and/or modify
904
4
# it under the terms of the GNU General Public License as published by
905
5
# the Free Software Foundation; version 3 of the License.
906
6
#
907
7
# This program is distributed in the hope that it will be useful,
908
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
909
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
910
10
# GNU General Public License for more details.
911
11
#
912
12
# You should have received a copy of the GNU General Public License
913
13
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
914
14
915
15
916
16
from .base_task import BaseTask
917
17
from libertine import utils
918
18
919
19
920
20
class ContainerInfoTask(BaseTask):
921
21
    def __init__(self, container_id, tasks, config, connection, callback):
922
22
        super().__init__(lock=None, container_id=container_id, config=config, connection=connection, callback=callback)
923
23
        self._tasks = tasks
924
24
925
25
    def _run(self):
926
26
        container = {'id': str(self._container)}
927
27
        container['status'] = self._config._get_value_by_key(self._container, 'installStatus') or ''
928
28
        container['task_ids'] = self._tasks
929
29
        self._progress.data(str(container))
930
0
30
931
=== added file 'python/libertine/service/tasks/create_task.py'
932
--- python/libertine/service/tasks/create_task.py	1970-01-01 00:00:00 +0000
933
+++ python/libertine/service/tasks/create_task.py	2016-11-16 17:34:14 +0000
934
@@ -0,0 +1,72 @@
935
1
# Copyright 2016 Canonical Ltd.
936
2
#
937
3
# This program is free software: you can redistribute it and/or modify
938
4
# it under the terms of the GNU General Public License as published by
939
5
# the Free Software Foundation; version 3 of the License.
940
6
#
941
7
# This program is distributed in the hope that it will be useful,
942
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
943
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
944
10
# GNU General Public License for more details.
945
11
#
946
12
# You should have received a copy of the GNU General Public License
947
13
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
948
14
949
15
950
16
from .base_task import BaseTask
951
17
from libertine import LibertineContainer, utils
952
18
from libertine.HostInfo import HostInfo
953
19
954
20
955
21
class CreateTask(BaseTask):
956
22
    def __init__(self, container_id, container_name, distro, container_type, enable_multiarch, config, lock, connection, callback):
957
23
        super().__init__(lock=lock, container_id=container_id, config=config, connection=connection, callback=callback)
958
24
        self._name = container_name
959
25
        self._distro = distro
960
26
        self._type = container_type
961
27
        self._multiarch = enable_multiarch
962
28
963
29
    def _run(self):
964
30
        utils.get_logger().debug("Creating container '%s'" % self._container)
965
31
966
32
        try:
967
33
            container = LibertineContainer(self._container, self._config)
968
34
969
35
            if not container.create_libertine_container(password='', multiarch=self._multiarch):
970
36
                self._config.delete_container(self._container)
971
37
                self._progress.error("Creating container '%s' failed" % self._container)
972
38
            else:
973
39
                self._config.update_container_install_status(self._container, "ready")
974
40
        except RuntimeError as e:
975
41
            self._progress.error(str(e))
976
42
            self._config.delete_container(self._container)
977
43
978
44
    def _before(self):
979
45
        utils.get_logger().debug("CreateTask::_before")
980
46
        if self._config.container_exists(self._container):
981
47
            self._progress.error("Container '%s' already exists" % self._container)
982
48
            return False
983
49
984
50
        info = HostInfo()
985
51
        if not self._distro:
986
52
            self._distro = info.get_host_distro_release()
987
53
        elif not info.is_distro_valid(self._distro):
988
54
            self._progress.error("Invalid distro '%s'." % self._distro)
989
55
            return False
990
56
991
57
        if not self._type:
992
58
            self._type = info.select_container_type_by_kernel()
993
59
        elif self._type == 'lxc' and not info.has_lxc_support():
994
60
            self._progress.error("System kernel does not support lxc type containers. Please either use chroot or leave empty.")
995
61
            return False
996
62
997
63
        if not self._name:
998
64
            self._name = "Ubuntu \'" + info.get_distro_codename(self._distro) + "\'"
999
65
1000
66
        self._config.add_new_container(self._container, self._name, self._type, self._distro)
1001
67
1002
68
        if self._multiarch:
1003
69
            self._config.update_container_multiarch_support(self._container, 'enabled')
1004
70
1005
71
        self._config.update_container_install_status(self._container, 'installing')
1006
72
        return True
1007
0
73
1008
=== added file 'python/libertine/service/tasks/destroy_task.py'
1009
--- python/libertine/service/tasks/destroy_task.py	1970-01-01 00:00:00 +0000
1010
+++ python/libertine/service/tasks/destroy_task.py	2016-11-16 17:34:14 +0000
1011
@@ -0,0 +1,42 @@
1012
1
# Copyright 2016 Canonical Ltd.
1013
2
#
1014
3
# This program is free software: you can redistribute it and/or modify
1015
4
# it under the terms of the GNU General Public License as published by
1016
5
# the Free Software Foundation; version 3 of the License.
1017
6
#
1018
7
# This program is distributed in the hope that it will be useful,
1019
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1020
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1021
10
# GNU General Public License for more details.
1022
11
#
1023
12
# You should have received a copy of the GNU General Public License
1024
13
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
1025
14
1026
15
1027
16
from .base_task import BaseTask
1028
17
from libertine import LibertineContainer, utils
1029
18
1030
19
1031
20
class DestroyTask(BaseTask):
1032
21
    def __init__(self, container_id, config, lock, connection, callback):
1033
22
        super().__init__(lock=lock, container_id=container_id, config=config, connection=connection, callback=callback)
1034
23
1035
24
    def _run(self):
1036
25
        utils.get_logger().debug("Destroying container '%s'" % self._container)
1037
26
1038
27
        container = LibertineContainer(self._container, self._config)
1039
28
        if not container.destroy_libertine_container():
1040
29
            self._progress.error("Destroying container '%s' failed" % self._container)
1041
30
            self._config.update_container_install_status(self._container, "ready")
1042
31
            return
1043
32
1044
33
        self._config.delete_container(self._container)
1045
34
1046
35
    def _before(self):
1047
36
        utils.get_logger().debug("CreateTask::_before")
1048
37
        if self._config._get_value_by_key(self._container, 'installStatus') != 'ready':
1049
38
            self._progress.error("Container '%s' does not exist" % self._container)
1050
39
            return False
1051
40
1052
41
        self._config.update_container_install_status(self._container, 'removing')
1053
42
        return True
1054
0
43
1055
=== added file 'python/libertine/service/tasks/install_task.py'
1056
--- python/libertine/service/tasks/install_task.py	1970-01-01 00:00:00 +0000
1057
+++ python/libertine/service/tasks/install_task.py	2016-11-16 17:34:14 +0000
1058
@@ -0,0 +1,49 @@
1059
1
# Copyright 2016 Canonical Ltd.
1060
2
#
1061
3
# This program is free software: you can redistribute it and/or modify
1062
4
# it under the terms of the GNU General Public License as published by
1063
5
# the Free Software Foundation; version 3 of the License.
1064
6
#
1065
7
# This program is distributed in the hope that it will be useful,
1066
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1067
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1068
10
# GNU General Public License for more details.
1069
11
#
1070
12
# You should have received a copy of the GNU General Public License
1071
13
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
1072
14
1073
15
1074
16
from .base_task import BaseTask
1075
17
from libertine import LibertineContainer, utils
1076
18
1077
19
1078
20
class InstallTask(BaseTask):
1079
21
    def __init__(self, package_name, container_id, config, lock, connection, callback):
1080
22
        super().__init__(lock=lock, container_id=container_id, config=config, connection=connection, callback=callback)
1081
23
        self._package = package_name
1082
24
1083
25
    def matches(self, package, klass):
1084
26
        return self._package == package and self.__class__ == klass
1085
27
1086
28
    @property
1087
29
    def package(self):
1088
30
        return self._package
1089
31
1090
32
    def _run(self):
1091
33
        utils.get_logger().debug("Installing package '%s'" % self._package)
1092
34
        container = LibertineContainer(self._container, self._config)
1093
35
        if container.install_package(self._package):
1094
36
            self._config.update_package_install_status(self._container, self._package, "installed")
1095
37
        else:
1096
38
            self._config.delete_package(self._container, self._package)
1097
39
            self._progress.error("Package installation failed for '%s'" % self._package)
1098
40
1099
41
    def _before(self):
1100
42
        utils.get_logger().debug("InstallTask::_before")
1101
43
        if self._config.package_exists(self._container, self._package):
1102
44
            self._progress.error("Package '%s' already exists, skipping install" % self._package)
1103
45
            return False
1104
46
        else:
1105
47
            self._config.add_new_package(self._container, self._package)
1106
48
            self._config.update_package_install_status(self._container, self._package, "installing")
1107
49
            return True
1108
0
50
1109
=== added file 'python/libertine/service/tasks/list_apps_task.py'
1110
--- python/libertine/service/tasks/list_apps_task.py	1970-01-01 00:00:00 +0000
1111
+++ python/libertine/service/tasks/list_apps_task.py	2016-11-16 17:34:14 +0000
1112
@@ -0,0 +1,30 @@
1113
1
# Copyright 2016 Canonical Ltd.
1114
2
#
1115
3
# This program is free software: you can redistribute it and/or modify
1116
4
# it under the terms of the GNU General Public License as published by
1117
5
# the Free Software Foundation; version 3 of the License.
1118
6
#
1119
7
# This program is distributed in the hope that it will be useful,
1120
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1121
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1122
10
# GNU General Public License for more details.
1123
11
#
1124
12
# You should have received a copy of the GNU General Public License
1125
13
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
1126
14
1127
15
1128
16
from .base_task import BaseTask
1129
17
from libertine import LibertineContainer, utils
1130
18
1131
19
1132
20
class ListAppsTask(BaseTask):
1133
21
    def __init__(self, container_id, config, connection, callback):
1134
22
        super().__init__(lock=None, container_id=container_id, config=config, connection=connection, callback=callback)
1135
23
1136
24
    def _run(self):
1137
25
        utils.get_logger().debug("Listing apps in container '%s'" % self._container)
1138
26
        if not self._config.container_exists(self._container):
1139
27
            self._progress.error("Container '%s' does not exist, skipping list" % self._container)
1140
28
        else:
1141
29
            container = LibertineContainer(self._container, self._config)
1142
30
            self._progress.data(str(container.list_app_launchers(use_json=True)))
1143
0
31
1144
=== added file 'python/libertine/service/tasks/list_task.py'
1145
--- python/libertine/service/tasks/list_task.py	1970-01-01 00:00:00 +0000
1146
+++ python/libertine/service/tasks/list_task.py	2016-11-16 17:34:14 +0000
1147
@@ -0,0 +1,25 @@
1148
1
# Copyright 2016 Canonical Ltd.
1149
2
#
1150
3
# This program is free software: you can redistribute it and/or modify
1151
4
# it under the terms of the GNU General Public License as published by
1152
5
# the Free Software Foundation; version 3 of the License.
1153
6
#
1154
7
# This program is distributed in the hope that it will be useful,
1155
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1156
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1157
10
# GNU General Public License for more details.
1158
11
#
1159
12
# You should have received a copy of the GNU General Public License
1160
13
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
1161
14
1162
15
1163
16
from .base_task import BaseTask
1164
17
from libertine import utils
1165
18
1166
19
1167
20
class ListTask(BaseTask):
1168
21
    def __init__(self, connection, callback):
1169
22
        super().__init__(lock=None, container_id=None, config=None, connection=connection, callback=callback)
1170
23
1171
24
    def _run(self):
1172
25
        self._progress.data(str(utils.Libertine.list_containers()))
1173
0
26
1174
=== added file 'python/libertine/service/tasks/remove_task.py'
1175
--- python/libertine/service/tasks/remove_task.py	1970-01-01 00:00:00 +0000
1176
+++ python/libertine/service/tasks/remove_task.py	2016-11-16 17:34:14 +0000
1177
@@ -0,0 +1,48 @@
1178
1
# Copyright 2016 Canonical Ltd.
1179
2
#
1180
3
# This program is free software: you can redistribute it and/or modify
1181
4
# it under the terms of the GNU General Public License as published by
1182
5
# the Free Software Foundation; version 3 of the License.
1183
6
#
1184
7
# This program is distributed in the hope that it will be useful,
1185
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1186
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1187
10
# GNU General Public License for more details.
1188
11
#
1189
12
# You should have received a copy of the GNU General Public License
1190
13
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
1191
14
1192
15
1193
16
from .base_task import BaseTask
1194
17
from libertine import LibertineContainer, utils
1195
18
1196
19
1197
20
class RemoveTask(BaseTask):
1198
21
    def __init__(self, package_name, container_id, config, lock, connection, callback):
1199
22
        super().__init__(lock=lock, container_id=container_id, config=config, connection=connection, callback=callback)
1200
23
        self._package = package_name
1201
24
1202
25
    def matches(self, package, klass):
1203
26
        return self._package == package and self.__class__ == klass
1204
27
1205
28
    @property
1206
29
    def package(self):
1207
30
        return self._package
1208
31
1209
32
    def _run(self):
1210
33
        utils.get_logger().debug("Removing package '%s'" % self._package)
1211
34
        container = LibertineContainer(self._container, self._config)
1212
35
        if container.remove_package(self._package):
1213
36
            self._config.delete_package(self._container, self._package)
1214
37
        else:
1215
38
            self._config.update_package_install_status(self._container, self._package, 'installed')
1216
39
            self._progress.error("Package removal failed for '%s'" % self._package)
1217
40
1218
41
    def _before(self):
1219
42
        utils.get_logger().debug("RemoveTask::_before")
1220
43
        if self._config.get_package_install_status(self._container, self._package) == 'installed':
1221
44
            self._config.update_package_install_status(self._container, self._package, "removing")
1222
45
            return True
1223
46
        else:
1224
47
            self._progress.error("Package '%s' not installed, skipping remove" % self._package)
1225
48
            return False
1226
0
49
1227
=== added file 'python/libertine/service/tasks/search_task.py'
1228
--- python/libertine/service/tasks/search_task.py	1970-01-01 00:00:00 +0000
1229
+++ python/libertine/service/tasks/search_task.py	2016-11-16 17:34:14 +0000
1230
@@ -0,0 +1,27 @@
1231
1
# Copyright 2016 Canonical Ltd.
1232
2
#
1233
3
# This program is free software: you can redistribute it and/or modify
1234
4
# it under the terms of the GNU General Public License as published by
1235
5
# the Free Software Foundation; version 3 of the License.
1236
6
#
1237
7
# This program is distributed in the hope that it will be useful,
1238
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1239
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1240
10
# GNU General Public License for more details.
1241
11
#
1242
12
# You should have received a copy of the GNU General Public License
1243
13
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
1244
14
1245
15
1246
16
from .base_task import BaseTask
1247
17
from libertine import utils
1248
18
1249
19
1250
20
class SearchTask(BaseTask):
1251
21
    def __init__(self, container_id, cache, query, connection, callback):
1252
22
        super().__init__(lock=None, container_id=container_id, config=None, connection=connection, callback=callback)
1253
23
        self._cache = cache
1254
24
        self._query = query
1255
25
1256
26
    def _run(self):
1257
27
        self._progress.data(str(self._cache.search(self._query)))
1258
0
28
1259
=== added file 'python/libertine/service/tasks/update_task.py'
1260
--- python/libertine/service/tasks/update_task.py	1970-01-01 00:00:00 +0000
1261
+++ python/libertine/service/tasks/update_task.py	2016-11-16 17:34:14 +0000
1262
@@ -0,0 +1,39 @@
1263
1
# Copyright 2016 Canonical Ltd.
1264
2
#
1265
3
# This program is free software: you can redistribute it and/or modify
1266
4
# it under the terms of the GNU General Public License as published by
1267
5
# the Free Software Foundation; version 3 of the License.
1268
6
#
1269
7
# This program is distributed in the hope that it will be useful,
1270
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1271
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1272
10
# GNU General Public License for more details.
1273
11
#
1274
12
# You should have received a copy of the GNU General Public License
1275
13
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
1276
14
1277
15
1278
16
from .base_task import BaseTask
1279
17
from libertine import LibertineContainer, utils
1280
18
1281
19
1282
20
class UpdateTask(BaseTask):
1283
21
    def __init__(self, container_id, config, lock, connection, callback):
1284
22
        super().__init__(lock=lock, container_id=container_id, config=config, connection=connection, callback=callback)
1285
23
1286
24
    def _run(self):
1287
25
        utils.get_logger().debug("Updating container '%s'" % self._container)
1288
26
        container = LibertineContainer(self._container, self._config)
1289
27
        self._config.update_container_install_status(self._container, "updating")
1290
28
        if not container.update_libertine_container():
1291
29
            self._progress.error("Failed to update container '%s'" % self._container)
1292
30
1293
31
        self._config.update_container_install_status(self._container, "ready")
1294
32
1295
33
    def _before(self):
1296
34
        utils.get_logger().debug("UpdateTask::_before")
1297
35
        if not self._config.container_exists(self._container):
1298
36
            self._progress.error("Container '%s' does not exist, skipping update" % self._container)
1299
37
            return False
1300
38
        else:
1301
39
            return True
1302
0
40
1303
=== modified file 'tests/unit/CMakeLists.txt'
1304
--- tests/unit/CMakeLists.txt	2016-09-27 00:55:28 +0000
1305
+++ tests/unit/CMakeLists.txt	2016-11-16 17:34:14 +0000
1306
@@ -30,3 +30,4 @@
1307
30
                     ENVIRONMENT
30
                     ENVIRONMENT
1308
31
                     "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};CMAKE_BINARY_DIR=${CMAKE_BINARY_DIR};PYTHONPATH=${CMAKE_SOURCE_DIR}/python;CMAKE_SOURCE_DIR=${CMAKE_SOURCE_DIR}")
31
                     "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};CMAKE_BINARY_DIR=${CMAKE_BINARY_DIR};PYTHONPATH=${CMAKE_SOURCE_DIR}/python;CMAKE_SOURCE_DIR=${CMAKE_SOURCE_DIR}")
1309
32
32
1310
33
add_subdirectory(service)
1311
33
34
1312
=== added file 'tests/unit/pytest.ini'
1313
--- tests/unit/pytest.ini	1970-01-01 00:00:00 +0000
1314
+++ tests/unit/pytest.ini	2016-11-16 17:34:14 +0000
1315
@@ -0,0 +1,2 @@
1316
1
[pytest]
1317
2
norecursedirs = service
1318
0
3
1319
=== added directory 'tests/unit/service'
1320
=== added file 'tests/unit/service/CMakeLists.txt'
1321
--- tests/unit/service/CMakeLists.txt	1970-01-01 00:00:00 +0000
1322
+++ tests/unit/service/CMakeLists.txt	2016-11-16 17:34:14 +0000
1323
@@ -0,0 +1,12 @@
1324
1
function(create_service_unit_test test_name)
1325
2
  add_test(${test_name} /usr/bin/python3 -m testtools.run ${test_name})
1326
3
  set_tests_properties(${test_name}
1327
4
                       PROPERTIES ENVIRONMENT
1328
5
                       "GI_TYPELIB_PATH=${CMAKE_BINARY_DIR}/liblibertine;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/liblibertine:${LD_LIBRARY_PATH};PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}:${CMAKE_SOURCE_DIR}/python;LIBERTINE_DATA_DIR=${CMAKE_CURRENT_SOURCE_DIR}")
1329
6
endfunction(create_service_unit_test)
1330
7
1331
8
create_service_unit_test(test_container)
1332
9
create_service_unit_test(test_apt)
1333
10
create_service_unit_test(test_task_dispatcher)
1334
11
1335
12
add_subdirectory(tasks)
1336
0
13
1337
=== added directory 'tests/unit/service/containerroot'
1338
=== added directory 'tests/unit/service/containerroot/var'
1339
=== added directory 'tests/unit/service/containerroot/var/cache'
1340
=== added directory 'tests/unit/service/containerroot/var/cache/app-info'
1341
=== added directory 'tests/unit/service/containerroot/var/cache/app-info/gv'
1342
=== added file 'tests/unit/service/containerroot/var/cache/app-info/gv/en_US.gvz'
1343
=== added directory 'tests/unit/service/tasks'
1344
=== added file 'tests/unit/service/tasks/CMakeLists.txt'
1345
--- tests/unit/service/tasks/CMakeLists.txt	1970-01-01 00:00:00 +0000
1346
+++ tests/unit/service/tasks/CMakeLists.txt	2016-11-16 17:34:14 +0000
1347
@@ -0,0 +1,10 @@
1348
1
create_service_unit_test(test_app_info_task)
1349
2
create_service_unit_test(test_container_info_task)
1350
3
create_service_unit_test(test_create_task)
1351
4
create_service_unit_test(test_destroy_task)
1352
5
create_service_unit_test(test_install_task)
1353
6
create_service_unit_test(test_list_task)
1354
7
create_service_unit_test(test_list_apps_task)
1355
8
create_service_unit_test(test_remove_task)
1356
9
create_service_unit_test(test_search_task)
1357
10
create_service_unit_test(test_update_task)
1358
0
11
1359
=== added file 'tests/unit/service/tasks/test_app_info_task.py'
1360
--- tests/unit/service/tasks/test_app_info_task.py	1970-01-01 00:00:00 +0000
1361
+++ tests/unit/service/tasks/test_app_info_task.py	2016-11-16 17:34:14 +0000
1362
@@ -0,0 +1,61 @@
1363
1
# Copyright 2016 Canonical Ltd.
1364
2
#
1365
3
# This program is free software: you can redistribute it and/or modify it
1366
4
# under the terms of the GNU General Public License version 3, as published
1367
5
# by the Free Software Foundation.
1368
6
#
1369
7
# This program is distributed in the hope that it will be useful, but
1370
8
# WITHOUT ANY WARRANTY; without even the implied warranties of
1371
9
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
1372
10
# PURPOSE.  See the GNU General Public License for more details.
1373
11
#
1374
12
# You should have received a copy of the GNU General Public License along
1375
13
# with this program.  If not, see <http://www.gnu.org/licenses/>.
1376
14
1377
15
1378
16
import unittest.mock
1379
17
from unittest import TestCase
1380
18
from libertine.service import tasks, apt
1381
19
from libertine.ContainersConfig import ContainersConfig
1382
20
1383
21
1384
22
class TestAppInfoTask(TestCase):
1385
23
    def setUp(self):
1386
24
        self.config     = unittest.mock.create_autospec(ContainersConfig)
1387
25
        self.cache      = unittest.mock.create_autospec(apt.AptCache)
1388
26
        self.connection = unittest.mock.Mock()
1389
27
1390
28
    def test_app_not_found_causes_error(self):
1391
29
        self.called_with = None
1392
30
        def callback(t):
1393
31
            self.called_with = t
1394
32
1395
33
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1396
34
            progress = MockProgress.return_value
1397
35
            self.cache.app_info.return_value = {}
1398
36
            task = tasks.AppInfoTask('palpatine', self.cache, 'lightside', [1, 2], self.config, self.connection, callback)
1399
37
            task._instant_callback = True
1400
38
            task.start().join()
1401
39
1402
40
            progress.error.assert_called_once_with('Could not find app info for \'lightside\' in container \'palpatine\'')
1403
41
1404
42
            self.assertEqual(task, self.called_with)
1405
43
1406
44
    def test_success_sends_data(self):
1407
45
        self.called_with = None
1408
46
        def callback(t):
1409
47
            self.called_with = t
1410
48
1411
49
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1412
50
            progress = MockProgress.return_value
1413
51
            progress.done = False
1414
52
1415
53
            self.cache.app_info.return_value = {'package': 'darkside-common'}
1416
54
            self.config.get_package_install_status.return_value = 'installed'
1417
55
            task = tasks.AppInfoTask('palpatine', self.cache, 'darkside', [1, 2, 3], self.config, self.connection, callback)
1418
56
            task._instant_callback = True
1419
57
            task.start().join()
1420
58
1421
59
            progress.data.assert_called_once_with(str({'package': 'darkside-common', 'status': 'installed', 'task_ids': [1, 2, 3]}))
1422
60
1423
61
            self.assertEqual(task, self.called_with)
1424
0
62
1425
=== added file 'tests/unit/service/tasks/test_container_info_task.py'
1426
--- tests/unit/service/tasks/test_container_info_task.py	1970-01-01 00:00:00 +0000
1427
+++ tests/unit/service/tasks/test_container_info_task.py	2016-11-16 17:34:14 +0000
1428
@@ -0,0 +1,44 @@
1429
1
# Copyright 2016 Canonical Ltd.
1430
2
#
1431
3
# This program is free software: you can redistribute it and/or modify it
1432
4
# under the terms of the GNU General Public License version 3, as published
1433
5
# by the Free Software Foundation.
1434
6
#
1435
7
# This program is distributed in the hope that it will be useful, but
1436
8
# WITHOUT ANY WARRANTY; without even the implied warranties of
1437
9
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
1438
10
# PURPOSE.  See the GNU General Public License for more details.
1439
11
#
1440
12
# You should have received a copy of the GNU General Public License along
1441
13
# with this program.  If not, see <http://www.gnu.org/licenses/>.
1442
14
1443
15
1444
16
import unittest.mock
1445
17
from unittest import TestCase
1446
18
from libertine.service import tasks
1447
19
from libertine.ContainersConfig import ContainersConfig
1448
20
1449
21
1450
22
class TestContainerInfoTask(TestCase):
1451
23
    def setUp(self):
1452
24
        self.config     = unittest.mock.create_autospec(ContainersConfig)
1453
25
        self.connection = unittest.mock.Mock()
1454
26
1455
27
    def test_success_sends_data(self):
1456
28
        self.called_with = None
1457
29
        def callback(t):
1458
30
            self.called_with = t
1459
31
1460
32
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1461
33
            progress = MockProgress.return_value
1462
34
            progress.done = False
1463
35
1464
36
            self.config._get_value_by_key.return_value = 'ready'
1465
37
            task = tasks.ContainerInfoTask('palpatine', [1, 2, 3], self.config, self.connection, callback)
1466
38
            task._instant_callback = True
1467
39
            task.start().join()
1468
40
1469
41
            progress.data.assert_called_once_with(str({'id': 'palpatine', 'status': 'ready', 'task_ids': [1, 2, 3]}))
1470
42
            progress.finished.assert_called_once_with('palpatine')
1471
43
1472
44
            self.assertEqual(task, self.called_with)
1473
0
45
1474
=== added file 'tests/unit/service/tasks/test_create_task.py'
1475
--- tests/unit/service/tasks/test_create_task.py	1970-01-01 00:00:00 +0000
1476
+++ tests/unit/service/tasks/test_create_task.py	2016-11-16 17:34:14 +0000
1477
@@ -0,0 +1,234 @@
1478
1
# Copyright 2016 Canonical Ltd.
1479
2
#
1480
3
# This program is free software: you can redistribute it and/or modify it
1481
4
# under the terms of the GNU General Public License version 3, as published
1482
5
# by the Free Software Foundation.
1483
6
#
1484
7
# This program is distributed in the hope that it will be useful, but
1485
8
# WITHOUT ANY WARRANTY; without even the implied warranties of
1486
9
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
1487
10
# PURPOSE.  See the GNU General Public License for more details.
1488
11
#
1489
12
# You should have received a copy of the GNU General Public License along
1490
13
# with this program.  If not, see <http://www.gnu.org/licenses/>.
1491
14
1492
15
1493
16
import unittest.mock
1494
17
from unittest import TestCase
1495
18
from libertine.service import tasks
1496
19
from libertine.ContainersConfig import ContainersConfig
1497
20
1498
21
1499
22
class TestCreateTask(TestCase):
1500
23
    def setUp(self):
1501
24
        self.config      = unittest.mock.create_autospec(ContainersConfig)
1502
25
        self.connection  = unittest.mock.Mock()
1503
26
        self.lock      = unittest.mock.MagicMock()
1504
27
        self.called_with = None
1505
28
1506
29
    def callback(self, task):
1507
30
        self.called_with = task
1508
31
1509
32
    def test_success_creates_lxc_container(self):
1510
33
        self.config.container_exists.return_value = False
1511
34
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1512
35
            progress = MockProgress.return_value
1513
36
            progress.done = False
1514
37
            task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'zesty', 'lxc', False, self.config, self.lock, self.connection, self.callback)
1515
38
            task._instant_callback = True
1516
39
1517
40
            with unittest.mock.patch('libertine.service.tasks.create_task.HostInfo') as MockHostInfo:
1518
41
                MockHostInfo.return_value.is_distro_valid.return_value = True
1519
42
                MockHostInfo.return_value.has_lxc_support.return_value = True
1520
43
1521
44
                with unittest.mock.patch('libertine.service.tasks.create_task.LibertineContainer') as MockContainer:
1522
45
                    MockContainer.return_value.create_libertine_container.return_value = True
1523
46
                    task.start().join()
1524
47
1525
48
            progress.finished.assert_called_once_with('palpatine')
1526
49
            self.config.add_new_container.assert_called_once_with('palpatine', 'Emperor Palpatine', 'lxc', 'zesty')
1527
50
            self.config.update_container_install_status.assert_has_calls([
1528
51
                unittest.mock.call('palpatine', 'installing'),
1529
52
                unittest.mock.call('palpatine', 'ready')
1530
53
            ], any_order=True)
1531
54
            self.assertEqual(task, self.called_with)
1532
55
1533
56
    def test_success_creates_chroot_container(self):
1534
57
        self.config.container_exists.return_value = False
1535
58
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1536
59
            progress = MockProgress.return_value
1537
60
            progress.done = False
1538
61
            task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'zesty', 'chroot', False, self.config, self.lock, self.connection, self.callback)
1539
62
            task._instant_callback = True
1540
63
1541
64
            with unittest.mock.patch('libertine.service.tasks.create_task.HostInfo') as MockHostInfo:
1542
65
                MockHostInfo.return_value.is_distro_valid.return_value = True
1543
66
1544
67
                with unittest.mock.patch('libertine.service.tasks.create_task.LibertineContainer') as MockContainer:
1545
68
                    MockContainer.return_value.create_libertine_container.return_value = True
1546
69
                    task.start().join()
1547
70
1548
71
            progress.finished.assert_called_once_with('palpatine')
1549
72
            self.config.add_new_container.assert_called_once_with('palpatine', 'Emperor Palpatine', 'chroot', 'zesty')
1550
73
            self.config.update_container_install_status.assert_has_calls([
1551
74
                unittest.mock.call('palpatine', 'installing'),
1552
75
                unittest.mock.call('palpatine', 'ready')
1553
76
            ], any_order=True)
1554
77
            self.assertEqual(task, self.called_with)
1555
78
1556
79
    def test_container_runtime_error_sends_error(self):
1557
80
        self.config.container_exists.return_value = False
1558
81
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1559
82
            progress = MockProgress.return_value
1560
83
            task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'zesty', 'lxc', False, self.config, self.lock, self.connection, self.callback)
1561
84
            task._instant_callback = True
1562
85
1563
86
            with unittest.mock.patch('libertine.service.tasks.create_task.HostInfo') as MockHostInfo:
1564
87
                MockHostInfo.return_value.is_distro_valid.return_value = True
1565
88
                MockHostInfo.return_value.has_lxc_support.return_value = True
1566
89
1567
90
                with unittest.mock.patch('libertine.service.tasks.create_task.LibertineContainer') as MockContainer:
1568
91
                    MockContainer.return_value.create_libertine_container.side_effect = RuntimeError('a great disturbance')
1569
92
                    task.start().join()
1570
93
1571
94
            progress.error.assert_called_once_with('a great disturbance')
1572
95
1573
96
            self.config.add_new_container.assert_called_once_with('palpatine', 'Emperor Palpatine', 'lxc', 'zesty')
1574
97
            self.config.update_container_install_status.assert_called_once_with('palpatine', 'installing')
1575
98
            self.config.delete_container.assert_called_once_with('palpatine')
1576
99
1577
100
            self.assertEqual(task, self.called_with)
1578
101
1579
102
    def test_failed_container_exists_sends_error(self):
1580
103
        self.config.container_exists.return_value = True
1581
104
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1582
105
            progress = MockProgress.return_value
1583
106
            task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'zesty', 'lxc', False, self.config, self.lock, self.connection, self.callback)
1584
107
            task._instant_callback = True
1585
108
            task.start().join()
1586
109
1587
110
            progress.error.assert_called_once_with('Container \'palpatine\' already exists')
1588
111
            self.assertEqual(task, self.called_with)
1589
112
1590
113
    def test_container_invalid_distro_error_sends_error(self):
1591
114
        self.config.container_exists.return_value = False
1592
115
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1593
116
            progress = MockProgress.return_value
1594
117
            with unittest.mock.patch('libertine.service.tasks.create_task.HostInfo') as MockHostInfo:
1595
118
                MockHostInfo.return_value.is_distro_valid.return_value = False
1596
119
                task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'vesty', 'lxc', False, self.config, self.lock, self.connection, self.callback)
1597
120
                task._instant_callback = True
1598
121
                task.start().join()
1599
122
1600
123
            progress.error.assert_called_once_with('Invalid distro \'vesty\'.')
1601
124
            self.assertEqual(task, self.called_with)
1602
125
1603
126
    def test_container_improper_lxc_error_sends_error(self):
1604
127
        self.config.container_exists.return_value = False
1605
128
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1606
129
            progress = MockProgress.return_value
1607
130
            with unittest.mock.patch('libertine.service.tasks.create_task.HostInfo') as MockHostInfo:
1608
131
                MockHostInfo.return_value.is_distro_valid.return_value = True
1609
132
                MockHostInfo.return_value.has_lxc_support.return_value = False
1610
133
                task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'zesty', 'lxc', False, self.config, self.lock, self.connection, self.callback)
1611
134
                task._instant_callback = True
1612
135
                task.start().join()
1613
136
1614
137
            progress.error.assert_called_once_with('System kernel does not support lxc type containers. Please either use chroot or leave empty.')
1615
138
            self.assertEqual(task, self.called_with)
1616
139
1617
140
    def test_sets_generic_name_when_empty(self):
1618
141
        self.config.container_exists.return_value = False
1619
142
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1620
143
            progress = MockProgress.return_value
1621
144
            progress.done = False
1622
145
            task = tasks.CreateTask('palpatine', None, 'zesty', 'chroot', False, self.config, self.lock, self.connection, self.callback)
1623
146
            task._instant_callback = True
1624
147
1625
148
            with unittest.mock.patch('libertine.service.tasks.create_task.HostInfo') as MockHostInfo:
1626
149
                MockHostInfo.return_value.is_distro_valid.return_value = True
1627
150
                MockHostInfo.return_value.get_distro_codename.return_value = 'Zesty Zapus 17.04'
1628
151
1629
152
                with unittest.mock.patch('libertine.service.tasks.create_task.LibertineContainer') as MockContainer:
1630
153
                    MockContainer.return_value.create_libertine_container.return_value = True
1631
154
                    task.start().join()
1632
155
1633
156
            progress.finished.assert_called_once_with('palpatine')
1634
157
            self.config.add_new_container.assert_called_once_with('palpatine', 'Ubuntu \'Zesty Zapus 17.04\'', 'chroot', 'zesty')
1635
158
            self.config.update_container_install_status.assert_has_calls([
1636
159
                unittest.mock.call('palpatine', 'installing'),
1637
160
                unittest.mock.call('palpatine', 'ready')
1638
161
            ], any_order=True)
1639
162
            self.assertEqual(task, self.called_with)
1640
163
1641
164
    def test_sets_multiarch(self):
1642
165
        self.config.container_exists.return_value = False
1643
166
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1644
167
            progress = MockProgress.return_value
1645
168
            progress.done = False
1646
169
            task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'zesty', 'chroot', True, self.config, self.lock, self.connection, self.callback)
1647
170
            task._instant_callback = True
1648
171
1649
172
            with unittest.mock.patch('libertine.service.tasks.create_task.HostInfo') as MockHostInfo:
1650
173
                MockHostInfo.return_value.is_distro_valid.return_value = True
1651
174
1652
175
                with unittest.mock.patch('libertine.service.tasks.create_task.LibertineContainer') as MockContainer:
1653
176
                    MockContainer.return_value.create_libertine_container.return_value = True
1654
177
                    task.start().join()
1655
178
1656
179
            progress.finished.assert_called_once_with('palpatine')
1657
180
            self.config.add_new_container.assert_called_once_with('palpatine', 'Emperor Palpatine', 'chroot', 'zesty')
1658
181
            self.config.update_container_multiarch_support.assert_called_once_with('palpatine', 'enabled')
1659
182
            self.config.update_container_install_status.assert_has_calls([
1660
183
                unittest.mock.call('palpatine', 'installing'),
1661
184
                unittest.mock.call('palpatine', 'ready')
1662
185
            ], any_order=True)
1663
186
            self.assertEqual(task, self.called_with)
1664
187
1665
188
    def test_sets_default_type(self):
1666
189
        self.config.container_exists.return_value = False
1667
190
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1668
191
            progress = MockProgress.return_value
1669
192
            progress.done = False
1670
193
            task = tasks.CreateTask('palpatine', 'Emperor Palpatine', 'zesty', None, False, self.config, self.lock, self.connection, self.callback)
1671
194
            task._instant_callback = True
1672
195
1673
196
            with unittest.mock.patch('libertine.service.tasks.create_task.HostInfo') as MockHostInfo:
1674
197
                MockHostInfo.return_value.is_distro_valid.return_value = True
1675
198
                MockHostInfo.return_value.select_container_type_by_kernel.return_value = 'lxc'
1676
199
1677
200
                with unittest.mock.patch('libertine.service.tasks.create_task.LibertineContainer') as MockContainer:
1678
201
                    MockContainer.return_value.create_libertine_container.return_value = True
1679
202
                    task.start().join()
1680
203
1681
204
            progress.finished.assert_called_once_with('palpatine')
1682
205
            self.config.add_new_container.assert_called_once_with('palpatine', 'Emperor Palpatine', 'lxc', 'zesty')
1683
206
            self.config.update_container_install_status.assert_has_calls([
1684
207
                unittest.mock.call('palpatine', 'installing'),
1685
208
                unittest.mock.call('palpatine', 'ready')
1686
209
            ], any_order=True)
1687
210
            self.assertEqual(task, self.called_with)
1688
211
1689
212
    def test_sets_default_distro(self):
1690
213
        self.config.container_exists.return_value = False
1691
214
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1692
215
            progress = MockProgress.return_value
1693
216
            progress.done = False
1694
217
            task = tasks.CreateTask('palpatine', 'Emperor Palpatine', None, 'lxc', False, self.config, self.lock, self.connection, self.callback)
1695
218
            task._instant_callback = True
1696
219
1697
220
            with unittest.mock.patch('libertine.service.tasks.create_task.HostInfo') as MockHostInfo:
1698
221
                MockHostInfo.return_value.has_lxc_support.return_value = True
1699
222
                MockHostInfo.return_value.get_host_distro_release.return_value = 'zesty'
1700
223
1701
224
                with unittest.mock.patch('libertine.service.tasks.create_task.LibertineContainer') as MockContainer:
1702
225
                    MockContainer.return_value.create_libertine_container.return_value = True
1703
226
                    task.start().join()
1704
227
1705
228
            progress.finished.assert_called_once_with('palpatine')
1706
229
            self.config.add_new_container.assert_called_once_with('palpatine', 'Emperor Palpatine', 'lxc', 'zesty')
1707
230
            self.config.update_container_install_status.assert_has_calls([
1708
231
                unittest.mock.call('palpatine', 'installing'),
1709
232
                unittest.mock.call('palpatine', 'ready')
1710
233
            ], any_order=True)
1711
234
            self.assertEqual(task, self.called_with)
1712
0
235
1713
=== added file 'tests/unit/service/tasks/test_destroy_task.py'
1714
--- tests/unit/service/tasks/test_destroy_task.py	1970-01-01 00:00:00 +0000
1715
+++ tests/unit/service/tasks/test_destroy_task.py	2016-11-16 17:34:14 +0000
1716
@@ -0,0 +1,80 @@
1717
1
# Copyright 2016 Canonical Ltd.
1718
2
#
1719
3
# This program is free software: you can redistribute it and/or modify it
1720
4
# under the terms of the GNU General Public License version 3, as published
1721
5
# by the Free Software Foundation.
1722
6
#
1723
7
# This program is distributed in the hope that it will be useful, but
1724
8
# WITHOUT ANY WARRANTY; without even the implied warranties of
1725
9
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
1726
10
# PURPOSE.  See the GNU General Public License for more details.
1727
11
#
1728
12
# You should have received a copy of the GNU General Public License along
1729
13
# with this program.  If not, see <http://www.gnu.org/licenses/>.
1730
14
1731
15
1732
16
import unittest.mock
1733
17
from unittest import TestCase
1734
18
from libertine.service import tasks
1735
19
from libertine.ContainersConfig import ContainersConfig
1736
20
1737
21
1738
22
class TestDestroyTask(TestCase):
1739
23
    def setUp(self):
1740
24
        self.config      = unittest.mock.create_autospec(ContainersConfig)
1741
25
        self.connection  = unittest.mock.Mock()
1742
26
        self.lock      = unittest.mock.MagicMock()
1743
27
        self.called_with = None
1744
28
1745
29
    def callback(self, task):
1746
30
        self.called_with = task
1747
31
1748
32
    def test_sends_error_on_non_ready_container(self):
1749
33
        self.config._get_value_by_key.return_value = ''
1750
34
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1751
35
            progress = MockProgress.return_value
1752
36
            progress.done = False
1753
37
            task = tasks.DestroyTask('palpatine', self.config, self.lock, self.connection, self.callback)
1754
38
            task._instant_callback = True
1755
39
1756
40
            with unittest.mock.patch('libertine.service.tasks.destroy_task.LibertineContainer') as MockContainer:
1757
41
                MockContainer.return_value.destroy_libertine_container.return_value = True
1758
42
                task.start().join()
1759
43
1760
44
            progress.error.assert_called_once_with('Container \'palpatine\' does not exist')
1761
45
            self.assertEqual(task, self.called_with)
1762
46
1763
47
    def test_sends_error_on_failed_destroy(self):
1764
48
        self.config._get_value_by_key.return_value = 'ready'
1765
49
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1766
50
            progress = MockProgress.return_value
1767
51
            task = tasks.DestroyTask('palpatine', self.config, self.lock, self.connection, self.callback)
1768
52
            task._instant_callback = True
1769
53
1770
54
            with unittest.mock.patch('libertine.service.tasks.destroy_task.LibertineContainer') as MockContainer:
1771
55
                MockContainer.return_value.destroy_libertine_container.return_value = False
1772
56
                task.start().join()
1773
57
1774
58
            progress.error.assert_called_once_with('Destroying container \'palpatine\' failed')
1775
59
            self.config.update_container_install_status.assert_has_calls([
1776
60
                unittest.mock.call('palpatine', 'removing'),
1777
61
                unittest.mock.call('palpatine', 'ready')
1778
62
            ], any_order=True)
1779
63
            self.assertEqual(task, self.called_with)
1780
64
1781
65
    def test_successfully_destroys(self):
1782
66
        self.config._get_value_by_key.return_value = 'ready'
1783
67
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1784
68
            progress = MockProgress.return_value
1785
69
            progress.done = False
1786
70
            task = tasks.DestroyTask('palpatine', self.config, self.lock, self.connection, self.callback)
1787
71
            task._instant_callback = True
1788
72
1789
73
            with unittest.mock.patch('libertine.service.tasks.destroy_task.LibertineContainer') as MockContainer:
1790
74
                MockContainer.return_value.destroy_libertine_container.return_value = True
1791
75
                task.start().join()
1792
76
1793
77
            progress.finished.assert_called_once_with('palpatine')
1794
78
            self.config.update_container_install_status.assert_called_once_with('palpatine', 'removing')
1795
79
            self.config.delete_container.assert_called_once_with('palpatine')
1796
80
            self.assertEqual(task, self.called_with)
1797
0
81
1798
=== added file 'tests/unit/service/tasks/test_install_task.py'
1799
--- tests/unit/service/tasks/test_install_task.py	1970-01-01 00:00:00 +0000
1800
+++ tests/unit/service/tasks/test_install_task.py	2016-11-16 17:34:14 +0000
1801
@@ -0,0 +1,76 @@
1802
1
# Copyright 2016 Canonical Ltd.
1803
2
#
1804
3
# This program is free software: you can redistribute it and/or modify it
1805
4
# under the terms of the GNU General Public License version 3, as published
1806
5
# by the Free Software Foundation.
1807
6
#
1808
7
# This program is distributed in the hope that it will be useful, but
1809
8
# WITHOUT ANY WARRANTY; without even the implied warranties of
1810
9
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
1811
10
# PURPOSE.  See the GNU General Public License for more details.
1812
11
#
1813
12
# You should have received a copy of the GNU General Public License along
1814
13
# with this program.  If not, see <http://www.gnu.org/licenses/>.
1815
14
1816
15
1817
16
import unittest.mock
1818
17
from unittest import TestCase
1819
18
from libertine.service import tasks
1820
19
from libertine.ContainersConfig import ContainersConfig
1821
20
1822
21
1823
22
class TestInstallTask(TestCase):
1824
23
    def setUp(self):
1825
24
        self.config      = unittest.mock.create_autospec(ContainersConfig)
1826
25
        self.connection  = unittest.mock.Mock()
1827
26
        self.lock        = unittest.mock.MagicMock()
1828
27
        self.called_with = None
1829
28
1830
29
    def callback(self, task):
1831
30
        self.called_with = task
1832
31
1833
32
    def test_sends_error_on_existing_package(self):
1834
33
        self.config.package_exists.return_value = True
1835
34
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1836
35
            progress = MockProgress.return_value
1837
36
            task = tasks.InstallTask('darkside-common', 'palpatine', self.config, self.lock, self.connection, self.callback)
1838
37
            task._instant_callback = True
1839
38
            task.start().join()
1840
39
1841
40
            progress.error.assert_called_once_with('Package \'darkside-common\' already exists, skipping install')
1842
41
            self.assertEqual(task, self.called_with)
1843
42
1844
43
    def test_sends_error_on_failed_install(self):
1845
44
        self.config.package_exists.return_value = False
1846
45
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1847
46
            progress = MockProgress.return_value
1848
47
            task = tasks.InstallTask('darkside-common', 'palpatine', self.config, self.lock, self.connection, self.callback)
1849
48
            task._instant_callback = True
1850
49
1851
50
            with unittest.mock.patch('libertine.service.tasks.install_task.LibertineContainer') as MockContainer:
1852
51
                MockContainer.return_value.install_package.return_value = False
1853
52
                task.start().join()
1854
53
1855
54
            progress.error.assert_called_once_with("Package installation failed for 'darkside-common'")
1856
55
            self.config.update_package_install_status.assert_called_once_with('palpatine', 'darkside-common', 'installing')
1857
56
            self.config.delete_package.assert_called_once_with('palpatine', 'darkside-common')
1858
57
            self.assertEqual(task, self.called_with)
1859
58
1860
59
    def test_successfully_install(self):
1861
60
        self.config.package_exists.return_value = False
1862
61
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1863
62
            progress = MockProgress.return_value
1864
63
            progress.done = False
1865
64
            task = tasks.InstallTask('darkside-common', 'palpatine', self.config, self.lock, self.connection, self.callback)
1866
65
            task._instant_callback = True
1867
66
1868
67
            with unittest.mock.patch('libertine.service.tasks.install_task.LibertineContainer') as MockContainer:
1869
68
                MockContainer.return_value.install_package.return_value = True
1870
69
                task.start().join()
1871
70
1872
71
            progress.finished.assert_called_once_with('palpatine')
1873
72
            self.config.update_package_install_status.assert_has_calls([
1874
73
                unittest.mock.call('palpatine', 'darkside-common', 'installing'),
1875
74
                unittest.mock.call('palpatine', 'darkside-common', 'installed')
1876
75
            ], any_order=True)
1877
76
            self.assertEqual(task, self.called_with)
1878
0
77
1879
=== added file 'tests/unit/service/tasks/test_list_apps_task.py'
1880
--- tests/unit/service/tasks/test_list_apps_task.py	1970-01-01 00:00:00 +0000
1881
+++ tests/unit/service/tasks/test_list_apps_task.py	2016-11-16 17:34:14 +0000
1882
@@ -0,0 +1,59 @@
1883
1
# Copyright 2016 Canonical Ltd.
1884
2
#
1885
3
# This program is free software: you can redistribute it and/or modify it
1886
4
# under the terms of the GNU General Public License version 3, as published
1887
5
# by the Free Software Foundation.
1888
6
#
1889
7
# This program is distributed in the hope that it will be useful, but
1890
8
# WITHOUT ANY WARRANTY; without even the implied warranties of
1891
9
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
1892
10
# PURPOSE.  See the GNU General Public License for more details.
1893
11
#
1894
12
# You should have received a copy of the GNU General Public License along
1895
13
# with this program.  If not, see <http://www.gnu.org/licenses/>.
1896
14
1897
15
1898
16
import unittest.mock
1899
17
from unittest import TestCase
1900
18
from libertine.service import tasks
1901
19
from libertine.ContainersConfig import ContainersConfig
1902
20
1903
21
1904
22
class TestListAppsTask(TestCase):
1905
23
    def setUp(self):
1906
24
        self.config      = unittest.mock.create_autospec(ContainersConfig)
1907
25
        self.connection  = unittest.mock.Mock()
1908
26
        self.lock      = unittest.mock.MagicMock()
1909
27
        self.called_with = None
1910
28
1911
29
    def callback(self, task):
1912
30
        self.called_with = task
1913
31
1914
32
    def test_sends_error_on_non_existent_container(self):
1915
33
        self.config.container_exists.return_value = False
1916
34
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1917
35
            progress = MockProgress.return_value
1918
36
            task = tasks.ListAppsTask('palpatine', self.config, self.connection, self.callback)
1919
37
            task._instant_callback = True
1920
38
1921
39
            with unittest.mock.patch('libertine.service.tasks.list_apps_task.LibertineContainer') as MockContainer:
1922
40
                task.start().join()
1923
41
1924
42
            progress.error.assert_called_once_with('Container \'palpatine\' does not exist, skipping list')
1925
43
            self.assertEqual(task, self.called_with)
1926
44
1927
45
    def test_successfully_lists_apps(self):
1928
46
        self.config.container_exists.return_value = True
1929
47
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1930
48
            progress = MockProgress.return_value
1931
49
            progress.done = False
1932
50
            task = tasks.ListAppsTask('palpatine', self.config, self.connection, self.callback)
1933
51
            task._instant_callback = True
1934
52
1935
53
            with unittest.mock.patch('libertine.service.tasks.list_apps_task.LibertineContainer') as MockContainer:
1936
54
                MockContainer.return_value.list_app_launchers.return_value = 'jarjar\nsidius'
1937
55
                task.start().join()
1938
56
1939
57
            progress.finished.assert_called_once_with('palpatine')
1940
58
            progress.data.assert_called_once_with('jarjar\nsidius')
1941
59
            self.assertEqual(task, self.called_with)
1942
0
60
1943
=== added file 'tests/unit/service/tasks/test_list_task.py'
1944
--- tests/unit/service/tasks/test_list_task.py	1970-01-01 00:00:00 +0000
1945
+++ tests/unit/service/tasks/test_list_task.py	2016-11-16 17:34:14 +0000
1946
@@ -0,0 +1,45 @@
1947
1
# Copyright 2016 Canonical Ltd.
1948
2
#
1949
3
# This program is free software: you can redistribute it and/or modify it
1950
4
# under the terms of the GNU General Public License version 3, as published
1951
5
# by the Free Software Foundation.
1952
6
#
1953
7
# This program is distributed in the hope that it will be useful, but
1954
8
# WITHOUT ANY WARRANTY; without even the implied warranties of
1955
9
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
1956
10
# PURPOSE.  See the GNU General Public License for more details.
1957
11
#
1958
12
# You should have received a copy of the GNU General Public License along
1959
13
# with this program.  If not, see <http://www.gnu.org/licenses/>.
1960
14
1961
15
1962
16
import unittest.mock
1963
17
from unittest import TestCase
1964
18
from libertine.service import tasks
1965
19
from libertine.ContainersConfig import ContainersConfig
1966
20
1967
21
1968
22
class TestListTask(TestCase):
1969
23
    def setUp(self):
1970
24
        self.config     = unittest.mock.create_autospec(ContainersConfig)
1971
25
        self.connection = unittest.mock.Mock()
1972
26
1973
27
    def test_success_sends_data(self):
1974
28
        self.called_with = None
1975
29
        def callback(t):
1976
30
            self.called_with = t
1977
31
1978
32
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
1979
33
            progress = MockProgress.return_value
1980
34
            progress.done = False
1981
35
            task = tasks.ListTask(self.connection, callback)
1982
36
            task._instant_callback = True
1983
37
1984
38
            with unittest.mock.patch('libertine.service.tasks.list_task.utils.Libertine') as MockLibertine:
1985
39
                MockLibertine.list_containers.return_value = 'palpatine\nvader\nmaul'
1986
40
                task.start().join()
1987
41
1988
42
            progress.data.assert_called_once_with('palpatine\nvader\nmaul')
1989
43
            progress.finished.assert_called_once_with('')
1990
44
1991
45
            self.assertEqual(task, self.called_with)
1992
0
46
1993
=== added file 'tests/unit/service/tasks/test_remove_task.py'
1994
--- tests/unit/service/tasks/test_remove_task.py	1970-01-01 00:00:00 +0000
1995
+++ tests/unit/service/tasks/test_remove_task.py	2016-11-16 17:34:14 +0000
1996
@@ -0,0 +1,76 @@
1997
1
# Copyright 2016 Canonical Ltd.
1998
2
#
1999
3
# This program is free software: you can redistribute it and/or modify it
2000
4
# under the terms of the GNU General Public License version 3, as published
2001
5
# by the Free Software Foundation.
2002
6
#
2003
7
# This program is distributed in the hope that it will be useful, but
2004
8
# WITHOUT ANY WARRANTY; without even the implied warranties of
2005
9
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
2006
10
# PURPOSE.  See the GNU General Public License for more details.
2007
11
#
2008
12
# You should have received a copy of the GNU General Public License along
2009
13
# with this program.  If not, see <http://www.gnu.org/licenses/>.
2010
14
2011
15
2012
16
import unittest.mock
2013
17
from unittest import TestCase
2014
18
from libertine.service import tasks
2015
19
from libertine.ContainersConfig import ContainersConfig
2016
20
2017
21
2018
22
class TestRemoveTask(TestCase):
2019
23
    def setUp(self):
2020
24
        self.config      = unittest.mock.create_autospec(ContainersConfig)
2021
25
        self.connection  = unittest.mock.Mock()
2022
26
        self.lock      = unittest.mock.MagicMock()
2023
27
        self.called_with = None
2024
28
2025
29
    def callback(self, task):
2026
30
        self.called_with = task
2027
31
2028
32
    def test_sends_error_on_non_installed_package(self):
2029
33
        self.config.get_package_install_status.return_value = 'installing'
2030
34
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
2031
35
            progress = MockProgress.return_value
2032
36
            task = tasks.RemoveTask('darkside-common', 'palpatine', self.config, self.lock, self.connection, self.callback)
2033
37
            task._instant_callback = True
2034
38
            task.start().join()
2035
39
2036
40
            progress.error.assert_called_once_with('Package \'darkside-common\' not installed, skipping remove')
2037
41
            self.assertEqual(task, self.called_with)
2038
42
2039
43
    def test_sends_error_on_failed_install(self):
2040
44
        self.config.get_package_install_status.return_value = 'installed'
2041
45
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
2042
46
            progress = MockProgress.return_value
2043
47
            task = tasks.RemoveTask('darkside-common', 'palpatine', self.config, self.lock, self.connection, self.callback)
2044
48
            task._instant_callback = True
2045
49
2046
50
            with unittest.mock.patch('libertine.service.tasks.remove_task.LibertineContainer') as MockContainer:
2047
51
                MockContainer.return_value.remove_package.return_value = False
2048
52
                task.start().join()
2049
53
2050
54
            progress.error.assert_called_once_with("Package removal failed for 'darkside-common'")
2051
55
            self.config.update_package_install_status.assert_has_calls([
2052
56
                unittest.mock.call('palpatine', 'darkside-common', 'removing'),
2053
57
                unittest.mock.call('palpatine', 'darkside-common', 'installed')
2054
58
            ], any_order=True)
2055
59
            self.assertEqual(task, self.called_with)
2056
60
2057
61
    def test_successfully_install(self):
2058
62
        self.config.get_package_install_status.return_value = 'installed'
2059
63
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
2060
64
            progress = MockProgress.return_value
2061
65
            progress.done = False
2062
66
            task = tasks.RemoveTask('darkside-common', 'palpatine', self.config, self.lock, self.connection, self.callback)
2063
67
            task._instant_callback = True
2064
68
2065
69
            with unittest.mock.patch('libertine.service.tasks.remove_task.LibertineContainer') as MockContainer:
2066
70
                MockContainer.return_value.remove_package.return_value = True
2067
71
                task.start().join()
2068
72
2069
73
            progress.finished.assert_called_once_with('palpatine')
2070
74
            self.config.update_package_install_status.assert_called_once_with('palpatine', 'darkside-common', 'removing')
2071
75
            self.config.delete_package.assert_called_once_with('palpatine', 'darkside-common')
2072
76
            self.assertEqual(task, self.called_with)
2073
0
77
2074
=== added file 'tests/unit/service/tasks/test_search_task.py'
2075
--- tests/unit/service/tasks/test_search_task.py	1970-01-01 00:00:00 +0000
2076
+++ tests/unit/service/tasks/test_search_task.py	2016-11-16 17:34:14 +0000
2077
@@ -0,0 +1,43 @@
2078
1
# Copyright 2016 Canonical Ltd.
2079
2
#
2080
3
# This program is free software: you can redistribute it and/or modify it
2081
4
# under the terms of the GNU General Public License version 3, as published
2082
5
# by the Free Software Foundation.
2083
6
#
2084
7
# This program is distributed in the hope that it will be useful, but
2085
8
# WITHOUT ANY WARRANTY; without even the implied warranties of
2086
9
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
2087
10
# PURPOSE.  See the GNU General Public License for more details.
2088
11
#
2089
12
# You should have received a copy of the GNU General Public License along
2090
13
# with this program.  If not, see <http://www.gnu.org/licenses/>.
2091
14
2092
15
2093
16
import unittest.mock
2094
17
from unittest import TestCase
2095
18
from libertine.service import tasks, apt
2096
19
2097
20
2098
21
class TestSearchTask(TestCase):
2099
22
    def setUp(self):
2100
23
        self.connection  = unittest.mock.Mock()
2101
24
        self.lock      = unittest.mock.MagicMock()
2102
25
        self.cache     = unittest.mock.create_autospec(apt.AptCache)
2103
26
        self.called_with = None
2104
27
2105
28
    def callback(self, task):
2106
29
        self.called_with = task
2107
30
2108
31
    def test_successfully_lists_apps(self):
2109
32
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
2110
33
            progress = MockProgress.return_value
2111
34
            progress.done = False
2112
35
            task = tasks.SearchTask('palpatine', self.cache, 'jarjar', self.connection, self.callback)
2113
36
            task._instant_callback = True
2114
37
2115
38
            self.cache.search.return_value = ['jarjar', 'sidius']
2116
39
            task.start().join()
2117
40
2118
41
            progress.finished.assert_called_once_with('palpatine')
2119
42
            progress.data.assert_called_once_with(str(['jarjar', 'sidius']))
2120
43
            self.assertEqual(task, self.called_with)
2121
0
44
2122
=== added file 'tests/unit/service/tasks/test_update_task.py'
2123
--- tests/unit/service/tasks/test_update_task.py	1970-01-01 00:00:00 +0000
2124
+++ tests/unit/service/tasks/test_update_task.py	2016-11-16 17:34:14 +0000
2125
@@ -0,0 +1,80 @@
2126
1
# Copyright 2016 Canonical Ltd.
2127
2
#
2128
3
# This program is free software: you can redistribute it and/or modify it
2129
4
# under the terms of the GNU General Public License version 3, as published
2130
5
# by the Free Software Foundation.
2131
6
#
2132
7
# This program is distributed in the hope that it will be useful, but
2133
8
# WITHOUT ANY WARRANTY; without even the implied warranties of
2134
9
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
2135
10
# PURPOSE.  See the GNU General Public License for more details.
2136
11
#
2137
12
# You should have received a copy of the GNU General Public License along
2138
13
# with this program.  If not, see <http://www.gnu.org/licenses/>.
2139
14
2140
15
2141
16
import unittest.mock
2142
17
from unittest import TestCase
2143
18
from libertine.service import tasks
2144
19
from libertine.ContainersConfig import ContainersConfig
2145
20
2146
21
2147
22
class TestUpdateTask(TestCase):
2148
23
    def setUp(self):
2149
24
        self.config      = unittest.mock.create_autospec(ContainersConfig)
2150
25
        self.connection  = unittest.mock.Mock()
2151
26
        self.lock      = unittest.mock.MagicMock()
2152
27
        self.called_with = None
2153
28
2154
29
    def callback(self, task):
2155
30
        self.called_with = task
2156
31
2157
32
    def test_sends_error_on_non_existent_container(self):
2158
33
        self.config.container_exists.return_value = False
2159
34
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
2160
35
            progress = MockProgress.return_value
2161
36
            task = tasks.UpdateTask('palpatine', self.config, self.lock, self.connection, self.callback)
2162
37
            task._instant_callback = True
2163
38
2164
39
            with unittest.mock.patch('libertine.service.tasks.update_task.LibertineContainer') as MockContainer:
2165
40
                task.start().join()
2166
41
2167
42
            progress.error.assert_called_once_with('Container \'palpatine\' does not exist, skipping update')
2168
43
            self.assertEqual(task, self.called_with)
2169
44
2170
45
    def test_sends_error_on_failed_update(self):
2171
46
        self.config.container_exists.return_value = True
2172
47
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
2173
48
            progress = MockProgress.return_value
2174
49
            task = tasks.UpdateTask('palpatine', self.config, self.lock, self.connection, self.callback)
2175
50
            task._instant_callback = True
2176
51
2177
52
            with unittest.mock.patch('libertine.service.tasks.update_task.LibertineContainer') as MockContainer:
2178
53
                MockContainer.return_value.update_libertine_container.return_value = False
2179
54
                task.start().join()
2180
55
2181
56
            progress.error.assert_called_once_with('Failed to update container \'palpatine\'')
2182
57
            self.config.update_container_install_status.assert_has_calls([
2183
58
                unittest.mock.call('palpatine', 'updating'),
2184
59
                unittest.mock.call('palpatine', 'ready')
2185
60
            ], any_order=True)
2186
61
            self.assertEqual(task, self.called_with)
2187
62
2188
63
    def test_successfully_updates(self):
2189
64
        self.config.container_exists.return_value = True
2190
65
        with unittest.mock.patch('libertine.service.tasks.base_task.libertine.service.progress.Progress') as MockProgress:
2191
66
            progress = MockProgress.return_value
2192
67
            progress.done = False
2193
68
            task = tasks.UpdateTask('palpatine', self.config, self.lock, self.connection, self.callback)
2194
69
            task._instant_callback = True
2195
70
2196
71
            with unittest.mock.patch('libertine.service.tasks.update_task.LibertineContainer') as MockContainer:
2197
72
                MockContainer.return_value.update_libertine_container.return_value = True
2198
73
                task.start().join()
2199
74
2200
75
            progress.finished.assert_called_once_with('palpatine')
2201
76
            self.config.update_container_install_status.assert_has_calls([
2202
77
                unittest.mock.call('palpatine', 'updating'),
2203
78
                unittest.mock.call('palpatine', 'ready')
2204
79
            ], any_order=True)
2205
80
            self.assertEqual(task, self.called_with)
2206
0
81
2207
=== added file 'tests/unit/service/test_apt.py'
2208
--- tests/unit/service/test_apt.py	1970-01-01 00:00:00 +0000
2209
+++ tests/unit/service/test_apt.py	2016-11-16 17:34:14 +0000
2210
@@ -0,0 +1,134 @@
2211
1
# Copyright 2016 Canonical Ltd.
2212
2
#
2213
3
# This program is free software: you can redistribute it and/or modify it
2214
4
# under the terms of the GNU General Public License version 3, as published
2215
5
# by the Free Software Foundation.
2216
6
#
2217
7
# This program is distributed in the hope that it will be useful, but
2218
8
# WITHOUT ANY WARRANTY; without even the implied warranties of
2219
9
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
2220
10
# PURPOSE.  See the GNU General Public License for more details.
2221
11
#
2222
12
# You should have received a copy of the GNU General Public License along
2223
13
# with this program.  If not, see <http://www.gnu.org/licenses/>.
2224
14
2225
15
import os
2226
16
import unittest.mock
2227
17
from unittest import TestCase
2228
18
from libertine.service import apt
2229
19
2230
20
2231
21
def build_mock_app(name, summary, website, description):
2232
22
    app = unittest.mock.Mock()
2233
23
    app.name = name
2234
24
    version = unittest.mock.Mock()
2235
25
    version.summary = summary
2236
26
    version.homepage = website
2237
27
    version.description = description
2238
28
    app.versions = [version]
2239
29
    return app
2240
30
2241
31
2242
32
class TestAptCache(TestCase):
2243
33
    def test_search_returns_empty_when_no_matching_results(self):
2244
34
        with unittest.mock.patch('libertine.service.apt.apt.Cache') as MockCache:
2245
35
            MockCache.return_value.keys.return_value = []
2246
36
2247
37
            with unittest.mock.patch('libertine.service.apt.Libertine') as MockLibertine:
2248
38
                MockLibertine.container_path.return_value = '/some/junk'
2249
39
                self.assertEqual(apt.AptCache('palpatine').search('vim'), [])
2250
40
2251
41
    def test_search_returns_matching_results(self):
2252
42
        with unittest.mock.patch('libertine.service.apt.apt.Cache') as MockCache:
2253
43
            MockCache.return_value = {
2254
44
                "vim": build_mock_app("vim", "vi improved", "vim.com", "who even uses raw vi"),
2255
45
                "gedit": build_mock_app("gedit", "text editor", "gedit.com", "visual text editor"),
2256
46
                "gimp": build_mock_app("gimp", "foss photoshop", "gimp.com", "edit bitmap images"),
2257
47
                "vim-common": build_mock_app("vim-common", "common vim stuff", "vim.common", "dependencies")
2258
48
            }
2259
49
2260
50
            with unittest.mock.patch('libertine.service.apt.Libertine') as MockLibertine:
2261
51
                MockLibertine.container_path.return_value = '/some/junk'
2262
52
                results = apt.AptCache('palpatine').search('vim')
2263
53
2264
54
            self.assertEqual(len(results), 2)
2265
55
            results = sorted(results, key=lambda xx: xx['id'])
2266
56
            self.assertEqual(results[0]['description'], 'who even uses raw vi')
2267
57
            self.assertEqual(results[0]['name'], 'vim')
2268
58
            self.assertEqual(results[0]['id'], 'vim')
2269
59
            self.assertEqual(results[0]['summary'], 'vi improved')
2270
60
            self.assertEqual(results[0]['website'], 'vim.com')
2271
61
            self.assertEqual(results[0]['package'], 'vim')
2272
62
2273
63
            self.assertEqual(results[1]['description'], 'dependencies')
2274
64
            self.assertEqual(results[1]['name'], 'vim-common')
2275
65
            self.assertEqual(results[1]['id'], 'vim-common')
2276
66
            self.assertEqual(results[1]['summary'], 'common vim stuff')
2277
67
            self.assertEqual(results[1]['website'], 'vim.common')
2278
68
            self.assertEqual(results[1]['package'], 'vim-common')
2279
69
2280
70
            MockCache.assert_called_once_with()
2281
71
2282
72
    def test_app_info_returns_empty_dict_when_no_such_app_exists(self):
2283
73
        with unittest.mock.patch('libertine.service.apt.apt.Cache') as MockCache:
2284
74
            MockCache.return_value = {}
2285
75
            with unittest.mock.patch('libertine.service.apt.Libertine') as MockLibertine:
2286
76
                MockLibertine.container_path.return_value = '/some/junk'
2287
77
                self.assertEqual(apt.AptCache('palpatine').app_info("vim"), {})
2288
78
            MockCache.assert_called_once_with()
2289
79
2290
80
    def test_app_info_returns_values_for_app(self):
2291
81
        with unittest.mock.patch('libertine.service.apt.apt.Cache') as MockCache:
2292
82
            MockCache.return_value = {
2293
83
                "vim": build_mock_app("vim", "vi improved", "vim.com", "who even uses raw vi"),
2294
84
                "gimp": build_mock_app("gimp", "foss photoshop", "gimp.com", "visual text editor"),
2295
85
            }
2296
86
            with unittest.mock.patch('libertine.service.apt.Libertine') as MockLibertine:
2297
87
                MockLibertine.container_path.return_value = '/some/junk'
2298
88
                self.assertEqual(apt.AptCache('palpatine').app_info("vim"), {
2299
89
                    'name': 'vim',
2300
90
                    'id': 'vim',
2301
91
                    'package': 'vim',
2302
92
                    'summary': 'vi improved',
2303
93
                    'description': 'who even uses raw vi',
2304
94
                    'website': 'vim.com'
2305
95
                })
2306
96
            MockCache.assert_called_once_with()
2307
97
2308
98
    def test_loads_cache_from_container_directory(self):
2309
99
        with unittest.mock.patch('libertine.service.apt.apt.Cache') as MockCache:
2310
100
            MockCache.return_value = {
2311
101
                "vim": build_mock_app("vim", "vi improved", "vim.com", "who even uses raw vi"),
2312
102
                "gimp": build_mock_app("gimp", "foss photoshop", "gimp.com", "visual text editor"),
2313
103
            }
2314
104
            with unittest.mock.patch('libertine.service.apt.Libertine') as MockLibertine:
2315
105
                containerpath = "%s/containerroot" % os.path.dirname(os.path.realpath(__file__))
2316
106
                MockLibertine.container_path.return_value = containerpath
2317
107
                self.assertEqual(apt.AptCache('palpatine').app_info("vim"), {
2318
108
                    'name': 'vim',
2319
109
                    'id': 'vim',
2320
110
                    'package': 'vim',
2321
111
                    'summary': 'vi improved',
2322
112
                    'description': 'who even uses raw vi',
2323
113
                    'website': 'vim.com'
2324
114
                })
2325
115
2326
116
            MockCache.assert_called_once_with(rootdir=containerpath)
2327
117
2328
118
    def test_loads_cache_only_once(self):
2329
119
        with unittest.mock.patch('libertine.service.apt.apt.Cache') as MockCache:
2330
120
            MockCache.return_value = {
2331
121
                "vim": build_mock_app("vim", "vi improved", "vim.com", "who even uses raw vi"),
2332
122
                "gimp": build_mock_app("gimp", "foss photoshop", "gimp.com", "visual text editor"),
2333
123
            }
2334
124
            with unittest.mock.patch('libertine.service.apt.Libertine') as MockLibertine:
2335
125
                MockLibertine.container_path.return_value = '/some/junk'
2336
126
                cache = apt.AptCache('palpatine')
2337
127
                cache.app_info("vim")
2338
128
                cache.app_info("vim")
2339
129
2340
130
            MockCache.assert_called_once_with()
2341
131
2342
132
2343
133
if __name__ == '__main__':
2344
134
    unittest.main()
2345
0
135
2346
=== added file 'tests/unit/service/test_container.py'
2347
--- tests/unit/service/test_container.py	1970-01-01 00:00:00 +0000
2348
+++ tests/unit/service/test_container.py	2016-11-16 17:34:14 +0000
2349
@@ -0,0 +1,202 @@
2350
1
# Copyright 2016 Canonical Ltd.
2351
2
#
2352
3
# This program is free software: you can redistribute it and/or modify it
2353
4
# under the terms of the GNU General Public License version 3, as published
2354
5
# by the Free Software Foundation.
2355
6
#
2356
7
# This program is distributed in the hope that it will be useful, but
2357
8
# WITHOUT ANY WARRANTY; without even the implied warranties of
2358
9
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
2359
10
# PURPOSE.  See the GNU General Public License for more details.
2360
11
#
2361
12
# You should have received a copy of the GNU General Public License along
2362
13
# with this program.  If not, see <http://www.gnu.org/licenses/>.
2363
14
2364
15
import unittest.mock
2365
16
from unittest import TestCase
2366
17
from libertine.service import container
2367
18
from libertine.service import tasks
2368
19
2369
20
2370
21
class TestContainer(TestCase):
2371
22
    def setUp(self):
2372
23
        self._connection = unittest.mock.Mock()
2373
24
        self._config = unittest.mock.Mock()
2374
25
        self._lock = unittest.mock.Mock()
2375
26
2376
27
    def test_search_creates_search_task(self):
2377
28
        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
2378
29
            cache = MockCache.return_value
2379
30
            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
2380
31
            with unittest.mock.patch('libertine.service.container.SearchTask') as MockSearchTask:
2381
32
                c.search('darkseid')
2382
33
                MockSearchTask.assert_called_once_with('palpatine', cache, 'darkseid', self._connection, unittest.mock.ANY)
2383
34
                MockSearchTask.return_value.start.assert_called_once_with()
2384
35
2385
36
    def test_app_info_creates_app_info_task(self):
2386
37
        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
2387
38
            cache = MockCache.return_value
2388
39
            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
2389
40
            with unittest.mock.patch('libertine.service.container.AppInfoTask') as MockAppInfoTask:
2390
41
                c.app_info('force')
2391
42
                MockAppInfoTask.assert_called_once_with('palpatine', cache, 'force', [], self._config, self._connection, unittest.mock.ANY)
2392
43
                MockAppInfoTask.return_value.start.assert_called_once_with()
2393
44
2394
45
    def test_app_info_gets_related_task_info(self):
2395
46
        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
2396
47
            cache = MockCache.return_value
2397
48
            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
2398
49
            with unittest.mock.patch('libertine.service.container.InstallTask') as MockInstallTask:
2399
50
                MockInstallTask.return_value.package = 'darkside'
2400
51
                MockInstallTask.return_value.matches.return_value = False
2401
52
                install_task_id = c.install('darkside')
2402
53
                with unittest.mock.patch('libertine.service.container.RemoveTask') as MockRemoveTask:
2403
54
                    MockRemoveTask.return_value.package = 'darkside'
2404
55
                    remove_task_id = c.remove('darkside')
2405
56
                with unittest.mock.patch('libertine.service.container.AppInfoTask') as MockAppInfoTask:
2406
57
                    c.app_info('darkside')
2407
58
                    MockAppInfoTask.assert_called_once_with('palpatine', cache, 'darkside', [install_task_id, remove_task_id],
2408
59
                                                            self._config, self._connection, unittest.mock.ANY)
2409
60
2410
61
    def test_install_creates_install_task(self):
2411
62
        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
2412
63
            cache = MockCache.return_value
2413
64
            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
2414
65
            with unittest.mock.patch('libertine.service.container.InstallTask') as MockInstallTask:
2415
66
                c.install('force')
2416
67
                MockInstallTask.assert_called_once_with('force', 'palpatine', self._config, self._lock, self._connection, unittest.mock.ANY)
2417
68
                MockInstallTask.return_value.start.assert_called_once_with()
2418
69
2419
70
    def test_install_only_calls_once_when_unfinished(self):
2420
71
        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
2421
72
            cache = MockCache.return_value
2422
73
            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
2423
74
            with unittest.mock.patch('libertine.service.container.InstallTask') as MockInstallTask:
2424
75
                c.install('darkside')
2425
76
                c.install('darkside')
2426
77
                c.install('darkside')
2427
78
                # MockInstallTask.assert_called_once_with('darkside', 'palpatine', self._config, self._lock, self._connection, unittest.mock.ANY)
2428
79
                MockInstallTask.return_value.start.assert_called_once_with()
2429
80
2430
81
    def test_remove_creates_remove_task(self):
2431
82
        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
2432
83
            cache = MockCache.return_value
2433
84
            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
2434
85
            with unittest.mock.patch('libertine.service.container.RemoveTask') as MockRemoveTask:
2435
86
                c.remove('force')
2436
87
                MockRemoveTask.assert_called_once_with('force', 'palpatine', self._config, self._lock, self._connection, unittest.mock.ANY)
2437
88
                MockRemoveTask.return_value.start.assert_called_once_with()
2438
89
2439
90
    def test_remove_only_calls_once_when_unfinished(self):
2440
91
        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
2441
92
            cache = MockCache.return_value
2442
93
            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
2443
94
            with unittest.mock.patch('libertine.service.container.RemoveTask') as MockRemoveTask:
2444
95
                c.remove('darkside')
2445
96
                c.remove('darkside')
2446
97
                c.remove('darkside')
2447
98
                # MockRemoveTask.assert_called_once_with('darkside', 'palpatine', self._config, self._lock, self._connection, unittest.mock.ANY)
2448
99
                MockRemoveTask.return_value.start.assert_called_once_with()
2449
100
2450
101
    def test_create_creates_create_task(self):
2451
102
        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
2452
103
            cache = MockCache.return_value
2453
104
            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
2454
105
            with unittest.mock.patch('libertine.service.container.CreateTask') as MockCreateTask:
2455
106
                c.create('Emperor Palpatine', 'zesty', 'lxd', False)
2456
107
                MockCreateTask.assert_called_once_with('palpatine', 'Emperor Palpatine', 'zesty', 'lxd', False,
2457
108
                                                       self._config, self._lock, self._connection, unittest.mock.ANY)
2458
109
                MockCreateTask.return_value.start.assert_called_once_with()
2459
110
2460
111
    def test_create_only_calls_once_when_unfinished(self):
2461
112
        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
2462
113
            cache = MockCache.return_value
2463
114
            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
2464
115
            with unittest.mock.patch('libertine.service.container.CreateTask') as MockCreateTask:
2465
116
                c.create('Emperor Palpatine', 'zesty', 'lxd', False)
2466
117
                c.create('Emperor Palpatine', 'zesty', 'lxd', False)
2467
118
                c.create('Emperor Palpatine', 'zesty', 'lxd', False)
2468
119
                # MockCreateTask.assert_called_once_with('palpatine', 'Emperor Palpatine', 'zesty', 'lxd', False,
2469
120
                #                                        self._config, self._lock, self._connection, unittest.mock.ANY)
2470
121
                MockCreateTask.return_value.start.assert_called_once_with()
2471
122
2472
123
    def test_destroy_creates_destroy_task(self):
2473
124
        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
2474
125
            cache = MockCache.return_value
2475
126
            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
2476
127
            with unittest.mock.patch('libertine.service.container.DestroyTask') as MockDestroyTask:
2477
128
                c.destroy()
2478
129
                # MockDestroyTask.assert_called_once_with('palpatine', self._config, self._lock, self._connection, unittest.mock.ANY)
2479
130
                MockDestroyTask.return_value.start.assert_called_once_with()
2480
131
2481
132
    def test_destroy_only_calls_once_when_unfinished(self):
2482
133
        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
2483
134
            cache = MockCache.return_value
2484
135
            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
2485
136
            with unittest.mock.patch('libertine.service.container.DestroyTask') as MockDestroyTask:
2486
137
                c.destroy()
2487
138
                c.destroy()
2488
139
                c.destroy()
2489
140
                # MockDestroyTask.assert_called_once_with('palpatine', self._config, self._lock, self._connection, unittest.mock.ANY)
2490
141
                MockDestroyTask.return_value.start.assert_called_once_with()
2491
142
2492
143
    def test_update_creates_update_task(self):
2493
144
        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
2494
145
            cache = MockCache.return_value
2495
146
            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
2496
147
            with unittest.mock.patch('libertine.service.container.UpdateTask') as MockUpdateTask:
2497
148
                c.update()
2498
149
                MockUpdateTask.assert_called_once_with('palpatine', self._config, self._lock, self._connection, unittest.mock.ANY)
2499
150
                MockUpdateTask.return_value.start.assert_called_once_with()
2500
151
2501
152
    def test_update_only_calls_once_when_unfinished(self):
2502
153
        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
2503
154
            cache = MockCache.return_value
2504
155
            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
2505
156
            with unittest.mock.patch('libertine.service.container.UpdateTask') as MockUpdateTask:
2506
157
                c.update()
2507
158
                c.update()
2508
159
                c.update()
2509
160
                # MockUpdateTask.assert_called_once_with('palpatine', self._config, self._lock, self._connection, unittest.mock.ANY)
2510
161
                MockUpdateTask.return_value.start.assert_called_once_with()
2511
162
2512
163
    def test_list_apps_creates_list_apps_task(self):
2513
164
        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
2514
165
            cache = MockCache.return_value
2515
166
            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
2516
167
            with unittest.mock.patch('libertine.service.container.ListAppsTask') as MockListAppsTask:
2517
168
                c.list_apps()
2518
169
                MockListAppsTask.assert_called_once_with('palpatine', self._config, self._connection, unittest.mock.ANY)
2519
170
                MockListAppsTask.return_value.start.assert_called_once_with()
2520
171
2521
172
    def test_removes_task_during_callback(self):
2522
173
        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
2523
174
            cache = MockCache.return_value
2524
175
            c = container.Container('palpatine', self._config, self._lock, self._connection, lambda task: task)
2525
176
            with unittest.mock.patch('libertine.service.container.InstallTask') as MockInstallTask:
2526
177
                MockInstallTask.return_value.package = 'force'
2527
178
                c.install('force')
2528
179
                self.assertEqual(1, len(MockInstallTask.return_value.start.mock_calls)) # ensure initial mocks were called
2529
180
                c.install('force')
2530
181
                self.assertEqual(1, len(MockInstallTask.return_value.start.mock_calls)) # ensure no more mocks were called
2531
182
                name, args, kwargs = MockInstallTask.mock_calls[0]
2532
183
                args[len(args)-1](MockInstallTask.return_value.start.return_value)
2533
184
                c.install('force')
2534
185
                self.assertEqual(2, len(MockInstallTask.return_value.start.mock_calls)) # ensure mocks were called again
2535
186
2536
187
    def test_completing_all_tasks_fires_callback(self):
2537
188
        with unittest.mock.patch('libertine.service.container.apt.AptCache') as MockCache:
2538
189
            cache = MockCache.return_value
2539
190
            self._container_id = None
2540
191
            def callback(container):
2541
192
                self._container_id = container.id
2542
193
            c = container.Container('palpatine', self._config, self._lock, self._connection, callback)
2543
194
            with unittest.mock.patch('libertine.service.container.InstallTask') as MockInstallTask:
2544
195
                c.install('force')
2545
196
                name, args, kwargs = MockInstallTask.mock_calls[0]
2546
197
                args[len(args)-1](MockInstallTask.return_value)
2547
198
            self.assertEqual('palpatine', self._container_id)
2548
199
2549
200
2550
201
if __name__ == '__main__':
2551
202
    unittest.main()
2552
0
203
2553
=== added file 'tests/unit/service/test_task_dispatcher.py'
2554
--- tests/unit/service/test_task_dispatcher.py	1970-01-01 00:00:00 +0000
2555
+++ tests/unit/service/test_task_dispatcher.py	2016-11-16 17:34:14 +0000
2556
@@ -0,0 +1,148 @@
2557
1
# Copyright 2016 Canonical Ltd.
2558
2
#
2559
3
# This program is free software: you can redistribute it and/or modify it
2560
4
# under the terms of the GNU General Public License version 3, as published
2561
5
# by the Free Software Foundation.
2562
6
#
2563
7
# This program is distributed in the hope that it will be useful, but
2564
8
# WITHOUT ANY WARRANTY; without even the implied warranties of
2565
9
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
2566
10
# PURPOSE.  See the GNU General Public License for more details.
2567
11
#
2568
12
# You should have received a copy of the GNU General Public License along
2569
13
# with this program.  If not, see <http://www.gnu.org/licenses/>.
2570
14
2571
15
import unittest.mock
2572
16
from unittest import TestCase
2573
17
from libertine.service import task_dispatcher
2574
18
2575
19
2576
20
class TestTaskDispatcher(TestCase):
2577
21
    def setUp(self):
2578
22
        self._connection = unittest.mock.Mock()
2579
23
        self._config_patcher = unittest.mock.patch('libertine.service.task_dispatcher.libertine.ContainersConfig.ContainersConfig')
2580
24
        self._config_patcher.start()
2581
25
        self._dispatcher = task_dispatcher.TaskDispatcher(self._connection)
2582
26
2583
27
    def tearDown(self):
2584
28
        self._config_patcher.stop()
2585
29
2586
30
    def test_search_calls_search_on_container(self):
2587
31
        with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
2588
32
            c = MockContainer.return_value
2589
33
            c.search.return_value = 123
2590
34
            self.assertEqual(123, self._dispatcher.search('palpatine', 'sith'))
2591
35
            c.search.assert_called_once_with('sith')
2592
36
2593
37
    def test_app_info_calls_app_info_on_container(self):
2594
38
        with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
2595
39
            c = MockContainer.return_value
2596
40
            c.app_info.return_value = 123
2597
41
            self.assertEqual(123, self._dispatcher.app_info('palpatine', 'deathstar'))
2598
42
            c.app_info.assert_called_once_with('deathstar')
2599
43
2600
44
    def test_install_calls_install_on_container(self):
2601
45
        with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
2602
46
            c = MockContainer.return_value
2603
47
            c.install.return_value = 123
2604
48
            self.assertEqual(123, self._dispatcher.install('palpatine', 'darkside'))
2605
49
            c.install.assert_called_once_with('darkside')
2606
50
2607
51
    def test_remove_calls_remove_on_container(self):
2608
52
        with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
2609
53
            c = MockContainer.return_value
2610
54
            c.remove.return_value = 123
2611
55
            self.assertEqual(123, self._dispatcher.remove('palpatine', 'lightside'))
2612
56
            c.remove.assert_called_once_with('lightside')
2613
57
2614
58
    def test_create_calls_create_on_container(self):
2615
59
        with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
2616
60
            c = MockContainer.return_value
2617
61
            c.create.return_value = 123
2618
62
            self.assertEqual(123, self._dispatcher.create('palpatine', 'Emperor Palpatine', 'zesty', 'lxd', False))
2619
63
            c.create.assert_called_once_with('Emperor Palpatine', 'zesty', 'lxd', False)
2620
64
2621
65
    def test_destroy_calls_destroy_on_container(self):
2622
66
        with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
2623
67
            c = MockContainer.return_value
2624
68
            c.destroy.return_value = 123
2625
69
            self.assertEqual(123, self._dispatcher.destroy('palpatine'))
2626
70
            c.destroy.assert_called_once_with()
2627
71
2628
72
    def test_update_calls_update_on_container(self):
2629
73
        with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
2630
74
            c = MockContainer.return_value
2631
75
            c.update.return_value = 123
2632
76
            self.assertEqual(123, self._dispatcher.update('palpatine'))
2633
77
            c.update.assert_called_once_with()
2634
78
2635
79
    def test_list_apps_calls_list_apps_on_container(self):
2636
80
        with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
2637
81
            c = MockContainer.return_value
2638
82
            c.list_apps.return_value = 123
2639
83
            self.assertEqual(123, self._dispatcher.list_apps('palpatine'))
2640
84
            c.list_apps.assert_called_once_with()
2641
85
2642
86
    def test_containers_reused_on_subsequent_calls(self):
2643
87
        with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
2644
88
            c = MockContainer.return_value
2645
89
            c.id = 'palpatine'
2646
90
            self._dispatcher.list_apps('palpatine')
2647
91
            self._dispatcher.list_apps('palpatine')
2648
92
            self._dispatcher.list_apps('palpatine')
2649
93
            MockContainer.assert_called_once_with('palpatine', unittest.mock.ANY, unittest.mock.ANY, self._connection, unittest.mock.ANY)
2650
94
2651
95
    def test_container_callback_removes_container(self):
2652
96
        with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
2653
97
            c = MockContainer.return_value
2654
98
            c.id = 'palpatine'
2655
99
            self._dispatcher.list_apps('palpatine')
2656
100
            MockContainer.assert_called_once_with('palpatine', unittest.mock.ANY, unittest.mock.ANY, self._connection, unittest.mock.ANY)
2657
101
            name, args, kwargs = MockContainer.mock_calls[0]
2658
102
            args[len(args)-1](MockContainer.return_value)
2659
103
            self._dispatcher.list_apps('palpatine')
2660
104
            MockContainer.assert_has_calls([ # verify container constructed twice
2661
105
                unittest.mock.call('palpatine', unittest.mock.ANY, unittest.mock.ANY, self._connection, unittest.mock.ANY),
2662
106
                unittest.mock.call('palpatine', unittest.mock.ANY, unittest.mock.ANY, self._connection, unittest.mock.ANY)
2663
107
            ], any_order=True)
2664
108
2665
109
    def test_container_info_creates_container_info_task(self):
2666
110
        with unittest.mock.patch('libertine.service.task_dispatcher.ContainerInfoTask') as MockContainerInfoTask:
2667
111
            task = MockContainerInfoTask.return_value
2668
112
            task.id = 123
2669
113
            self.assertEqual(123, self._dispatcher.container_info('palpatine'))
2670
114
            MockContainerInfoTask.assert_called_once_with('palpatine', [], unittest.mock.ANY, self._connection, unittest.mock.ANY)
2671
115
            task.start.assert_called_once_with()
2672
116
2673
117
    def test_container_info_forwards_container_task_ids(self):
2674
118
        with unittest.mock.patch('libertine.service.task_dispatcher.ContainerInfoTask') as MockContainerInfoTask:
2675
119
            task = MockContainerInfoTask.return_value
2676
120
            with unittest.mock.patch('libertine.service.task_dispatcher.Container') as MockContainer:
2677
121
                c = MockContainer.return_value
2678
122
                c.tasks = [1, 2, 3]
2679
123
                c.id = 'palpatine'
2680
124
                self._dispatcher.list_apps('palpatine') # creates container
2681
125
                self._dispatcher.container_info('palpatine')
2682
126
            MockContainerInfoTask.assert_called_once_with('palpatine', [1, 2, 3], unittest.mock.ANY, self._connection, unittest.mock.ANY)
2683
127
            task.start.assert_called_once_with()
2684
128
2685
129
    def test_list_creates_list_task(self):
2686
130
        with unittest.mock.patch('libertine.service.task_dispatcher.ListTask') as MockListTask:
2687
131
            task = MockListTask.return_value
2688
132
            task.id = 123
2689
133
            self.assertEqual(123, self._dispatcher.list())
2690
134
            MockListTask.assert_called_once_with(self._connection, unittest.mock.ANY)
2691
135
            task.start.assert_called_once_with()
2692
136
2693
137
    def test_containerless_tasks_are_cleaned_up(self):
2694
138
        with unittest.mock.patch('libertine.service.task_dispatcher.ListTask') as MockListTask:
2695
139
            self._dispatcher.list()
2696
140
            MockListTask.assert_called_once_with(self._connection, unittest.mock.ANY)
2697
141
            name, args, kwargs = MockListTask.mock_calls[0]
2698
142
            self.assertEqual(1, len(self._dispatcher._tasks))
2699
143
            args[len(args)-1](MockListTask.return_value)
2700
144
            self.assertEqual(0, len(self._dispatcher._tasks))
2701
145
2702
146
2703
147
if __name__ == '__main__':
2704
148
    unittest.main()
2705
0
149
2706
=== modified file 'tools/CMakeLists.txt'
2707
--- tools/CMakeLists.txt	2016-08-04 01:39:08 +0000
2708
+++ tools/CMakeLists.txt	2016-11-16 17:34:14 +0000
2709
@@ -1,4 +1,4 @@
2711
1
install(PROGRAMS libertine-container-manager libertine-launch libertine-lxc-manager libertine-xmir libertine-lxc-setup
1
install(PROGRAMS libertine-container-manager libertine-launch libertine-lxc-manager libertine-xmir libertine-lxc-setup libertined
2712
2
        DESTINATION ${CMAKE_INSTALL_BINDIR})
2
        DESTINATION ${CMAKE_INSTALL_BINDIR})
2713
3
install(FILES libertine-launch.1 libertine-container-manager.1 libertine-lxc-manager.1 libertine-xmir.1
3
install(FILES libertine-launch.1 libertine-container-manager.1 libertine-lxc-manager.1 libertine-xmir.1
2714
4
        DESTINATION ${CMAKE_INSTALL_MANDIR}/man1
4
        DESTINATION ${CMAKE_INSTALL_MANDIR}/man1
2715
5
5
2716
=== modified file 'tools/libertine-container-manager'
2717
--- tools/libertine-container-manager	2016-11-09 18:25:33 +0000
2718
+++ tools/libertine-container-manager	2016-11-16 17:34:14 +0000
2719
@@ -183,7 +183,7 @@
2720
183
        container = LibertineContainer(container_id)
183
        container = LibertineContainer(container_id)
2721
184
184
2722
185
        self.containers_config.update_container_install_status(container_id, "updating")
185
        self.containers_config.update_container_install_status(container_id, "updating")
2724
186
        if container.update_libertine_container(args.verbosity) is not 0:
186
        if not container.update_libertine_container(args.verbosity):
2725
187
            self.containers_config.update_container_install_status(container_id, "ready")
187
            self.containers_config.update_container_install_status(container_id, "ready")
2726
188
            sys.exit(1)
188
            sys.exit(1)
2727
189
189
2728
190
190
2729
=== added file 'tools/libertined'
2730
--- tools/libertined	1970-01-01 00:00:00 +0000
2731
+++ tools/libertined	2016-11-16 17:34:14 +0000
2732
@@ -0,0 +1,141 @@
2733
1
#!/usr/bin/python3
2734
2
# -*- coding: utf-8 -*-
2735
3
2736
4
# Copyright 2016 Canonical Ltd.
2737
5
#
2738
6
# This program is free software: you can redistribute it and/or modify
2739
7
# it under the terms of the GNU General Public License as published by
2740
8
# the Free Software Foundation; version 3 of the License.
2741
9
#
2742
10
# This program is distributed in the hope that it will be useful,
2743
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
2744
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2745
13
# GNU General Public License for more details.
2746
14
#
2747
15
# You should have received a copy of the GNU General Public License
2748
16
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
2749
17
2750
18
import argparse
2751
19
import signal
2752
20
import sys
2753
21
import os
2754
22
from gi.repository import GLib, GObject
2755
23
from libertine import utils
2756
24
from libertine.service import manager
2757
25
2758
26
2759
27
class OutputRedirector(object):
2760
28
    def __init__(self, config):
2761
29
        self.config = config
2762
30
        self.cache_path = '%s/.cache/libertined' % os.environ['HOME']
2763
31
        self.cache_file = '%s/libertined.log' % self.cache_path
2764
32
        self.output_file = None
2765
33
        self.copied_stdout = None
2766
34
        self.copied_stderr = None
2767
35
2768
36
    def _fileno(self, file_or_fd):
2769
37
        return getattr(file_or_fd, 'fileno', lambda: file_or_fd)()
2770
38
2771
39
    def _do_redirect(self, stream):
2772
40
        fd = self._fileno(stream)
2773
41
        copied_stream = os.fdopen(os.dup(fd), 'wb')
2774
42
        stream.flush()
2775
43
        os.dup2(self._fileno(self.output_file), fd)
2776
44
        return copied_stream, fd
2777
45
2778
46
    def _undo_redirect(self, stream, stream_fd, copied_stream):
2779
47
        stream.flush()
2780
48
        os.dup2(copied_stream.fileno(), stream_fd)
2781
49
        copied_stream.close()
2782
50
2783
51
    def _rotate_logs(self):
2784
52
        os.makedirs(self.cache_path, exist_ok=True)
2785
53
        num_backups = 3
2786
54
        for i in range(num_backups, 0, -1):
2787
55
            filename = '%s.%i' % (self.cache_file, i)
2788
56
            if os.path.exists(filename):
2789
57
                if i == num_backups:
2790
58
                    os.remove(filename)
2791
59
                else:
2792
60
                    os.rename(filename, '%s.%i' % (self.cache_file, i+1))
2793
61
        if os.path.exists(self.cache_file):
2794
62
            os.rename(self.cache_file, '%s.1' % self.cache_file)
2795
63
2796
64
    def __enter__(self):
2797
65
        if self.config.debug:
2798
66
            os.environ['LIBERTINE_DEBUG'] = '1'
2799
67
        else:
2800
68
            if self.config.cache_output:
2801
69
                os.environ['LIBERTINE_DEBUG'] = '1'
2802
70
                self._rotate_logs()
2803
71
                self.output_file = open(self.cache_file, 'w')
2804
72
            else:
2805
73
                self.output_file = open(os.devnull, 'w')
2806
74
2807
75
            self.copied_stdout, self.stdout_fd = self._do_redirect(sys.stdout)
2808
76
            self.copied_stderr, self.stderr_fd = self._do_redirect(sys.stderr)
2809
77
2810
78
    def __exit__(self, type, value, tb):
2811
79
        if self.copied_stdout and self.stdout_fd:
2812
80
            self._undo_redirect(sys.stdout, self.stdout_fd, self.copied_stdout)
2813
81
        if self.copied_stderr and self.stderr_fd:
2814
82
            self._undo_redirect(sys.stderr, self.stderr_fd, self.copied_stderr)
2815
83
        if self.output_file:
2816
84
            self.output_file.close()
2817
85
2818
86
2819
87
class Config(object):
2820
88
  def __init__(self):
2821
89
    self._arg_parser = argparse.ArgumentParser(description=u'Libertine Store service')
2822
90
    self._arg_parser.add_argument(u'-l', u"--use-local-cache",
2823
91
                                  action='store_true',
2824
92
                                  default=False,
2825
93
                                  help=u"use local cache instead of system cache")
2826
94
    self._arg_parser.add_argument(u'-d', u"--debug",
2827
95
                                  action='store_true',
2828
96
                                  default=False,
2829
97
                                  help=u"allow all output on stdout")
2830
98
    self._arg_parser.add_argument(u'-c', u"--cache-output",
2831
99
                                  action='store_true',
2832
100
                                  default=False,
2833
101
                                  help=u"Log to $HOME/.cache/libertined/ instead of stdout")
2834
102
    args = self._arg_parser.parse_args(namespace=Config)
2835
103
2836
104
2837
105
class Loop(object):
2838
106
    def __init__(self):
2839
107
        GLib.unix_signal_add(GLib.PRIORITY_HIGH,
2840
108
                         signal.SIGTERM,
2841
109
                         self.sigterm,
2842
110
                         None)
2843
111
        self.loop = GLib.MainLoop()
2844
112
2845
113
    def sigterm(self, code):
2846
114
        utils.get_logger().info("terminate ('%s') signal received" % code)
2847
115
        self.shutdown()
2848
116
2849
117
    def shutdown(self):
2850
118
        utils.get_logger().info("shutting service down")
2851
119
        self.loop.quit()
2852
120
2853
121
    def run(self):
2854
122
        utils.get_logger().debug("entering main loop")
2855
123
        self.loop.run()
2856
124
2857
125
2858
126
def main():
2859
127
    config = Config()
2860
128
2861
129
    with OutputRedirector(config):
2862
130
        utils.get_logger().info("Starting libertine service")
2863
131
        service = manager.Manager()
2864
132
        loop = Loop()
2865
133
        try:
2866
134
            loop.run()
2867
135
        except KeyboardInterrupt:
2868
136
            utils.get_logger().debug("keyboard interrupt received")
2869
137
            loop.shutdown()
2870
138
2871
139
2872
140
if __name__ == '__main__':
2873
141
    main()
Reviewer	Review Type	Date Requested	Status
Christopher Townsend		2016-11-01	Approve on 2016-11-16
Libertine CI Bot	continuous-integration		Approve on 2016-11-16
Review via email: mp+309794@code.launchpad.net