Merge lp:~ubuntu-branches/ubuntu/natty/landscape-client/natty-updates-201411191718 into lp:ubuntu/natty-updates/landscape-client

[Ubuntu Package Importer]

The package importer has detected a possible inconsistency between the package history in the archive and the history in bzr. As the archive is authoritative the importer has made lp:ubuntu/natty-updates/landscape-client reflect what is in the archive and the old bzr branch has been pushed to lp:~ubuntu-branches/ubuntu/natty/landscape-client/natty-updates-201411191718. This merge proposal was created so that an Ubuntu developer can review the situations and perform a merge/upload if necessary. There are three typical cases where this can happen.
  1. Where someone pushes a change to bzr and someone else uploads the package without that change. This is the reason that this check is done by the importer. If this appears to be the case then a merge/upload should be done if the changes that were in bzr are still desirable.
  2. The importer incorrectly detected the above situation when someone made a change in bzr and then uploaded it.
  3. The importer incorrectly detected the above situation when someone just uploaded a package and didn't touch bzr.

If this case doesn't appear to be the first situation then set the status of the merge proposal to "Rejected" and help avoid the problem in future by filing a bug at https://bugs.launchpad.net/udd linking to this merge proposal.

(this is an automatically generated message)

Unmerged revisions

=== added directory 'applications'
=== renamed directory 'applications' => 'applications.moved'
=== added file 'applications/landscape-client-settings.desktop.in'
--- applications/landscape-client-settings.desktop.in	1970-01-01 00:00:00 +0000
+++ applications/landscape-client-settings.desktop.in	2014-11-19 18:22:39 +0000
@@ -0,0 +1,17 @@
+[Desktop Entry]
+_Name=Management Service
+_Comment=Management Service Preferences
+Exec=landscape-client-ui-install
+Icon=preferences-management-service
+Terminal=False
+Type=Application
+StartupNotify=true
+Categories=GNOME;GTK;Settings;X-GNOME-SystemSettings;X-GNOME-Settings-Panel;
+OnlyShowIn=GNOME;Unity;
+X-GNOME-Bugzilla-Bugzilla=GNOME
+X-GNOME-Bugzilla-Product=gnome-control-center
+X-GNOME-Bugzilla-Component=sample
+X-GNOME-Bugzilla-Version=1.0.0
+X-GNOME-Settings-Panel=sample
+X-GNOME-Keywords=device;system;information;memory;processor;version;default;application;fallback;preferred;
+X-Ubuntu-Gettext-Domain=landscape-client
 
=== added directory 'apt-update'
=== renamed directory 'apt-update' => 'apt-update.moved'
=== added file 'apt-update/Makefile'
--- apt-update/Makefile	1970-01-01 00:00:00 +0000
+++ apt-update/Makefile	2014-11-19 18:22:39 +0000
@@ -0,0 +1,7 @@
+NAME = apt-update
+
+$(NAME): $(NAME).c
+	$(CC) $(CFLAGS) -Wall $< -o $@
+
+clean:
+	rm -f $(NAME)
 
=== added file 'apt-update/apt-update.c'
--- apt-update/apt-update.c	1970-01-01 00:00:00 +0000
+++ apt-update/apt-update.c	2014-11-19 18:22:39 +0000
@@ -0,0 +1,81 @@
+/*
+
+ Copyright (c) 2011 Canonical, Ltd.
+
+*/
+
+#define _GNU_SOURCE
+#include <sys/resource.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <grp.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <stdio.h>
+#include <pwd.h>
+
+int main(int argc, char *argv[], char *envp[])
+{
+  char *apt_argv[] = {"/usr/bin/apt-get", "-q", "update", NULL};
+  char *apt_envp[] = {"PATH=/bin:/usr/bin", NULL, NULL};
+
+  // Set the HOME environment variable
+  struct passwd *pwd = getpwuid(geteuid());
+  if (!pwd) {
+    fprintf(stderr, "error: Unable to find passwd entry for uid %d (%s)\n",
+            geteuid(), strerror(errno));
+    exit(1);
+  }
+  if (asprintf(&apt_envp[1], "HOME=%s", pwd->pw_dir) == -1) {
+    perror("error: Unable to create HOME environment variable");
+    exit(1);
+  }
+
+  // Drop any supplementary group
+  if (setgroups(0, NULL) == -1) {
+    perror("error: Unable to set supplementary groups IDs");
+    exit(1);
+  }
+
+  // Set real/effective gid and uid
+  if (setregid(pwd->pw_gid, pwd->pw_gid) == -1) {
+    fprintf(stderr, "error: Unable to set real and effective gid (%s)\n",
+            strerror(errno));
+    exit(1);
+  }
+  if (setreuid(pwd->pw_uid, pwd->pw_uid) == -1) {
+    perror("error: Unable to set real and effective uid");
+    exit(1);
+  }
+
+  // Close all file descriptors except the standard ones
+  struct rlimit rlp;
+  if (getrlimit(RLIMIT_NOFILE, &rlp) == -1) {
+    perror("error: Unable to determine file descriptor limits");
+    exit(1);
+  }
+  int file_max;
+  if (rlp.rlim_max == RLIM_INFINITY || rlp.rlim_max > 4096)
+    file_max = 4096;
+  else
+    file_max = rlp.rlim_max;
+  int file;
+  for (file = 3; file < file_max; file++) {
+    close(file);
+  }
+
+  // Set umask to 022
+  umask(S_IWGRP | S_IWOTH);
+
+  if (chdir("/") == -1) {
+    perror("error: Unable to change working directory");
+    exit(1);
+  }
+
+  // Run apt-get update
+  execve(apt_argv[0], apt_argv, apt_envp);
+  perror("error: Unable to execute apt-get");
+  return 1;
+}
 
=== added directory 'dbus-1'
=== renamed directory 'dbus-1' => 'dbus-1.moved'
=== added file 'dbus-1/com.canonical.LandscapeClientRegistration.conf'
--- dbus-1/com.canonical.LandscapeClientRegistration.conf	1970-01-01 00:00:00 +0000
+++ dbus-1/com.canonical.LandscapeClientRegistration.conf	2014-11-19 18:22:39 +0000
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+"http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+  <type>system</type>
+  <policy user="root">
+    <allow own="com.canonical.LandscapeClientRegistration"/>
+    <allow send_destination="com.canonical.LandscapeClientRegistration"/>
+    <allow send_interface="com.canonical.LandscapeClientRegistration"/>
+  </policy>
+
+  <policy context="default">
+    <allow send_destination="com.canonical.LandscapeClientRegistration"/>
+    <allow send_interface="com.canonical.LandscapeClientRegistration"/>
+  </policy>
+</busconfig>
 
=== added file 'dbus-1/com.canonical.LandscapeClientRegistration.service'
--- dbus-1/com.canonical.LandscapeClientRegistration.service	1970-01-01 00:00:00 +0000
+++ dbus-1/com.canonical.LandscapeClientRegistration.service	2014-11-19 18:22:39 +0000
@@ -0,0 +1,4 @@
+[D-BUS Service]
+Name=com.canonical.LandscapeClientRegistration
+Exec=/usr/bin/landscape-client-registration-mechanism
+User=root
 \ No newline at end of file
 
=== added file 'dbus-1/com.canonical.LandscapeClientSettings.conf'
--- dbus-1/com.canonical.LandscapeClientSettings.conf	1970-01-01 00:00:00 +0000
+++ dbus-1/com.canonical.LandscapeClientSettings.conf	2014-11-19 18:22:39 +0000
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+"http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+  <type>system</type>
+  <policy user="root">
+    <allow own="com.canonical.LandscapeClientSettings"/>
+    <allow send_destination="com.canonical.LandscapeClientSettings"/>
+    <allow send_interface="com.canonical.LandscapeClientSettings"/>
+  </policy>
+
+  <policy context="default">
+    <allow send_destination="com.canonical.LandscapeClientSettings"/>
+    <allow send_interface="com.canonical.LandscapeClientSettings"/>
+  </policy>
+</busconfig>
 
=== added file 'dbus-1/com.canonical.LandscapeClientSettings.service'
--- dbus-1/com.canonical.LandscapeClientSettings.service	1970-01-01 00:00:00 +0000
+++ dbus-1/com.canonical.LandscapeClientSettings.service	2014-11-19 18:22:39 +0000
@@ -0,0 +1,4 @@
+[D-BUS Service]
+Name=com.canonical.LandscapeClientSettings
+Exec=/usr/bin/landscape-client-settings-mechanism
+User=root
 \ No newline at end of file
 
=== modified file 'debian/changelog'
--- debian/changelog	2012-06-19 15:12:07 +0000
+++ debian/changelog	2014-11-19 18:22:39 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 landscape-client (12.05-0ubuntu0.11.04) natty-proposed; urgency=low
 
   * New upstream release 12.05 (r561 in trunk) (LP: #1004678).
@@ -115,6 +116,84 @@
 
  -- Andreas Hasenack <[e-mail]>  Tue, 10 Apr 2012 14:14:16 -0300
 
+=======
+landscape-client (12.04.3-0ubuntu0.11.04) UNRELEASED; urgency=low
+
+  Tracking bug: LP: #978884
+
+  [ David Britton ]
+  * Warn on unicode entry into settings UI (LP: #956612).
+  * Sanitise hostname field in settings UI (LP: #954507).
+  * Make it clear that the Landscape service is commercial (LP: #965850)
+  * Further internationalize the settings UI (LP: #962899)
+  * Depend on python-aptdaemon.gtk3widgets instead of python-aptdaemon and
+    replace dependency on python-gobject by python-gi (LP: #961894)
+  * Add i18n to the landscape-client-ui-install script. (LP: #961891)
+
+  [ Andreas Hasenack ]
+  * Fix default landscape hostname in glib schema.
+  * dpkg test improvements to fix intermittent failures.
+  * If ssl_public_key is supplied, use it also when fetching script
+    attachments. This fixes the case of using script execution with
+    attachments when the Landscape server is using a custom CA,
+    most common in LDS deployments. (LP: #959846)
+  * Make sure we have a PATH variable set before doing package
+    activities, and also set it in the initscript for good measure. If
+    the client was configured and restarted by the new UI configuration
+    tool, PATH wasn't set, triggering an error in dpkg. (LP: #961190)
+  * Make landscape-client-ui depend on landscape-client-ui-install, so
+    that we get an entry in the system settings if just
+    landscape-client-ui is installed. The actual entry comes from
+    landscape-client-ui-install.
+  * Optimization: when adding binaries, don't reload every repo, only the one
+    containing the binaries. (LP: #954822)
+  * Handle the case where the user clicks twice inadvertently on the
+    Landscape icon in system settings and don't start a second copy of
+    itself. (LP: #960211)
+  * Change package management features to use APT instead of Smart (LP: #856244,
+    #861707, #859615, #861345, #863239, #863259, #865270, #865272, #865285,
+    #865273, #871641, #865299, #873196, #873939, #876493, #881973, #882438,
+    #866014, #881998, #884142, #884151, #884131, #887037, #886208, #887578,
+    #887947, #889067, #889069, #889087, #889099, #865303, #889113, #890605,
+    #890606, #890609, #897416, #891855, #898681, #898683, #897656, #898542,
+    #862212, #903202, #914734, #914735, #914737, #916301, #915280, #914742,
+    #918925, #918175, #919179, #921664, #921699, #922582, #922511, #921712,
+    #928750, #932136, #928941, #937411, #937567, #925543, #947803, #952973,
+    #948142, #953136, #953906, #956590).
+  * Add a GTK interface to configure the client (LP: #911279, #911666, #912163,
+    #911665, #916300, #931937, #931937, #943622, #945025, #911279, #944652,
+    #948464, #948416, #949158, #911671, #950864, #949208, #949147, #953070,
+    #953292, #953463, #953034, #949200, #953026, #954499, #954516, #954285,
+    #953065, #954414, #954332, #954542, #955966, #955139, #956030, #956119).
+  * Add the ability to auto discover the server location on local deployment
+    (LP: #917422, #927620, #917422, #928585, #929087, #932325, #948564)
+  * Allow the client to accept arbitrary environment variables from the
+    server for script execution (LP: #954999).
+  * Make landscape-config exit non-zero when registration fails and
+    --ok-no-register is not passed (LP: #271759).
+  * Check for the content of /sys/bus/xen/devices to report a machine as a Xen
+    VM instead of just relying on the existence of /sys/bus/xen (LP: #921970).
+  * Make sure cloud registration succeeds if there is no kernel specified in
+    the meta-data service (LP: #920453).
+  * Report private and public IP adresses from the metadata service at cloud
+    registration time (LP: #918366).
+  * Add support for reporting hardware information using lshw (LP: #899002,
+    #943975, #955734).
+  * Add support for the new attachment service in script execution
+    (LP: #893040).
+  * Adds a new message type, 'register-provisioned-machine', which is meant
+    to register computers using an OTP (LP: #881405).
+  * Add local cloning option for load testing (LP: #872830, #925924).
+  * Add more variables to preseeding (LP: #863204, #867710).
+  * Allow the configuration of the ping interval (LP: #397884).
+  * Add fake package reporters for load testing purposes (LP: #821571,
+    #821570).
+  * Report a package reporter error to the server if no APT sources are
+    configured, to trigger a package reporter alert (LP: #823769).
+
+ -- Andreas Hasenack <[e-mail]>  Tue, 10 Apr 2012 14:14:16 -0300
+
+>>>>>>> MERGE-SOURCE
 landscape-client (11.07.1.1-0ubuntu0.11.04.0) natty-proposed; urgency=low
 
   * Try to load the old persist file if the current one doesn't exist or is
 
=== modified file 'debian/control'
--- debian/control	2012-06-19 15:12:07 +0000
+++ debian/control	2014-11-19 18:22:39 +0000
@@ -3,8 +3,13 @@
 Priority: optional
 Maintainer: Ubuntu Developers <[e-mail]>
 XSBC-Original-Maintainer: Landscape Team <[e-mail]>
+<<<<<<< TREE
 Build-Depends: debhelper (>= 5), po-debconf, python-dev, python-central | python-support, lsb-release, gawk, python-twisted-core, python-distutils-extra
 Standards-Version: 3.8.2
+=======
+Build-Depends: debhelper (>= 5), po-debconf, python-dev, python-central | python-support, lsb-release, gawk, python-twisted-core, python-distutils-extra
+Standards-Version: 3.8.0
+>>>>>>> MERGE-SOURCE
 XS-Python-Version: >= 2.4, << 2.8
 
 Package: landscape-common
@@ -36,8 +41,13 @@
 Depends: ${python:Depends}, ${misc:Depends}, ${extra:Depends},
          ${shlibs:Depends},
          python-twisted-web,
+<<<<<<< TREE
          python-twisted-names,
          landscape-common (= ${binary:Version})
+=======
+         python-twisted-names,
+         landscape-common (>= ${Source-Version})
+>>>>>>> MERGE-SOURCE
 Suggests: ${extra:Suggests}
 Description: The Landscape administration system client
  Landscape is a web-based tool for managing Ubuntu systems. This
@@ -46,6 +56,7 @@
  .
  This package provides the Landscape client and requires a Landscape account.
 XB-Python-Version: ${python:Versions}
+<<<<<<< TREE
 
 Package: landscape-client-ui
 Architecture: any
@@ -76,3 +87,35 @@
  .
  This package provides an automatic installer for landscape-client-ui.
 XB-Python-Version: ${python:Versions}
+=======
+
+Package: landscape-client-ui
+Architecture: any
+Depends: ${python:Depends}, ${misc:Depends},
+         landscape-client (>= ${Source-Version}),
+         landscape-client-ui-install (>= ${Source-Version}),
+         python-gi,
+         python-dbus,
+         policykit-1,
+         gir1.2-notify-0.7,
+         gir1.2-gtk-3.0
+Description: The Landscape administration system client - UI configuration
+ Landscape is a web-based tool for managing Ubuntu systems.
+ .
+ This package provides the Landscape client configuration UI.
+XB-Python-Version: ${python:Versions}
+
+Package: landscape-client-ui-install
+Architecture: any
+Depends: ${python:Depends}, ${misc:Depends},
+         python-gi,
+         python-dbus,
+         policykit-1,
+         gir1.2-gtk-3.0,
+         python-aptdaemon.gtk3widgets
+Description: The Landscape administration system client - UI installer
+ Landscape is a web-based tool for managing Ubuntu systems.
+ .
+ This package provides an automatic installer for landscape-client-ui.
+XB-Python-Version: ${python:Versions}
+>>>>>>> MERGE-SOURCE
 
=== added file 'debian/landscape-client-ui-install.install'
--- debian/landscape-client-ui-install.install	1970-01-01 00:00:00 +0000
+++ debian/landscape-client-ui-install.install	2014-11-19 18:22:39 +0000
@@ -0,0 +1,4 @@
+usr/bin/landscape-client-ui-install
+usr/share/applications/landscape-client-settings.desktop
+usr/share/icons/hicolor/scalable/apps/preferences-management-service.svg
+usr/share/locale
 
=== renamed file 'debian/landscape-client-ui-install.install' => 'debian/landscape-client-ui-install.install.moved'
=== added file 'debian/landscape-client-ui.install'
--- debian/landscape-client-ui.install	1970-01-01 00:00:00 +0000
+++ debian/landscape-client-ui.install	2014-11-19 18:22:39 +0000
@@ -0,0 +1,9 @@
+usr/bin/landscape-client-settings-mechanism
+usr/bin/landscape-client-registration-mechanism
+usr/bin/landscape-client-settings-ui
+usr/share/dbus-1/system-services/com.canonical.LandscapeClientSettings.service
+usr/share/dbus-1/system-services/com.canonical.LandscapeClientRegistration.service
+usr/share/polkit-1/actions/com.canonical.LandscapeClientSettings.policy
+etc/dbus-1/system.d/com.canonical.LandscapeClientSettings.conf
+etc/dbus-1/system.d/com.canonical.LandscapeClientRegistration.conf
+usr/share/glib-2.0/schemas/com.canonical.landscape-client-settings.gschema.xml
 
=== renamed file 'debian/landscape-client-ui.install' => 'debian/landscape-client-ui.install.moved'
=== modified file 'debian/landscape-client.templates'
--- debian/landscape-client.templates	2012-06-19 15:12:07 +0000
+++ debian/landscape-client.templates	2014-11-19 18:22:39 +0000
@@ -17,6 +17,7 @@
  needed if the given account is requesting a client registration
  password.
 
+<<<<<<< TREE
 Template: landscape-client/url
 Type: string
 Default: https://landscape.canonical.com/message-system
@@ -69,6 +70,60 @@
  first registration.  Once the machine is registered, these tags can only be
  changed using the Landscape server.
 
+=======
+Template: landscape-client/url
+Type: string
+Default: https://landscape.canonical.com/message-system
+_Description: Landscape Server URL:
+ The server URL to connect to.
+
+Template: landscape-client/exchange_interval
+Type: string
+Default: 900
+_Description: Message Exchange Interval:
+ Interval, in seconds, between normal message exchanges with the Landscape
+ server.
+
+Template: landscape-client/urgent_exchange_interval
+Type: string
+Default: 60
+_Description: Urgent Message Exchange Interval:
+ Interval, in seconds, between urgent message exchanges with the Landscape
+ server.
+
+Template: landscape-client/ping_url
+Type: string
+Default: http://landscape.canonical.com/ping
+_Description: Landscape PingServer URL:
+ The URL to perform lightweight exchange initiation with.
+
+Template: landscape-client/ping_interval
+Type: string
+Default: 30
+_Description: Ping Interval:
+ Interval, in seconds, between client ping exchanges with the Landscape server.
+
+Template: landscape-client/http_proxy
+Type: string
+Default:
+_Description: HTTP proxy (blank for none):
+ The URL of the HTTP proxy, if one is needed.
+
+Template: landscape-client/https_proxy
+Type: string
+Default:
+_Description: HTTPS proxy (blank for none):
+ The URL of the HTTPS proxy, if one is needed.
+
+Template: landscape-client/tags
+Type: string
+Default:
+_Description: Initial tags for first registration
+ Comma separated list of tags which will be assigned to this computer on its
+ first registration.  Once the machine is registered, these tags can only be
+ changed using the Landscape server.
+
+>>>>>>> MERGE-SOURCE
 Template: landscape-client/register_system
 Type: boolean
 Default: false
 
=== modified file 'debian/po/templates.pot'
--- debian/po/templates.pot	2012-06-19 15:12:07 +0000
+++ debian/po/templates.pot	2014-11-19 18:22:39 +0000
@@ -8,7 +8,11 @@
 msgstr ""
 "Project-Id-Version: landscape-client\n"
 "Report-Msgid-Bugs-To: [e-mail]\n"
+<<<<<<< TREE
 "POT-Creation-Date: 2012-06-01 18:35-0300\n"
+=======
+"POT-Creation-Date: 2012-03-07 17:07+0100\n"
+>>>>>>> MERGE-SOURCE
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <[e-mail]>\n"
@@ -59,6 +63,7 @@
 "if the given account is requesting a client registration password."
 msgstr ""
 
+<<<<<<< TREE
 #. Type: string
 #. Description
 #: ../landscape-client.templates:4001
@@ -164,6 +169,113 @@
 "changed using the Landscape server."
 msgstr ""
 
+=======
+#. Type: string
+#. Description
+#: ../landscape-client.templates:4001
+msgid "Landscape Server URL:"
+msgstr ""
+
+#. Type: string
+#. Description
+#: ../landscape-client.templates:4001
+msgid "The server URL to connect to."
+msgstr ""
+
+#. Type: string
+#. Description
+#: ../landscape-client.templates:5001
+msgid "Message Exchange Interval:"
+msgstr ""
+
+#. Type: string
+#. Description
+#: ../landscape-client.templates:5001
+msgid ""
+"Interval, in seconds, between normal message exchanges with the Landscape "
+"server."
+msgstr ""
+
+#. Type: string
+#. Description
+#: ../landscape-client.templates:6001
+msgid "Urgent Message Exchange Interval:"
+msgstr ""
+
+#. Type: string
+#. Description
+#: ../landscape-client.templates:6001
+msgid ""
+"Interval, in seconds, between urgent message exchanges with the Landscape "
+"server."
+msgstr ""
+
+#. Type: string
+#. Description
+#: ../landscape-client.templates:7001
+msgid "Landscape PingServer URL:"
+msgstr ""
+
+#. Type: string
+#. Description
+#: ../landscape-client.templates:7001
+msgid "The URL to perform lightweight exchange initiation with."
+msgstr ""
+
+#. Type: string
+#. Description
+#: ../landscape-client.templates:8001
+msgid "Ping Interval:"
+msgstr ""
+
+#. Type: string
+#. Description
+#: ../landscape-client.templates:8001
+msgid ""
+"Interval, in seconds, between client ping exchanges with the Landscape "
+"server."
+msgstr ""
+
+#. Type: string
+#. Description
+#: ../landscape-client.templates:9001
+msgid "HTTP proxy (blank for none):"
+msgstr ""
+
+#. Type: string
+#. Description
+#: ../landscape-client.templates:9001
+msgid "The URL of the HTTP proxy, if one is needed."
+msgstr ""
+
+#. Type: string
+#. Description
+#: ../landscape-client.templates:10001
+msgid "HTTPS proxy (blank for none):"
+msgstr ""
+
+#. Type: string
+#. Description
+#: ../landscape-client.templates:10001
+msgid "The URL of the HTTPS proxy, if one is needed."
+msgstr ""
+
+#. Type: string
+#. Description
+#: ../landscape-client.templates:11001
+msgid "Initial tags for first registration"
+msgstr ""
+
+#. Type: string
+#. Description
+#: ../landscape-client.templates:11001
+msgid ""
+"Comma separated list of tags which will be assigned to this computer on its "
+"first registration.  Once the machine is registered, these tags can only be "
+"changed using the Landscape server."
+msgstr ""
+
+>>>>>>> MERGE-SOURCE
 #. Type: boolean
 #. Description
 #: ../landscape-client.templates:12001
@@ -172,6 +284,7 @@
 
 #. Type: boolean
 #. Description
+<<<<<<< TREE
 #: ../landscape-client.templates:12001
 msgid ""
 "Register this system with a preexisting Landscape account.  Please go to "
@@ -212,6 +325,26 @@
 #. this will break the choices shown to users
 #: ../landscape-common.templates:1001
 msgid "Run sysinfo on every login"
+=======
+#: ../landscape-client.templates:12001
+msgid ""
+"Register this system with a preexisting Landscape account.  Please go to "
+"http://landscape.canonical.com if you need a Landscape account."
+msgstr ""
+
+#. Type: select
+#. Choices
+#. Translators beware! the following three strings form a single
+#. Choices menu. - Every one of these strings has to fit in a standard
+#. 80 characters console, as the fancy screen setup takes up some space
+#. try to keep below ~71 characters.
+#. DO NOT USE commas (,) in Choices translations otherwise
+#. this will break the choices shown to users
+#: ../landscape-common.templates:1001
+msgid ""
+"Do not display sysinfo on login, Cache sysinfo in /etc/motd, Run sysinfo on "
+"every login"
+>>>>>>> MERGE-SOURCE
 msgstr ""
 
 #. Type: select
 
=== modified file 'debian/rules'
--- debian/rules	2012-06-19 15:12:07 +0000
+++ debian/rules	2014-11-19 18:22:39 +0000
@@ -2,6 +2,7 @@
 
 dist_release := $(shell lsb_release -cs)
 ifneq ($(dist_release),dapper)
+<<<<<<< TREE
 	use_pycentral = yes
 endif
 ifeq (,$(filter $(dist_release), hardy lucid))
@@ -12,6 +13,18 @@
 ifeq (,$(filter $(dist_release),hardy lucid natty oneiric))
 	# We want landscape-client-ui only from precise onward
 	dh_extra_flags += -plandscape-client-ui -plandscape-client-ui-install
+=======
+	use_pycentral = yes
+endif
+ifeq (,$(filter $(dist_release), hardy lucid))
+	use_dhpython2 = yes
+endif
+
+dh_extra_flags = -plandscape-common -plandscape-client
+ifneq (,$(filter $(dist_release),precise))
+	# We want landscape-client-ui only from precise onward
+	dh_extra_flags += -plandscape-client-ui -plandscape-client-ui-install
+>>>>>>> MERGE-SOURCE
 endif
 
 -include /usr/share/python/python.mk
 
=== added file 'dev/dns-server'
--- dev/dns-server	1970-01-01 00:00:00 +0000
+++ dev/dns-server	2014-11-19 18:22:39 +0000
@@ -0,0 +1,99 @@
+#!/usr/bin/env python
+"""
+This script creates a DNS server that has enough functionality to test
+the server autodiscovery feature of landscape client.
+
+Landscape client uses /etc/resolv.conf to find the location of name servers.
+To have landscape client use this server, make sure that:
+
+nameserver 127.0.0.1
+
+is the first nameserver in /etc/resolv.conf.  Linux name lookups only support
+port 53, so this program must run on port 53 in order to work.  Be aware that
+NetworkManager overwrites this file any time your network configuration
+changes.
+
+This program does not return enough information for a tool like dig to complete
+successfully.  If this is needed, use Bind 9, detailed at
+https://wiki.canonical.com/Landscape/SpecRegistry/0082
+"""
+
+import argparse
+import sys
+from twisted.internet import reactor, defer
+from twisted.names import dns, common
+from twisted.names.server import DNSServerFactory
+
+
+PORT = 5553
+SRV_RESPONSE = 'lds1.mylandscapehost.com'
+A_RESPONSE = '127.0.0.1'
+
+
+class SimpleResolver(common.ResolverBase):
+    def _lookup(self, name, cls, typ, timeout):
+        """
+        Respond to DNS requests.  See documentation for
+        L{twisted.names.common.ResolverBase}.
+        """
+        # This nameserver returns the same result all the time, regardless
+        # of what name the client asks for.
+        results = []
+        ttl = 60
+        if typ == dns.SRV:
+            record = dns.Record_SRV(0, 1, 80, SRV_RESPONSE, ttl)
+            owner = '_landscape._tcp.mylandscapehost.com'
+            results.append(dns.RRHeader(owner, record.TYPE, dns.IN, ttl,
+                                        record, auth=True))
+        elif typ == dns.A:
+            record = dns.Record_A(A_RESPONSE)
+            owner = 'landscape.localdomain'
+            results.append(dns.RRHeader(owner, record.TYPE, dns.IN, ttl,
+                                        record, auth=True))
+
+        authority = []
+        return defer.succeed((results, authority, []))
+
+
+def parse_command_line(args):
+    global SRV_RESPONSE, A_RESPONSE, PORT
+    description = """
+    This test tool responds to DNS queries for SRV and A records.  It always
+    responds with the same result regardless of the query string sent by the
+    client.
+
+    To test this tool, try the following commands:
+    dig -p 5553 @127.0.0.1 SRV _landscape._tcp.mylandscapehost.com
+
+    dig -p 5553 @127.0.0.1 localhost.localdomain
+    """
+    parser = argparse.ArgumentParser(description=description)
+    parser.add_argument("--srv-response", type=str, default=SRV_RESPONSE,
+                        help="Give this reply to SRV queries (eg: localhost)")
+    parser.add_argument("--a-response", type=str, default=A_RESPONSE,
+                        help="Give this reply to A queries (eg: 127.0.0.1)")
+    parser.add_argument("--port", type=int, default=PORT,
+                        help="Listen on this port (default 5553).  DNS "
+                        "normally runs on port 53")
+
+    args = vars(parser.parse_args())
+    SRV_RESPONSE = args["srv_response"]
+    A_RESPONSE = args["a_response"]
+    PORT = args["port"]
+
+
+def main():
+    parse_command_line(sys.argv)
+
+    simple_resolver = SimpleResolver()
+    factory = DNSServerFactory(authorities=[simple_resolver], verbose=1)
+    protocol = dns.DNSDatagramProtocol(factory)
+    print "starting reactor on port %s.." % PORT
+    reactor.listenTCP(PORT, factory)
+    reactor.listenUDP(PORT, protocol)
+    reactor.run()
+    print "reactor stopped..."
+
+
+if __name__ == "__main__":
+    main()
 
=== renamed file 'dev/dns-server' => 'dev/dns-server.moved'
=== added directory 'glib-2.0'
=== renamed directory 'glib-2.0' => 'glib-2.0.moved'
=== added directory 'glib-2.0/schemas'
=== added file 'glib-2.0/schemas/com.canonical.landscape-client-settings.gschema.xml'
--- glib-2.0/schemas/com.canonical.landscape-client-settings.gschema.xml	1970-01-01 00:00:00 +0000
+++ glib-2.0/schemas/com.canonical.landscape-client-settings.gschema.xml	2014-11-19 18:22:39 +0000
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?>
+<schemalist>
+  <schema id="com.canonical.landscape-client-settings" path="/com/canonical/landscape-client-settings/">
+    <key type="s" name="management-type">
+      <default>"not"</default>
+      <summary>Whether the client settings UI currently set to a hosted client configuration, an LDS instance or no management service.</summary>
+    </key>
+    <key type="s" name="computer-title">
+      <default>""</default>
+      <summary>The title to register the machine with.</summary>
+    </key>
+    <key type="s" name="hosted-landscape-host">
+      <default>"landscape.canonical.com"</default>
+      <summary>The hostname of the Canonical hosted landscape system.</summary>
+    </key>
+    <key type="s" name="hosted-account-name">
+      <default>""</default>
+      <summary>An account name for use with the Canonical hosted landscape system.</summary>
+    </key>
+    <key type="s" name="hosted-password">
+      <default>""</default>
+      <summary>A password for use with the Canonical hosted landscape system</summary>
+    </key>
+    <key type="s" name="local-landscape-host">
+      <default>""</default>
+      <summary>The hostname of the local landscape system.</summary>
+    </key>
+    <key type="s" name="local-account-name">
+      <default>""</default>
+      <summary>An account name for use with the local landscape system.</summary>
+    </key>
+    <key type="s" name="local-password">
+      <default>""</default>
+      <summary>A password for use with the local landscape system</summary>
+    </key>
+  </schema>
+</schemalist>
 
=== added directory 'icons'
=== renamed directory 'icons' => 'icons.moved'
=== added file 'icons/preferences-management-service.svg'
--- icons/preferences-management-service.svg	1970-01-01 00:00:00 +0000
+++ icons/preferences-management-service.svg	2014-11-19 18:22:39 +0000
@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Generator: Adobe Illustrator 14.0.0, SVG Export Plug-In  -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   version="1.1"
+   x="0px"
+   y="0px"
+   width="32"
+   height="32"
+   viewBox="-0.787 -0.867 32 32"
+   enable-background="new -0.787 -0.867 285 285"
+   xml:space="preserve"
+   id="svg2"
+   inkscape:version="0.48.2 r9819"
+   sodipodi:docname="canonical_aubergine_hex.svg"><metadata
+   id="metadata12"><rdf:RDF><cc:Work
+       rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
+         rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><sodipodi:namedview
+   pagecolor="#ffffff"
+   bordercolor="#666666"
+   borderopacity="1"
+   objecttolerance="10"
+   gridtolerance="10"
+   guidetolerance="10"
+   inkscape:pageopacity="0"
+   inkscape:pageshadow="2"
+   inkscape:window-width="697"
+   inkscape:window-height="480"
+   id="namedview10"
+   showgrid="false"
+   fit-margin-top="0"
+   fit-margin-left="0"
+   fit-margin-right="0"
+   fit-margin-bottom="0"
+   inkscape:zoom="7.38"
+   inkscape:cx="15.9035"
+   inkscape:cy="16.176"
+   inkscape:window-x="449"
+   inkscape:window-y="100"
+   inkscape:window-maximized="0"
+   inkscape:current-layer="svg2" />
+<defs
+   id="defs4">
+</defs>
+<path
+   d="m 15.21339,25.32101 c -5.62692,0 -10.18809,-4.55982 -10.18809,-10.18812 0,-5.62706 4.56117,-10.18768 10.18809,-10.18768 5.62705,0 10.18798,4.56062 10.18798,10.18768 0,5.6283 -4.56082,10.18812 -10.18798,10.18812 z"
+   id="path6"
+   inkscape:connector-curvature="0"
+   style="fill:#772953" />
+<path
+   d="M 31.213,15.13334 C 31.213,23.96956 24.04959,31.133 15.21294,31.133 6.37607,31.133 -0.787,23.96945 -0.787,15.13334 -0.787,6.29621 6.37607,-0.867 15.21306,-0.867 24.04959,-0.867 31.213,6.29621 31.213,15.13334 z M 15.21306,3.025 c -6.68751,0 -12.10774,5.42115 -12.10774,12.10823 0,6.68809 5.42023,12.10755 12.10774,12.10755 6.68773,0 12.10796,-5.41946 12.10796,-12.10755 C 27.32102,8.44615 21.90079,3.025 15.21306,3.025 z"
+   id="path8"
+   inkscape:connector-curvature="0"
+   style="fill:#772953" />
+</svg>
 \ No newline at end of file
 
=== modified file 'landscape/__init__.py'
--- landscape/__init__.py	2012-06-19 15:12:07 +0000
+++ landscape/__init__.py	2014-11-19 18:22:39 +0000
@@ -1,7 +1,11 @@
 import sys
 
 DEBIAN_REVISION = ""
+<<<<<<< TREE
 UPSTREAM_VERSION = "12.05"
+=======
+UPSTREAM_VERSION = "12.04.3"
+>>>>>>> MERGE-SOURCE
 VERSION = "%s%s" % (UPSTREAM_VERSION, DEBIAN_REVISION)
 
 # The "server-api" field of outgoing messages will be set to this value, and
 
=== modified file 'landscape/constants.py'
=== modified file 'landscape/deployment.py'
--- landscape/deployment.py	2012-06-19 15:12:07 +0000
+++ landscape/deployment.py	2014-11-19 18:22:39 +0000
@@ -282,6 +282,7 @@
               - C{quiet} (C{False})
               - C{log_dir} (C{"/var/log/landscape"})
               - C{log_level} (C{"info"})
+<<<<<<< TREE
               - C{url} (C{"http://landscape.canonical.com/message-system"})
               - C{ping_url} (C{"http://landscape.canonical.com/ping"})
               - C{ssl_public_key}
@@ -289,6 +290,15 @@
               - C{autodiscover_srv_query_string}
                     (C{"_tcp._landscape.localdomain"})
               - C{autodiscover_a_query_string} (C{"landscape.localdomain"})
+=======
+              - C{url} (C{"http://landcape.canonical.com/message-system"})
+              - C{ping_url} (C{"http://landscape.canonical.com/ping"})
+              - C{ssl_public_key}
+              - C{server_autodiscover} (C{"false"})
+              - C{autodiscover_srv_query_string}
+                    (C{"_tcp._landscape.localdomain"})
+              - C{autodiscover_a_query_string} (C{"landscape.localdomain"})
+>>>>>>> MERGE-SOURCE
               - C{ignore_sigint} (C{False})
         """
         parser = super(Configuration, self).make_parser()
 
=== added file 'landscape/lib/dns.py'
--- landscape/lib/dns.py	1970-01-01 00:00:00 +0000
+++ landscape/lib/dns.py	2014-11-19 18:22:39 +0000
@@ -0,0 +1,78 @@
+"""DNS lookups for server autodiscovery."""
+
+import logging
+from twisted.names import dns
+from twisted.names.client import Resolver
+
+
+def discover_server(autodiscover_srv_query_string="",
+                    autodiscover_a_query_string="", resolver=None):
+    """
+    Look up the dns location of the landscape server.
+
+    @param autodiscover_srv_query_string: The query string to send to the DNS
+        server when making a SRV query.
+    @param autodiscover_a_query_string: The query string to send to the DNS
+        server when making a A query.
+    @type resolver: The resolver to use.  If none is specified a resolver that
+        uses settings from /etc/resolv.conf will be created. (Testing only)
+    """
+    if not resolver:
+        resolver = Resolver("/etc/resolv.conf")
+    d = _lookup_server_record(resolver, autodiscover_srv_query_string)
+    d.addErrback(_lookup_hostname, resolver, autodiscover_a_query_string)
+    return d
+
+
+def _lookup_server_record(resolver, service_name):
+    """
+    Do a DNS SRV record lookup for the location of the landscape server.
+
+    @type resolver: A resolver to use for DNS lookups
+        L{twisted.names.client.Resolver}.
+    @param service_name: The query string to send to the DNS server when
+        making a SRV query.
+    @return: A deferred containing either the hostname of the landscape server
+        if found or an empty string if not found.
+    """
+    def lookup_done(result):
+        name = ""
+        for item in result:
+            for row in item:
+                if row.type == dns.SRV:
+                    name = row.payload.target.name
+                    break
+        return name
+
+    def lookup_failed(result):
+        logging.info("SRV lookup of %s failed." % service_name)
+        return result
+
+    d = resolver.lookupService(service_name)
+    d.addCallback(lookup_done)
+    d.addErrback(lookup_failed)
+    return d
+
+
+def _lookup_hostname(result, resolver, hostname):
+    """
+    Do a DNS name lookup for the location of the landscape server.
+
+    @param result: The result from a call to lookup_server_record.
+    @param resolver: The resolver to use for DNS lookups.
+    @param hostname: The query string to send to the DNS server when making
+        a A query.
+    @param return: A deferred containing the ip address of the landscape
+        server if found or None if not found.
+    """
+    def lookup_done(result):
+        return result
+
+    def lookup_failed(result):
+        logging.info("Name lookup of %s failed." % hostname)
+        return result
+
+    d = resolver.getHostByName(hostname)
+    d.addCallback(lookup_done)
+    d.addErrback(lookup_failed)
+    return d
 
=== renamed file 'landscape/lib/dns.py' => 'landscape/lib/dns.py.moved'
=== added file 'landscape/lib/tests/test_dns.py'
--- landscape/lib/tests/test_dns.py	1970-01-01 00:00:00 +0000
+++ landscape/lib/tests/test_dns.py	2014-11-19 18:22:39 +0000
@@ -0,0 +1,208 @@
+from landscape.tests.helpers import LandscapeTest
+from landscape.lib.dns import (
+    _lookup_server_record, _lookup_hostname, discover_server)
+
+from twisted.internet import defer
+from twisted.names import dns
+from twisted.names.error import ResolverError
+
+
+class FakeResolverResult(object):
+    """
+    A fake resolver result returned by L{FakeResolver}.
+
+    @param type: The result type L{twisted.names.dns.SRV}
+    @param payload: The result contents
+    """
+    def __init__(self):
+        self.type = None
+
+        class Payload(object):
+            """
+            A payload result returned by fake resolver.
+
+            @param target: The result of the lookup
+            """
+            def __init__(self):
+                self.target = ""
+
+        class Target(object):
+            """
+            A payload target returned by fake resolver.
+
+            @param name: The name contained by the target.
+            """
+            def __init__(self):
+                self.name = ""
+
+        self.payload = Payload()
+        self.payload.target = Target()
+
+
+class FakeResolver(object):
+    """
+    A fake resolver that mimics L{twisted.names.client.Resolver}
+    """
+    def __init__(self):
+        self.results = None
+        self.name = None
+        self.queried = None
+
+    def lookupService(self, arg1):
+        self.queried = arg1
+        deferred = defer.Deferred()
+        deferred.callback(self.results)
+        return deferred
+
+    def getHostByName(self, arg1):
+        self.queried = arg1
+        deferred = defer.Deferred()
+        deferred.callback(self.name)
+        return deferred
+
+
+class BadResolver(object):
+    """
+    A resolver that mimics L{twisted.names.client.Resolver} and always returns
+    an error.
+    """
+    def lookupService(self, arg1):
+        deferred = defer.Deferred()
+        deferred.errback(ResolverError("Couldn't connect"))
+        return deferred
+
+    def getHostByName(self, arg1):
+        deferred = defer.Deferred()
+        deferred.errback(ResolverError("Couldn't connect"))
+        return deferred
+
+
+class DnsSrvLookupTest(LandscapeTest):
+    def test_with_server_found(self):
+        """
+        Looking up a DNS SRV record should return the result of the lookup.
+        """
+        fake_result = FakeResolverResult()
+        fake_result.type = dns.SRV
+        fake_result.payload.target.name = "a.b.com"
+        fake_resolver = FakeResolver()
+        fake_resolver.results = [[fake_result]]
+        query_string = "_landscape._tcp.mylandscapehost.com"
+
+        def check(result):
+            self.assertEqual(fake_resolver.queried, query_string)
+            self.assertEqual("a.b.com", result)
+
+        d = _lookup_server_record(fake_resolver, query_string)
+        d.addCallback(check)
+        return d
+
+    def test_with_server_not_found(self):
+        """
+        Looking up a DNS SRV record and finding nothing exists should return
+        an empty string.
+        """
+        fake_resolver = FakeResolver()
+        fake_resolver.results = [[]]
+
+        def check(result):
+            self.assertEqual("", result)
+
+        d = _lookup_server_record(fake_resolver,
+                                 "_landscape._tcp.mylandscapehost.com")
+        d.addCallback(check)
+        return d
+
+    def test_with_resolver_error(self):
+        """A resolver error triggers error handling code."""
+        # The failure should be properly logged
+        logging_mock = self.mocker.replace("logging.info")
+        logging_mock("SRV lookup of _landscape._tcp.mylandscapehost.com "
+                     "failed.")
+        self.mocker.replay()
+
+        d = _lookup_server_record(BadResolver(),
+                                 "_landscape._tcp.mylandscapehost.com")
+        self.assertFailure(d, ResolverError)
+        return d
+
+
+class DnsNameLookupTest(LandscapeTest):
+    def test_with_name_found(self):
+        """
+        Looking up a DNS name record should return the result of the lookup.
+        """
+        fake_resolver = FakeResolver()
+        fake_resolver.name = "a.b.com"
+        query_string = "landscape.localdomain"
+
+        def check(result):
+            self.assertEqual(fake_resolver.queried, query_string)
+            self.assertEqual("a.b.com", result)
+
+        d = _lookup_hostname(None, fake_resolver, query_string)
+        d.addCallback(check)
+        return d
+
+    def test_with_name_not_found(self):
+        """
+        Looking up a DNS NAME record and not finding a result should return
+        None.
+        """
+        fake_resolver = FakeResolver()
+        fake_resolver.name = None
+
+        def check(result):
+            self.assertEqual(None, result)
+
+        d = _lookup_hostname(None, fake_resolver, "landscape.localdomain")
+        d.addCallback(check)
+        return d
+
+    def test_with_resolver_error(self):
+        """A resolver error triggers error handling code."""
+        # The failure should be properly logged
+        logging_mock = self.mocker.replace("logging.info")
+        logging_mock("Name lookup of landscape.localdomain failed.")
+        self.mocker.replay()
+
+        d = _lookup_hostname(None, BadResolver(), "landscape.localdomain")
+        self.assertFailure(d, ResolverError)
+        return d
+
+
+class DiscoverServerTest(LandscapeTest):
+    def test_srv_lookup(self):
+        """The DNS name of the server is found using a SRV lookup."""
+        fake_result = FakeResolverResult()
+        fake_result.type = dns.SRV
+        fake_result.payload.target.name = "a.b.com"
+        fake_resolver = FakeResolver()
+        fake_resolver.results = [[fake_result]]
+
+        d = discover_server(resolver=fake_resolver)
+
+        def check(result):
+            self.assertEqual("a.b.com", result)
+
+        d.addCallback(check)
+        return d
+
+    def test_a_name_lookup(self):
+        """The DNS name of the server is found using an A name lookup."""
+        fake_resolver = FakeResolver()
+        fake_resolver.name = "x.y.com"
+
+        d = discover_server(resolver=fake_resolver)
+
+        def check(result):
+            self.assertEqual("x.y.com", result)
+
+        d.addCallback(check)
+        return d
+
+    def test_failed_lookup(self):
+        """A resolver error is returned when server autodiscovery fails."""
+        d = _lookup_server_record(BadResolver(), "landscape.localdomain")
+        self.assertFailure(d, ResolverError)
+        return d
 
=== renamed file 'landscape/lib/tests/test_dns.py' => 'landscape/lib/tests/test_dns.py.moved'
=== added file 'landscape/manager/fakepackagemanager.py'
--- landscape/manager/fakepackagemanager.py	1970-01-01 00:00:00 +0000
+++ landscape/manager/fakepackagemanager.py	2014-11-19 18:22:39 +0000
@@ -0,0 +1,57 @@
+import logging
+import os
+import random
+
+from twisted.internet.utils import getProcessOutput
+from twisted.internet.defer import succeed
+
+from landscape.package.store import PackageStore
+from landscape.package.changer import PackageChanger
+from landscape.package.releaseupgrader import ReleaseUpgrader
+from landscape.manager.plugin import ManagerPlugin
+from landscape.manager.manager import SUCCEEDED
+
+
+class FakePackageManager(ManagerPlugin):
+
+    run_interval = 1800
+    randint = random.randint
+
+    def register(self, registry):
+        super(FakePackageManager, self).register(registry)
+        self.config = registry.config
+
+        registry.register_message("change-packages",
+                                  self.handle_change_packages)
+        registry.register_message("change-package-locks",
+                                  self.handle_change_package_locks)
+        registry.register_message("release-upgrade",
+                                  self.handle_release_upgrade)
+
+    def _handle(self, response):
+        delay = self.randint(30, 300)
+        self.registry.reactor.call_later(
+            delay, self.manager.broker.send_message, response, urgent=True)
+
+    def handle_change_packages(self, message):
+        response = {"type": "change-packages-result",
+                    "operation-id": message.get("operation-id"),
+                    "result-code": 1,
+                    "result-text": "OK done."}
+        return self._handle(response)
+
+    def handle_change_package_locks(self, message):
+        response = {"type": "operation-result",
+                    "operation-id": message.get("operation-id"),
+                    "status": SUCCEEDED,
+                    "result-text": "Package locks successfully changed.",
+                    "result-code": 0}
+        return self._handle(response)
+
+    def handle_release_upgrade(self, message):
+        response = {"type": "operation-result",
+                    "operation-id": message.get("operation-id"),
+                    "status": SUCCEEDED,
+                    "result-text": "Successful release upgrade.",
+                    "result-code": 0}
+        return self._handle(response)
 
=== renamed file 'landscape/manager/fakepackagemanager.py' => 'landscape/manager/fakepackagemanager.py.moved'
=== added file 'landscape/manager/hardwareinfo.py'
--- landscape/manager/hardwareinfo.py	1970-01-01 00:00:00 +0000
+++ landscape/manager/hardwareinfo.py	2014-11-19 18:22:39 +0000
@@ -0,0 +1,28 @@
+import os
+
+from twisted.internet.utils import getProcessOutput
+
+from landscape.manager.plugin import ManagerPlugin
+
+
+class HardwareInfo(ManagerPlugin):
+    """A plugin to retrieve hardware information."""
+
+    message_type = "hardware-info"
+    run_interval = 60 * 60 * 24
+    run_immediately = True
+    command = "/usr/bin/lshw"
+
+    def run(self):
+        self.call_on_accepted(self.message_type, self.send_message)
+        return self.registry.broker.call_if_accepted(
+                self.message_type, self.send_message)
+
+    def send_message(self):
+        result = getProcessOutput(
+            self.command, args=["-xml", "-quiet"], env=os.environ, path=None)
+        return result.addCallback(self._got_output)
+
+    def _got_output(self, output):
+        message = {"type": self.message_type, "data": output}
+        return self.registry.broker.send_message(message)
 
=== renamed file 'landscape/manager/hardwareinfo.py' => 'landscape/manager/hardwareinfo.py.moved'
=== modified file 'landscape/manager/tests/test_aptsources.py'
=== added file 'landscape/manager/tests/test_fakepackagemanager.py'
--- landscape/manager/tests/test_fakepackagemanager.py	1970-01-01 00:00:00 +0000
+++ landscape/manager/tests/test_fakepackagemanager.py	2014-11-19 18:22:39 +0000
@@ -0,0 +1,70 @@
+from landscape.manager.plugin import SUCCEEDED
+
+from landscape.manager.fakepackagemanager import FakePackageManager
+from landscape.tests.helpers import LandscapeTest, ManagerHelper
+
+
+class FakePackageManagerTest(LandscapeTest):
+    """Tests for the fake package manager plugin."""
+
+    helpers = [ManagerHelper]
+
+    def setUp(self):
+        super(FakePackageManagerTest, self).setUp()
+        self.package_manager = FakePackageManager()
+        self.package_manager.randint = lambda x, y: 0
+
+    def test_handle_change_packages(self):
+        """
+        L{FakePackageManager} is able to handle a C{change-packages} message,
+        creating a C{change-packages-result} in response.
+        """
+        self.manager.add(self.package_manager)
+        service = self.broker_service
+        service.message_store.set_accepted_types(["change-packages-result"])
+        message = {"type": "change-packages", "operation-id": 1}
+        self.manager.dispatch_message(message)
+        self.manager.reactor.advance(1)
+
+        self.assertMessages(service.message_store.get_pending_messages(),
+                            [{"type": "change-packages-result",
+                              "result-text": "OK done.",
+                              "result-code": 1, "operation-id": 1}])
+
+    def test_handle_change_package_locks(self):
+        """
+        L{FakePackageManager} is able to handle a C{change-package-locks}
+        message, creating a C{operation-result} in response.
+        """
+        self.manager.add(self.package_manager)
+        service = self.broker_service
+        service.message_store.set_accepted_types(["operation-result"])
+        message = {"type": "change-package-locks", "operation-id": 1}
+        self.manager.dispatch_message(message)
+        self.manager.reactor.advance(1)
+
+        self.assertMessages(service.message_store.get_pending_messages(),
+                            [{"type": "operation-result",
+                              "result-text":
+                                  "Package locks successfully changed.",
+                              "result-code": 0, "status": SUCCEEDED,
+                              "operation-id": 1}])
+
+    def test_handle_release_upgrade(self):
+        """
+        L{FakePackageManager} is able to handle a C{release-upgrade} message,
+        creating a C{operation-result} in response.
+        """
+        self.manager.add(self.package_manager)
+        service = self.broker_service
+        service.message_store.set_accepted_types(["operation-result"])
+        message = {"type": "release-upgrade", "operation-id": 1}
+        self.manager.dispatch_message(message)
+        self.manager.reactor.advance(1)
+
+        self.assertMessages(service.message_store.get_pending_messages(),
+                            [{"type": "operation-result",
+                              "result-text":
+                                  "Successful release upgrade.",
+                              "result-code": 0, "status": SUCCEEDED,
+                              "operation-id": 1}])
 
=== renamed file 'landscape/manager/tests/test_fakepackagemanager.py' => 'landscape/manager/tests/test_fakepackagemanager.py.moved'
=== added file 'landscape/manager/tests/test_hardwareinfo.py'
--- landscape/manager/tests/test_hardwareinfo.py	1970-01-01 00:00:00 +0000
+++ landscape/manager/tests/test_hardwareinfo.py	2014-11-19 18:22:39 +0000
@@ -0,0 +1,45 @@
+from landscape.tests.helpers import LandscapeTest, ManagerHelper
+
+from landscape.manager.hardwareinfo import HardwareInfo
+
+
+class HardwareInfoTests(LandscapeTest):
+    helpers = [ManagerHelper]
+
+    def setUp(self):
+        super(HardwareInfoTests, self).setUp()
+        self.info = HardwareInfo()
+        self.info.command = "/bin/echo"
+        self.manager.add(self.info)
+
+        service = self.broker_service
+        service.message_store.set_accepted_types(["hardware-info"])
+
+    def test_message(self):
+        """
+        L{HardwareInfo} sends the output of its command when running.
+        """
+        deferred = self.info.send_message()
+
+        def check(ignored):
+            self.assertMessages(
+                self.broker_service.message_store.get_pending_messages(),
+                [{"data": u"-xml -quiet\n", "type": "hardware-info"}])
+
+        return deferred.addCallback(check)
+
+    def test_run_upgraded_system(self):
+        """
+        L{HardwareInfo} sends the output of its command when running on
+        a system that has been upgraded to include this plugin, i.e.
+        where the client already knows that it can send the
+        hardware-info message.
+        """
+        deferred = self.info.run()
+
+        def check(ignored):
+            self.assertMessages(
+                self.broker_service.message_store.get_pending_messages(),
+                [{"data": u"-xml -quiet\n", "type": "hardware-info"}])
+
+        return deferred.addCallback(check)
 
=== renamed file 'landscape/manager/tests/test_hardwareinfo.py' => 'landscape/manager/tests/test_hardwareinfo.py.moved'
=== modified file 'landscape/monitor/packagemonitor.py'
--- landscape/monitor/packagemonitor.py	2012-06-19 15:12:07 +0000
+++ landscape/monitor/packagemonitor.py	2014-11-19 18:22:39 +0000
@@ -53,6 +53,7 @@
         if "packages" in message_types:
             self.spawn_reporter()
 
+<<<<<<< TREE
     def _run_fake_reporter(self, args):
         """Run a fake-reporter in-process."""
 
@@ -103,6 +104,58 @@
 
         return result.addBoth(done)
 
+=======
+    def _run_fake_reporter(self, args):
+        """Run a fake-reporter in-process."""
+
+        class FakeFacade(object):
+            """
+            A fake facade to workaround the issue that the SmartFacade
+            essentially allows only once instance per process.
+            """
+
+            def get_arch(self):
+                arch = os.uname()[-1]
+                result = {"pentium": "i386",
+                          "i86pc": "i386",
+                          "x86_64": "amd64"}.get(arch)
+                if result:
+                    arch = result
+                elif (arch[0] == "i" and arch.endswith("86")):
+                    arch = "i386"
+                return arch
+
+        if getattr(self, "_fake_reporter", None) is None:
+
+            from landscape.package.reporter import (
+                FakeReporter, PackageReporterConfiguration)
+            from landscape.package.store import FakePackageStore
+            package_facade = FakeFacade()
+            package_config = PackageReporterConfiguration()
+            package_config.load(args + ["-d", self.config.data_path,
+                                        "-l", self.config.log_dir])
+            package_store = FakePackageStore(package_config.store_filename)
+            self._fake_reporter = FakeReporter(package_store, package_facade,
+                                               self.registry.broker,
+                                               package_config)
+            self._fake_reporter.global_store_filename = os.path.join(
+                self.config.master_data_path, "package", "database")
+            self._fake_reporter_running = False
+
+        if self._fake_reporter_running:
+            from twisted.internet.defer import succeed
+            return succeed(None)
+
+        self._fake_reporter_running = True
+        result = self._fake_reporter.run()
+
+        def done(passthrough):
+            self._fake_reporter_running = False
+            return passthrough
+
+        return result.addBoth(done)
+
+>>>>>>> MERGE-SOURCE
     def spawn_reporter(self):
         args = ["--quiet"]
         if self.config.config:
 
=== modified file 'landscape/package/changer.py'
--- landscape/package/changer.py	2012-06-19 15:12:07 +0000
+++ landscape/package/changer.py	2014-11-19 18:22:39 +0000
@@ -18,7 +18,11 @@
 from landscape.package.taskhandler import (
     PackageTaskHandler, PackageTaskHandlerConfiguration, PackageTaskError,
     run_task_handler)
+<<<<<<< TREE
 from landscape.manager.manager import FAILED
+=======
+from landscape.manager.manager import FAILED, SUCCEEDED
+>>>>>>> MERGE-SOURCE
 
 
 class UnknownPackageData(Exception):
@@ -99,6 +103,8 @@
             return result.addErrback(self.unknown_package_data_error, task)
         if message["type"] == "change-package-locks":
             return self.handle_change_package_locks(message)
+        if message["type"] == "change-package-holds":
+            return self.handle_change_package_holds(message)
 
     def unknown_package_data_error(self, failure, task):
         """Handle L{UnknownPackageData} data errors.
@@ -293,13 +299,105 @@
         Package locks aren't supported anymore.
         """
 
+<<<<<<< TREE
         response = {
             "type": "operation-result",
             "operation-id": message.get("operation-id"),
             "status": FAILED,
             "result-text": "This client doesn't support package locks.",
             "result-code": 1}
-        return self._broker.send_message(response, True)
+=======
+        if not self._facade.supports_package_locks:
+            response = {
+                "type": "operation-result",
+                "operation-id": message.get("operation-id"),
+                "status": FAILED,
+                "result-text": "This client doesn't support package locks.",
+                "result-code": 1}
+            return self._broker.send_message(response, True)
+
+        for lock in message.get("create", ()):
+            self._facade.set_package_lock(*lock)
+        for lock in message.get("delete", ()):
+            self._facade.remove_package_lock(*lock)
+        self._facade.save_config()
+
+        response = {"type": "operation-result",
+                    "operation-id": message.get("operation-id"),
+                    "status": SUCCEEDED,
+                    "result-text": "Package locks successfully changed.",
+                    "result-code": 0}
+
+        logging.info("Queuing message with change package locks results to "
+                     "exchange urgently.")
+>>>>>>> MERGE-SOURCE
+        return self._broker.send_message(response, True)
+
+    def _send_change_package_holds_response(self, response):
+        """Log that a package holds result is sent and send the response."""
+        logging.info("Queuing message with change package holds results to "
+                     "exchange urgently.")
+        return self._broker.send_message(response, True)
+
+    def handle_change_package_holds(self, message):
+        """Handle a C{change-package-holds} message.
+
+        Create and delete package holds as requested by the given C{message}.
+        """
+        if not self._facade.supports_package_holds:
+            response = {
+                "type": "operation-result",
+                "operation-id": message.get("operation-id"),
+                "status": FAILED,
+                "result-text": "This client doesn't support package holds.",
+                "result-code": 1}
+            return self._send_change_package_holds_response(response)
+
+        not_installed = set()
+        holds_to_create = message.get("create", [])
+        versions_to_create = set()
+        for id in holds_to_create:
+            hash = self._store.get_id_hash(id)
+            hold_version = self._facade.get_package_by_hash(hash)
+            if (hold_version
+                and self._facade.is_package_installed(hold_version)):
+                versions_to_create.add((hold_version.package, hold_version))
+            else:
+                not_installed.add(str(id))
+        holds_to_remove = message.get("delete", [])
+        versions_to_remove = set()
+        for id in holds_to_remove:
+            hash = self._store.get_id_hash(id)
+            hold_version = self._facade.get_package_by_hash(hash)
+            if (hold_version
+                and self._facade.is_package_installed(hold_version)):
+                versions_to_remove.add((hold_version.package, hold_version))
+
+        if not_installed:
+            response = {
+                "type": "operation-result",
+                "operation-id": message.get("operation-id"),
+                "status": FAILED,
+                "result-text": "Package holds not changed, since the" +
+                               " following packages are not installed: %s" % (
+                                   ", ".join(sorted(not_installed))),
+                "result-code": 1}
+            return self._send_change_package_holds_response(response)
+
+        for package, hold_version in versions_to_create:
+            self._facade.set_package_hold(hold_version)
+        for package, hold_version in versions_to_remove:
+            self._facade.remove_package_hold(hold_version)
+
+        self._facade.reload_channels()
+
+        response = {"type": "operation-result",
+                    "operation-id": message.get("operation-id"),
+                    "status": SUCCEEDED,
+                    "result-text": "Package holds successfully changed.",
+                    "result-code": 0}
+
+        return self._send_change_package_holds_response(response)
 
     @staticmethod
     def find_command():
 
=== modified file 'landscape/package/facade.py'
--- landscape/package/facade.py	2012-06-19 15:12:07 +0000
+++ landscape/package/facade.py	2014-11-19 18:22:39 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 import hashlib
 import os
 import subprocess
@@ -22,6 +23,47 @@
 from landscape.lib.fs import append_file, create_file, read_file
 from landscape.constants import UBUNTU_PATH
 from landscape.package.skeleton import build_skeleton_apt
+=======
+import hashlib
+import os
+import subprocess
+import tempfile
+from cStringIO import StringIO
+from operator import attrgetter
+
+has_smart = True
+try:
+    import smart
+    from smart.transaction import (
+        Transaction, PolicyInstall, PolicyUpgrade, PolicyRemove, Failed)
+    from smart.const import INSTALL, REMOVE, UPGRADE, ALWAYS, NEVER
+except ImportError:
+    has_smart = False
+
+# Importing apt throws a FutureWarning on hardy, that we don't want to
+# see.
+import warnings
+warnings.filterwarnings("ignore", module="apt", category=FutureWarning)
+del warnings
+
+import apt
+import apt_inst
+import apt_pkg
+
+has_new_enough_apt = True
+from aptsources.sourceslist import SourcesList
+try:
+    from apt.progress.text import AcquireProgress
+    from apt.progress.base import InstallProgress
+except ImportError:
+    AcquireProgress = object
+    InstallProgress = object
+    has_new_enough_apt = False
+
+from landscape.lib.fs import append_file, create_file, read_file
+from landscape.constants import UBUNTU_PATH
+from landscape.package.skeleton import build_skeleton, build_skeleton_apt
+>>>>>>> MERGE-SOURCE
 
 
 class TransactionError(Exception):
@@ -43,64 +85,708 @@
     """Raised when channels fail to load."""
 
 
-class LandscapeAcquireProgress(AcquireProgress):
-
-    def _winch(self, *dummy):
-        """Override trying to get the column count of the buffer.
-
-        We always send the output to a file, not to a terminal, so the
-        default width (80 columns) is fine for us.
-
-        Overriding this method means that we don't have to care about
-        fcntl.ioctl API differences for different Python versions.
-        """
-
-
-class LandscapeInstallProgress(InstallProgress):
-
-    dpkg_exited = None
-
-    def wait_child(self):
-        """Override to find out whether dpkg exited or not.
-
-        The C{run()} method returns os.WEXITSTATUS(res) without checking
-        os.WIFEXITED(res) first, so it can signal that everything is ok,
-        even though something causes dpkg not to exit cleanly.
-
-        Save whether dpkg exited cleanly into the C{dpkg_exited}
-        attribute. If dpkg exited cleanly the exit code can be used to
-        determine whether there were any errors. If dpkg didn't exit
-        cleanly it should mean that something went wrong.
-        """
-        res = super(LandscapeInstallProgress, self).wait_child()
-        self.dpkg_exited = os.WIFEXITED(res)
-        return res
-
-
-class AptFacade(object):
-    """Wrapper for tasks using Apt.
-
-    This object wraps Apt features, in a way that makes using and testing
-    these features slightly more comfortable.
-
-    @param root: The root dir of the Apt configuration files.
-    @ivar refetch_package_index: Whether to refetch the package indexes
-        when reloading the channels, or reuse the existing local
-        database.
-    """
-
-    _dpkg_status = "/var/lib/dpkg/status"
-
-    def __init__(self, root=None):
-        self._root = root
-        self._dpkg_args = []
-        if self._root is not None:
-            self._ensure_dir_structure()
-            self._dpkg_args.extend(["--root", self._root])
-        # don't use memonly=True here because of a python-apt bug on Natty when
-        # sources.list contains invalid lines (LP: #886208)
-        self._cache = apt.cache.Cache(rootdir=root)
-        self._channels_loaded = False
+<<<<<<< TREE
+class LandscapeAcquireProgress(AcquireProgress):
+
+    def _winch(self, *dummy):
+        """Override trying to get the column count of the buffer.
+
+        We always send the output to a file, not to a terminal, so the
+        default width (80 columns) is fine for us.
+
+        Overriding this method means that we don't have to care about
+        fcntl.ioctl API differences for different Python versions.
+        """
+
+
+class LandscapeInstallProgress(InstallProgress):
+
+    dpkg_exited = None
+
+    def wait_child(self):
+        """Override to find out whether dpkg exited or not.
+
+        The C{run()} method returns os.WEXITSTATUS(res) without checking
+        os.WIFEXITED(res) first, so it can signal that everything is ok,
+        even though something causes dpkg not to exit cleanly.
+
+        Save whether dpkg exited cleanly into the C{dpkg_exited}
+        attribute. If dpkg exited cleanly the exit code can be used to
+        determine whether there were any errors. If dpkg didn't exit
+        cleanly it should mean that something went wrong.
+        """
+        res = super(LandscapeInstallProgress, self).wait_child()
+        self.dpkg_exited = os.WIFEXITED(res)
+        return res
+
+
+class AptFacade(object):
+    """Wrapper for tasks using Apt.
+
+    This object wraps Apt features, in a way that makes using and testing
+=======
+class LandscapeAcquireProgress(AcquireProgress):
+
+    def _winch(self, *dummy):
+        """Override trying to get the column count of the buffer.
+
+        We always send the output to a file, not to a terminal, so the
+        default width (80 columns) is fine for us.
+
+        Overriding this method means that we don't have to care about
+        fcntl.ioctl API differences for different Python versions.
+        """
+
+
+class LandscapeInstallProgress(InstallProgress):
+
+    dpkg_exited = None
+
+    def wait_child(self):
+        """Override to find out whether dpkg exited or not.
+
+        The C{run()} method returns os.WEXITSTATUS(res) without checking
+        os.WIFEXITED(res) first, so it can signal that everything is ok,
+        even though something causes dpkg not to exit cleanly.
+
+        Save whether dpkg exited cleanly into the C{dpkg_exited}
+        attribute. If dpkg exited cleanly the exit code can be used to
+        determine whether there were any errors. If dpkg didn't exit
+        cleanly it should mean that something went wrong.
+        """
+        res = super(LandscapeInstallProgress, self).wait_child()
+        self.dpkg_exited = os.WIFEXITED(res)
+        return res
+
+
+class AptFacade(object):
+    """Wrapper for tasks using Apt.
+
+    This object wraps Apt features, in a way that makes using and testing
+    these features slightly more comfortable.
+
+    @param root: The root dir of the Apt configuration files.
+    @ivar refetch_package_index: Whether to refetch the package indexes
+        when reloading the channels, or reuse the existing local
+        database.
+    """
+
+    supports_package_holds = True
+    supports_package_locks = False
+    _dpkg_status = "/var/lib/dpkg/status"
+
+    def __init__(self, root=None):
+        self._root = root
+        self._dpkg_args = []
+        if self._root is not None:
+            self._ensure_dir_structure()
+            self._dpkg_args.extend(["--root", self._root])
+        # don't use memonly=True here because of a python-apt bug on Natty when
+        # sources.list contains invalid lines (LP: #886208)
+        self._cache = apt.cache.Cache(rootdir=root)
+        self._channels_loaded = False
+        self._pkg2hash = {}
+        self._hash2pkg = {}
+        self._version_installs = []
+        self._global_upgrade = False
+        self._version_removals = []
+        self.refetch_package_index = False
+
+    def _ensure_dir_structure(self):
+        self._ensure_sub_dir("etc/apt")
+        self._ensure_sub_dir("etc/apt/sources.list.d")
+        self._ensure_sub_dir("var/cache/apt/archives/partial")
+        self._ensure_sub_dir("var/lib/apt/lists/partial")
+        dpkg_dir = self._ensure_sub_dir("var/lib/dpkg")
+        self._ensure_sub_dir("var/lib/dpkg/info")
+        self._ensure_sub_dir("var/lib/dpkg/updates")
+        self._ensure_sub_dir("var/lib/dpkg/triggers")
+        create_file(os.path.join(dpkg_dir, "available"), "")
+        self._dpkg_status = os.path.join(dpkg_dir, "status")
+        if not os.path.exists(self._dpkg_status):
+            create_file(self._dpkg_status, "")
+
+    def _ensure_sub_dir(self, sub_dir):
+        """Ensure that a dir in the Apt root exists."""
+        full_path = os.path.join(self._root, sub_dir)
+        if not os.path.exists(full_path):
+            os.makedirs(full_path)
+        return full_path
+
+    def deinit(self):
+        """This method exists solely to be compatible with C{SmartFacade}."""
+
+    def get_packages(self):
+        """Get all the packages available in the channels."""
+        return self._hash2pkg.itervalues()
+
+    def get_locked_packages(self):
+        """Get all packages in the channels that are locked.
+
+        For Apt, it means all packages that are held.
+        """
+        return [
+            version for version in self.get_packages()
+            if (self.is_package_installed(version)
+                and self._is_package_held(version.package))]
+
+    def get_package_locks(self):
+        """Return all set package locks.
+
+        @return: A C{list} of ternary tuples, contaning the name, relation
+            and version details for each lock currently set on the system.
+
+        XXX: This method isn't implemented yet. It's here to make the
+        transition to Apt in the package reporter easier.
+        """
+        return []
+
+    def get_package_holds(self):
+        """Return the name of all the packages that are on hold."""
+        return [version.package.name for version in self.get_locked_packages()]
+
+    def _set_dpkg_selections(self, selection):
+        """Set the dpkg selection.
+
+        It basically does "echo $selection | dpkg --set-selections".
+        """
+        process = subprocess.Popen(
+            ["dpkg", "--set-selections"] + self._dpkg_args,
+            stdin=subprocess.PIPE)
+        process.communicate(selection)
+
+    def set_package_hold(self, version):
+        """Add a dpkg hold for a package.
+
+        @param version: The version of the package to hold.
+        """
+        self._set_dpkg_selections(version.package.name + " hold")
+
+    def remove_package_hold(self, version):
+        """Removes a dpkg hold for a package.
+
+        @param version: The version of the package to unhold.
+        """
+        if not self._is_package_held(version.package):
+            return
+        self._set_dpkg_selections(version.package.name + " install")
+
+    def reload_channels(self, force_reload_binaries=False):
+        """Reload the channels and update the cache.
+
+        @param force_reload_binaries: Whether to always reload
+            information about the binaries packages that are in the facade's
+            internal repo.
+        """
+        self._cache.open(None)
+        internal_sources_list = self._get_internal_sources_list()
+        if (self.refetch_package_index or
+            (force_reload_binaries and os.path.exists(internal_sources_list))):
+            # Try to update only the internal repos, if the python-apt
+            # version is new enough to accept a sources_list parameter.
+            new_apt_args = {}
+            if force_reload_binaries and not self.refetch_package_index:
+                new_apt_args["sources_list"] = internal_sources_list
+            try:
+                try:
+                    self._cache.update(**new_apt_args)
+                except TypeError:
+                    self._cache.update()
+            except apt.cache.FetchFailedException:
+                raise ChannelError(
+                    "Apt failed to reload channels (%r)" % (
+                        self.get_channels()))
+            self._cache.open(None)
+
+        self._pkg2hash.clear()
+        self._hash2pkg.clear()
+        for package in self._cache:
+            if not self._is_main_architecture(package):
+                continue
+            for version in package.versions:
+                hash = self.get_package_skeleton(
+                    version, with_info=False).get_hash()
+                # Use a tuple including the package, since the Version
+                # objects of two different packages can have the same
+                # hash.
+                self._pkg2hash[(package, version)] = hash
+                self._hash2pkg[hash] = version
+        self._channels_loaded = True
+
+    def ensure_channels_reloaded(self):
+        """Reload the channels if they haven't been reloaded yet."""
+        if self._channels_loaded:
+            return
+        self.reload_channels()
+
+    def _get_internal_sources_list(self):
+        """Return the path to the source.list file for the facade channels."""
+        sources_dir = apt_pkg.config.find_dir("Dir::Etc::sourceparts")
+        return os.path.join(sources_dir, "_landscape-internal-facade.list")
+
+    def add_channel_apt_deb(self, url, codename, components=None):
+        """Add a deb URL which points to a repository.
+
+        @param url: The base URL of the repository.
+        @param codename: The dist in the repository.
+        @param components: The components to be included.
+        """
+        sources_file_path = self._get_internal_sources_list()
+        sources_line = "deb %s %s" % (url, codename)
+        if components:
+            sources_line += " %s" % " ".join(components)
+        if os.path.exists(sources_file_path):
+            current_content = read_file(sources_file_path).split("\n")
+            if sources_line in current_content:
+                return
+        sources_line += "\n"
+        append_file(sources_file_path, sources_line)
+
+    def add_channel_deb_dir(self, path):
+        """Add a directory with packages as a channel.
+
+        @param path: The path to the directory containing the packages.
+
+        A Packages file is created in the directory with information
+        about the deb files.
+        """
+        self._create_packages_file(path)
+        self.add_channel_apt_deb("file://%s" % path, "./", None)
+
+    def clear_channels(self):
+        """Clear the channels that have been added through the facade.
+
+        Channels that weren't added through the facade (i.e.
+        /etc/apt/sources.list and /etc/apt/sources.list.d) won't be
+        removed.
+        """
+        sources_file_path = self._get_internal_sources_list()
+        if os.path.exists(sources_file_path):
+            os.remove(sources_file_path)
+
+    def _create_packages_file(self, deb_dir):
+        """Create a Packages file in a directory with debs."""
+        packages_contents = "\n".join(
+            self.get_package_stanza(os.path.join(deb_dir, filename))
+            for filename in sorted(os.listdir(deb_dir)))
+        create_file(os.path.join(deb_dir, "Packages"), packages_contents)
+
+    def get_channels(self):
+        """Return a list of channels configured.
+
+        A channel is a deb line in sources.list or sources.list.d. It's
+        represented by a dict with baseurl, distribution, components,
+        and type keys.
+        """
+        sources_list = SourcesList()
+        return [{"baseurl": entry.uri, "distribution": entry.dist,
+                 "components": " ".join(entry.comps), "type": entry.type}
+                for entry in sources_list if not entry.disabled]
+
+    def reset_channels(self):
+        """Remove all the configured channels."""
+        sources_list = SourcesList()
+        for entry in sources_list:
+            entry.set_enabled(False)
+        sources_list.save()
+
+    def get_package_stanza(self, deb_path):
+        """Return a stanza for the package to be included in a Packages file.
+
+        @param deb_path: The path to the deb package.
+        """
+        deb_file = open(deb_path)
+        deb = apt_inst.DebFile(deb_file)
+        control = deb.control.extractdata("control")
+        deb_file.close()
+        filename = os.path.basename(deb_path)
+        size = os.path.getsize(deb_path)
+        contents = read_file(deb_path)
+        md5 = hashlib.md5(contents).hexdigest()
+        sha1 = hashlib.sha1(contents).hexdigest()
+        sha256 = hashlib.sha256(contents).hexdigest()
+        # Use rewrite_section to ensure that the field order is correct.
+        return apt_pkg.rewrite_section(
+            apt_pkg.TagSection(control), apt_pkg.REWRITE_PACKAGE_ORDER,
+            [("Filename", filename), ("Size", str(size)),
+             ("MD5sum", md5), ("SHA1", sha1), ("SHA256", sha256)])
+
+    def get_arch(self):
+        """Return the architecture APT is configured to use."""
+        return apt_pkg.config.get("APT::Architecture")
+
+    def set_arch(self, architecture):
+        """Set the architecture that APT should use.
+
+        Setting multiple architectures isn't supported.
+        """
+        if architecture is None:
+            architecture = ""
+        # From oneiric and onwards Architectures is used to set which
+        # architectures can be installed, in case multiple architectures
+        # are supported. We force it to be single architecture, until we
+        # have a plan for supporting multiple architectures.
+        apt_pkg.config.clear("APT::Architectures")
+        apt_pkg.config.set("APT::Architectures::", architecture)
+        result = apt_pkg.config.set("APT::Architecture", architecture)
+        # Reload the cache, otherwise architecture change isn't reflected in
+        # package list
+        self._cache.open(None)
+        return result
+
+    def get_package_skeleton(self, pkg, with_info=True):
+        """Return a skeleton for the provided package.
+
+        The skeleton represents the basic structure of the package.
+
+        @param pkg: Package to build skeleton from.
+        @param with_info: If True, the skeleton will include information
+            useful for sending data to the server.  Such information isn't
+            necessary if the skeleton will be used to build a hash.
+
+        @return: a L{PackageSkeleton} object.
+        """
+        return build_skeleton_apt(pkg, with_info=with_info, with_unicode=True)
+
+    def get_package_hash(self, version):
+        """Return a hash from the given package.
+
+        @param version: an L{apt.package.Version} object.
+        """
+        return self._pkg2hash.get((version.package, version))
+
+    def get_package_hashes(self):
+        """Get the hashes of all the packages available in the channels."""
+        return self._pkg2hash.values()
+
+    def get_package_by_hash(self, hash):
+        """Get the package having the provided hash.
+
+        @param hash: The hash the package should have.
+
+        @return: The L{apt.package.Package} that has the given hash.
+        """
+        return self._hash2pkg.get(hash)
+
+    def is_package_installed(self, version):
+        """Is the package version installed?"""
+        return version == version.package.installed
+
+    def is_package_available(self, version):
+        """Is the package available for installation?"""
+        return version.downloadable
+
+    def is_package_upgrade(self, version):
+        """Is the package an upgrade for another installed package?"""
+        if not version.package.is_upgradable or not version.package.installed:
+            return False
+        return version > version.package.installed
+
+    def _is_main_architecture(self, package):
+        """Is the package for the facade's main architecture?"""
+        # package.name includes the architecture, if it's for a foreign
+        # architectures. package.shortname never includes the
+        # architecture. package.shortname doesn't exist on releases that
+        # don't support multi-arch, though.
+        if not hasattr(package, "shortname"):
+            return True
+        return package.name == package.shortname
+
+    def _is_package_held(self, package):
+        """Is the package marked as held?"""
+        return package._pkg.selected_state == apt_pkg.SELSTATE_HOLD
+
+    def get_packages_by_name(self, name):
+        """Get all available packages matching the provided name.
+
+        @param name: The name the returned packages should have.
+        """
+        return [
+            version for version in self.get_packages()
+            if version.package.name == name]
+
+    def _get_broken_packages(self):
+        """Return the packages that are in a broken state."""
+        return set(
+            version.package for version in self.get_packages()
+            if version.package.is_inst_broken)
+
+    def _get_changed_versions(self, package):
+        """Return the versions that will be changed for the package.
+
+        Apt gives us that a package is going to be changed and have
+        variables set on the package to indicate what will change. We
+        need to convert that into a list of versions that will be either
+        installed or removed, which is what the server expects to get.
+        """
+        if package.marked_install:
+            return [package.candidate]
+        if package.marked_upgrade or package.marked_downgrade:
+            return [package.installed, package.candidate]
+        if package.marked_delete:
+            return [package.installed]
+        return None
+
+    def _check_changes(self, requested_changes):
+        """Check that the changes Apt will do have all been requested.
+
+        @raises DependencyError: If some change hasn't been explicitly
+            requested.
+        @return: C{True} if all the changes that Apt will perform have
+            been requested.
+        """
+        # Build tuples of (package, version) so that we can do
+        # comparison checks. Same versions of different packages compare
+        # as being the same, so we need to include the package as well.
+        all_changes = [
+            (version.package, version) for version in requested_changes]
+        versions_to_be_changed = set()
+        for package in self._cache.get_changes():
+            if not self._is_main_architecture(package):
+                continue
+            versions = self._get_changed_versions(package)
+            versions_to_be_changed.update(
+                (package, version) for version in versions)
+        dependencies = versions_to_be_changed.difference(all_changes)
+        if dependencies:
+            raise DependencyError(
+                [version for package, version in dependencies])
+        return len(versions_to_be_changed) > 0
+
+    def _get_unmet_relation_info(self, dep_relation):
+        """Return a string representation of a specific dependency relation."""
+        info = dep_relation.target_pkg.name
+        if dep_relation.target_ver:
+            info += " (%s %s)" % (
+                dep_relation.comp_type, dep_relation.target_ver)
+        reason = " but is not installable"
+        if dep_relation.target_pkg.name in self._cache:
+            dep_package = self._cache[dep_relation.target_pkg.name]
+            if dep_package.installed or dep_package.marked_install:
+                version = dep_package.candidate.version
+                if dep_package not in self._cache.get_changes():
+                    version = dep_package.installed.version
+                reason = " but %s is to be installed" % version
+        info += reason
+        return info
+
+    def _is_dependency_satisfied(self, dependency, dep_type):
+        """Return whether a dependency is satisfied.
+
+        For positive dependencies (Pre-Depends, Depends) it means that
+        one of its targets is going to be installed. For negative
+        dependencies (Conflicts, Breaks), it means that none of its
+        targets are going to be installed.
+        """
+        is_positive = dep_type not in ["Breaks", "Conflicts"]
+        depcache = self._cache._depcache
+        for or_dep in dependency:
+            for target in or_dep.all_targets():
+                package = target.parent_pkg
+                if ((package.current_state == apt_pkg.CURSTATE_INSTALLED
+                     or depcache.marked_install(package))
+                    and not depcache.marked_delete(package)):
+                    return is_positive
+        return not is_positive
+
+    def _get_unmet_dependency_info(self):
+        """Get information about unmet dependencies in the cache state.
+
+        Go through all the broken packages and say which dependencies
+        haven't been satisfied.
+
+        @return: A string with dependency information like what you get
+            from apt-get.
+        """
+
+        broken_packages = self._get_broken_packages()
+        if not broken_packages:
+            return ""
+        all_info = ["The following packages have unmet dependencies:"]
+        for package in sorted(broken_packages, key=attrgetter("name")):
+            for dep_type in ["PreDepends", "Depends", "Conflicts", "Breaks"]:
+                dependencies = package.candidate._cand.depends_list.get(
+                    dep_type, [])
+                for dependency in dependencies:
+                    if self._is_dependency_satisfied(dependency, dep_type):
+                        continue
+                    relation_infos = []
+                    for dep_relation in dependency:
+                        relation_infos.append(
+                            self._get_unmet_relation_info(dep_relation))
+                    info = "  %s: %s: " % (package.name, dep_type)
+                    or_divider = " or\n" + " " * len(info)
+                    all_info.append(info + or_divider.join(relation_infos))
+        return "\n".join(all_info)
+
+    def perform_changes(self):
+        """Perform the pending package operations."""
+        # Try to enforce non-interactivity
+        os.environ["DEBIAN_FRONTEND"] = "noninteractive"
+        os.environ["APT_LISTCHANGES_FRONTEND"] = "none"
+        os.environ["APT_LISTBUGS_FRONTEND"] = "none"
+        # dpkg will fail if no path is set.
+        if "PATH" not in os.environ:
+            os.environ["PATH"] = UBUNTU_PATH
+        apt_pkg.config.clear("DPkg::options")
+        apt_pkg.config.set("DPkg::options::", "--force-confold")
+
+        held_package_names = set()
+        package_installs = set(
+            version.package for version in self._version_installs)
+        package_upgrades = set(
+            version.package for version in self._version_removals
+            if version.package in package_installs)
+        version_changes = self._version_installs[:]
+        version_changes.extend(self._version_removals)
+        if not version_changes and not self._global_upgrade:
+            return None
+        fixer = apt_pkg.ProblemResolver(self._cache._depcache)
+        already_broken_packages = self._get_broken_packages()
+        for version in self._version_installs:
+            # Set the candidate version, so that the version we want to
+            # install actually is the one getting installed.
+            version.package.candidate = version
+            version.package.mark_install(auto_fix=False)
+            # If we need to resolve dependencies, try avoiding having
+            # the package we asked to be installed from being removed.
+            # (This is what would have been done if auto_fix would have
+            # been True.
+            fixer.clear(version.package._pkg)
+            fixer.protect(version.package._pkg)
+        if self._global_upgrade:
+            self._cache.upgrade(dist_upgrade=True)
+        for version in self._version_removals:
+            if self._is_package_held(version.package):
+                held_package_names.add(version.package.name)
+            if version.package in package_upgrades:
+                # The server requests the old version to be removed for
+                # upgrades, since Smart worked that way. For Apt we have
+                # to take care not to mark upgraded packages for # removal.
+                continue
+            version.package.mark_delete(auto_fix=False)
+            # Configure the resolver in the same way
+            # mark_delete(auto_fix=True) would have done.
+            fixer.clear(version.package._pkg)
+            fixer.protect(version.package._pkg)
+            fixer.remove(version.package._pkg)
+            fixer.install_protect()
+
+        if held_package_names:
+            raise TransactionError(
+                "Can't perform the changes, since the following packages" +
+                " are held: %s" % ", ".join(sorted(held_package_names)))
+
+        now_broken_packages = self._get_broken_packages()
+        if now_broken_packages != already_broken_packages:
+            try:
+                fixer.resolve(True)
+            except SystemError, error:
+                raise TransactionError(
+                    error.args[0] + "\n" + self._get_unmet_dependency_info())
+        if not self._check_changes(version_changes):
+            return None
+        fetch_output = StringIO()
+        # Redirect stdout and stderr to a file. We need to work with the
+        # file descriptors, rather than sys.stdout/stderr, since dpkg is
+        # run in a subprocess.
+        fd, install_output_path = tempfile.mkstemp()
+        old_stdout = os.dup(1)
+        old_stderr = os.dup(2)
+        os.dup2(fd, 1)
+        os.dup2(fd, 2)
+        install_progress = LandscapeInstallProgress()
+        try:
+            self._cache.commit(
+                fetch_progress=LandscapeAcquireProgress(fetch_output),
+                install_progress=install_progress)
+            if not install_progress.dpkg_exited:
+                raise SystemError("dpkg didn't exit cleanly.")
+        except SystemError, error:
+            result_text = (
+                fetch_output.getvalue() + read_file(install_output_path))
+            raise TransactionError(
+                error.args[0] + "\n\nPackage operation log:\n" + result_text)
+        else:
+            result_text = (
+                fetch_output.getvalue() + read_file(install_output_path))
+        finally:
+            # Restore stdout and stderr.
+            os.dup2(old_stdout, 1)
+            os.dup2(old_stderr, 2)
+            os.remove(install_output_path)
+        return result_text
+
+    def reset_marks(self):
+        """Clear the pending package operations."""
+        del self._version_installs[:]
+        del self._version_removals[:]
+        self._global_upgrade = False
+        self._cache.clear()
+
+    def mark_install(self, version):
+        """Mark the package for installation."""
+        self._version_installs.append(version)
+
+    def mark_global_upgrade(self):
+        """Upgrade all installed packages."""
+        self._global_upgrade = True
+
+    def mark_remove(self, version):
+        """Mark the package for removal."""
+        self._version_removals.append(version)
+
+
+class SmartFacade(object):
+    """Wrapper for tasks using Smart.
+
+    This object wraps Smart features, in a way that makes using and testing
+>>>>>>> MERGE-SOURCE
+    these features slightly more comfortable.
+<<<<<<< TREE
+
+    @param root: The root dir of the Apt configuration files.
+    @ivar refetch_package_index: Whether to refetch the package indexes
+        when reloading the channels, or reuse the existing local
+        database.
+=======
+
+    @param smart_init_kwargs: A dictionary that can be used to pass specific
+        keyword parameters to to L{smart.init}.
+>>>>>>> MERGE-SOURCE
+    """
+
+<<<<<<< TREE
+    _dpkg_status = "/var/lib/dpkg/status"
+
+    def __init__(self, root=None):
+        self._root = root
+        self._dpkg_args = []
+        if self._root is not None:
+            self._ensure_dir_structure()
+            self._dpkg_args.extend(["--root", self._root])
+        # don't use memonly=True here because of a python-apt bug on Natty when
+        # sources.list contains invalid lines (LP: #886208)
+        self._cache = apt.cache.Cache(rootdir=root)
+        self._channels_loaded = False
+=======
+    _deb_package_type = None
+    supports_package_holds = False
+    supports_package_locks = True
+
+    def __init__(self, smart_init_kwargs={}, sysconf_args=None):
+        if not has_smart:
+            raise RuntimeError(
+                "Smart needs to be installed if SmartFacade is used.")
+        self._smart_init_kwargs = smart_init_kwargs.copy()
+        self._smart_init_kwargs.setdefault("interface", "landscape")
+        self._sysconfig_args = sysconf_args or {}
+        self._reset()
+
+    def _reset(self):
+        # This attribute is initialized lazily in the _get_ctrl() method.
+        self._ctrl = None
+>>>>>>> MERGE-SOURCE
         self._pkg2hash = {}
         self._hash2pkg = {}
         self._version_installs = []
@@ -224,6 +910,7 @@
             return
         self.reload_channels()
 
+<<<<<<< TREE
     def _get_internal_sources_list(self):
         """Return the path to the source.list file for the facade channels."""
         sources_dir = apt_pkg.config.find_dir("Dir::Etc::sourceparts")
@@ -338,6 +1025,39 @@
         # package list
         self._cache.open(None)
         return result
+=======
+    def reload_channels(self, force_reload_binaries=False):
+        """
+        Reload Smart channels, getting all the cache (packages) in memory.
+
+        @raise: L{ChannelError} if Smart fails to reload the channels.
+        """
+        ctrl = self._get_ctrl()
+
+        try:
+            reload_result = ctrl.reloadChannels(caching=self._caching)
+        except smart.Error:
+            failed = True
+        else:
+            # Raise an error only if we are trying to download remote lists
+            failed = not reload_result and self._caching == NEVER
+        if failed:
+            raise ChannelError("Smart failed to reload channels (%s)"
+                               % smart.sysconf.get("channels"))
+
+        self._hash2pkg.clear()
+        self._pkg2hash.clear()
+
+        for pkg in self.get_packages():
+            hash = self.get_package_skeleton(pkg, False).get_hash()
+            self._hash2pkg[hash] = pkg
+            self._pkg2hash[pkg] = hash
+
+        self.channels_reloaded()
+
+    def channels_reloaded(self):
+        """Hook called after Smart channels are reloaded."""
+>>>>>>> MERGE-SOURCE
 
     def get_package_skeleton(self, pkg, with_info=True):
         """Return a skeleton for the provided package.
@@ -710,7 +1430,14 @@
         if len(results) > 0:
             return " ".join(results)
 
+    def mark_global_upgrade(self):
+        """Upgrade all installed packages."""
+        for package in self.get_packages():
+            if self.is_package_installed(package):
+                self.mark_upgrade(package)
+
     def reset_marks(self):
+<<<<<<< TREE
         """Clear the pending package operations."""
         del self._version_installs[:]
         del self._version_removals[:]
@@ -738,3 +1465,231 @@
     def mark_remove_hold(self, version):
         """Mark the package to have its hold removed."""
         self._version_hold_removals.append(version)
+=======
+        self._marks.clear()
+
+    def perform_changes(self):
+        ctrl = self._get_ctrl()
+        cache = ctrl.getCache()
+
+        transaction = Transaction(cache)
+
+        policy = PolicyInstall
+
+        only_remove = True
+        for pkg, oper in self._marks.items():
+            if oper == UPGRADE:
+                policy = PolicyUpgrade
+            if oper != REMOVE:
+                only_remove = False
+            transaction.enqueue(pkg, oper)
+
+        if only_remove:
+            policy = PolicyRemove
+
+        transaction.setPolicy(policy)
+
+        try:
+            transaction.run()
+        except Failed, e:
+            raise TransactionError(e.args[0])
+        changeset = transaction.getChangeSet()
+
+        if not changeset:
+            return None  # Nothing to do.
+
+        missing = []
+        for pkg, op in changeset.items():
+            if self._marks.get(pkg) != op:
+                missing.append(pkg)
+        if missing:
+            raise DependencyError(missing)
+
+        try:
+            self._ctrl.commitChangeSet(changeset)
+        except smart.Error, e:
+            raise TransactionError(e.args[0])
+
+        output = smart.iface.get_output_for_landscape()
+        failed = smart.iface.has_failed_for_landscape()
+
+        smart.iface.reset_for_landscape()
+
+        if failed:
+            raise SmartError(output)
+        return output
+
+    def reload_cache(self):
+        cache = self._get_ctrl().getCache()
+        cache.reset()
+        cache.load()
+
+    def get_arch(self):
+        """
+        Get the host dpkg architecture.
+        """
+        self._get_ctrl()
+        from smart.backends.deb.loader import DEBARCH
+        return DEBARCH
+
+    def set_arch(self, arch):
+        """
+        Set the host dpkg architecture.
+
+        To take effect it must be called before L{reload_channels}.
+
+        @param arch: the dpkg architecture to use (e.g. C{"i386"})
+        """
+        self._get_ctrl()
+        smart.sysconf.set("deb-arch", arch)
+
+        # XXX workaround Smart setting DEBARCH statically in the
+        # smart.backends.deb.base module
+        import smart.backends.deb.loader as loader
+        loader.DEBARCH = arch
+
+    def set_caching(self, mode):
+        """
+        Set Smart's caching mode.
+
+        @param mode: The caching mode to pass to Smart's C{reloadChannels}
+            when calling L{reload_channels} (e.g C{smart.const.NEVER} or
+            C{smart.const.ALWAYS}).
+        """
+        self._caching = mode
+
+    def reset_channels(self):
+        """Remove all configured Smart channels."""
+        self._get_ctrl()
+        smart.sysconf.set("channels", {}, soft=True)
+
+    def add_channel(self, alias, channel):
+        """
+        Add a Smart channel.
+
+        This method can be called more than once to set multiple channels.
+        To take effect it must be called before L{reload_channels}.
+
+        @param alias: A string identifying the channel to be added.
+        @param channel: A C{dict} holding information about the channel to
+            add (see the Smart API for details about valid keys and values).
+        """
+        channels = self.get_channels()
+        channels.update({alias: channel})
+        smart.sysconf.set("channels", channels, soft=True)
+
+    def add_channel_apt_deb(self, url, codename, components):
+        """Add a Smart channel of type C{"apt-deb"}.
+
+        @see: L{add_channel}
+        """
+        alias = codename
+        channel = {"baseurl": url, "distribution": codename,
+                   "components": components, "type": "apt-deb"}
+        self.add_channel(alias, channel)
+
+    def add_channel_deb_dir(self, path):
+        """Add a Smart channel of type C{"deb-dir"}.
+
+        @see: L{add_channel}
+        """
+        alias = path
+        channel = {"path": path, "type": "deb-dir"}
+        self.add_channel(alias, channel)
+
+    def clear_channels(self):
+        """Clear channels.
+
+        This method exists to be compatible with AptFacade. Smart
+        doesn't need to clear its channels.
+        """
+
+    def get_channels(self):
+        """
+        @return: A C{dict} of all configured channels.
+        """
+        self._get_ctrl()
+        return smart.sysconf.get("channels")
+
+    def get_package_locks(self):
+        """Return all set package locks.
+
+        @return: A C{list} of ternary tuples, contaning the name, relation
+            and version details for each lock currently set on the system.
+        """
+        self._get_ctrl()
+        locks = []
+        locks_by_name = smart.pkgconf.getFlagTargets("lock")
+        for name in locks_by_name:
+            for condition in locks_by_name[name]:
+                relation = condition[0] or ""
+                version = condition[1] or ""
+                locks.append((name, relation, version))
+        return locks
+
+    def _validate_lock_condition(self, relation, version):
+        if relation and not version:
+            raise RuntimeError("Package lock version not provided")
+        if version and not relation:
+            raise RuntimeError("Package lock relation not provided")
+
+    def set_package_lock(self, name, relation=None, version=None):
+        """Set a new package lock.
+
+        Any package matching the given name and possibly the given version
+        condition will be locked.
+
+        @param name: The name a package must match in order to be locked.
+        @param relation: Optionally, the relation of the version condition the
+            package must satisfy in order to be considered as locked.
+        @param version: Optionally, the version associated with C{relation}.
+
+        @note: If used at all, the C{relation} and C{version} parameter must be
+           both provided.
+        """
+        self._validate_lock_condition(relation, version)
+        self._get_ctrl()
+        smart.pkgconf.setFlag("lock", name, relation, version)
+
+    def remove_package_lock(self, name, relation=None, version=None):
+        """Remove a package lock."""
+        self._validate_lock_condition(relation, version)
+        self._get_ctrl()
+        smart.pkgconf.clearFlag("lock", name=name, relation=relation,
+                                version=version)
+
+    def save_config(self):
+        """Flush the current smart configuration to disk."""
+        control = self._get_ctrl()
+        control.saveSysConf()
+
+    def is_package_installed(self, package):
+        """Is the package installed?"""
+        return package.installed
+
+    def is_package_available(self, package):
+        """Is the package available for installation?"""
+        for loader in package.loaders:
+            # Is the package also in a non-installed
+            # loader?  IOW, "available".
+            if not loader.getInstalled():
+                return True
+        return False
+
+    def is_package_upgrade(self, package):
+        """Is the package an upgrade for another installed package?"""
+        is_upgrade = False
+        for upgrade in package.upgrades:
+            for provides in upgrade.providedby:
+                for provides_package in provides.packages:
+                    if provides_package.installed:
+                        is_upgrade = True
+                        break
+                else:
+                    continue
+                break
+            else:
+                continue
+            break
+        return is_upgrade
+>>>>>>> MERGE-SOURCE
 
=== added file 'landscape/package/interface.py.OTHER'
--- landscape/package/interface.py.OTHER	1970-01-01 00:00:00 +0000
+++ landscape/package/interface.py.OTHER	2014-11-19 18:22:39 +0000
@@ -0,0 +1,84 @@
+import logging
+import types
+import sys
+
+try:
+    import smart.interfaces
+    from smart.interface import Interface
+    from smart.const import ERROR, WARNING, INFO, DEBUG
+except ImportError:
+    # Smart is optional if AptFacade is being used.
+    Interface = object
+
+
+class LandscapeInterface(Interface):
+
+    __output = ""
+    __failed = False
+
+    def reset_for_landscape(self):
+        """Reset output and failed flag."""
+        self.__failed = False
+        self.__output = u""
+
+    def get_output_for_landscape(self):
+        """showOutput() is cached, and returned by this method."""
+        return self.__output
+
+    def has_failed_for_landscape(self):
+        """Return true if any error() messages were logged."""
+        return self.__failed
+
+    def error(self, msg):
+        self.__failed = True
+        # Calling these logging.* functions here instead of message()
+        # below will output the message or not depending on the debug
+        # level set in landscape-client, rather than the one set in
+        # Smart's configuration.
+        logging.error("[Smart] %s", msg)
+        super(LandscapeInterface, self).error(msg)
+
+    def warning(self, msg):
+        logging.warning("[Smart] %s", msg)
+        super(LandscapeInterface, self).warning(msg)
+
+    def info(self, msg):
+        logging.info("[Smart] %s", msg)
+        super(LandscapeInterface, self).info(msg)
+
+    def debug(self, msg):
+        logging.debug("[Smart] %s", msg)
+        super(LandscapeInterface, self).debug(msg)
+
+    def message(self, level, msg):
+        prefix = {ERROR: "ERROR", WARNING: "WARNING",
+                  INFO: "INFO", DEBUG: "DEBUG"}.get(level)
+        self.showOutput("%s: %s\n" % (prefix, msg))
+
+    def showOutput(self, output):
+        if not isinstance(output, unicode):
+            try:
+                output = output.decode("utf-8")
+            except UnicodeDecodeError:
+                output = output.decode("ascii", "replace")
+        self.__output += output
+
+
+class LandscapeInterfaceModule(types.ModuleType):
+
+    def __init__(self):
+        super(LandscapeInterfaceModule, self).__init__("landscape")
+
+    def create(self, ctrl, command=None, argv=None):
+        return LandscapeInterface(ctrl)
+
+
+def install_landscape_interface():
+    if "smart.interfaces.landscape" not in sys.modules:
+        # Plug the interface in a place Smart will recognize.
+        smart.interfaces.landscape = LandscapeInterfaceModule()
+        sys.modules["smart.interfaces.landscape"] = smart.interfaces.landscape
+
+
+def uninstall_landscape_interface():
+    sys.modules.pop("smart.interfaces.landscape", None)
 
=== modified file 'landscape/package/reporter.py'
--- landscape/package/reporter.py	2012-06-19 15:12:07 +0000
+++ landscape/package/reporter.py	2014-11-19 18:22:39 +0000
@@ -12,6 +12,7 @@
 from landscape.lib.fs import touch_file
 from landscape.lib import bpickle
 
+from landscape.package.facade import AptFacade
 from landscape.package.taskhandler import (
     PackageTaskHandlerConfiguration, PackageTaskHandler, run_task_handler)
 from landscape.package.store import UnknownHashIDRequest, FakePackageStore
@@ -47,15 +48,31 @@
 
     queue_name = "reporter"
 
+<<<<<<< TREE
     apt_update_interval = 60
     apt_update_filename = "/usr/lib/landscape/apt-update"
+=======
+    smart_update_interval = 60
+    smart_update_filename = "/usr/lib/landscape/smart-update"
+    apt_update_filename = "/usr/lib/landscape/apt-update"
+>>>>>>> MERGE-SOURCE
     sources_list_filename = "/etc/apt/sources.list"
     sources_list_directory = "/etc/apt/sources.list.d"
 
     def run(self):
         result = Deferred()
 
+<<<<<<< TREE
         result.addCallback(lambda x: self.run_apt_update())
+=======
+        if isinstance(self._facade, AptFacade):
+            # Update APT cache if APT facade is enabled.
+            result.addCallback(lambda x: self.run_apt_update())
+        else:
+            # Run smart-update before anything else, to make sure that
+            # the SmartFacade will load freshly updated channels
+            result.addCallback(lambda x: self.run_smart_update())
+>>>>>>> MERGE-SOURCE
 
         # If the appropriate hash=>id db is not there, fetch it
         result.addCallback(lambda x: self.fetch_hash_id_db())
@@ -219,6 +236,86 @@
             return result.addCallback(callback)
 
         else:
+<<<<<<< TREE
+            logging.debug("'%s' didn't run, update interval has not passed" %
+                          self.apt_update_filename)
+            return succeed(("", "", 0))
+=======
+            args = ("--after", str(self.smart_update_interval))
+        result = spawn_process(self.smart_update_filename, args=args)
+
+        def callback((out, err, code)):
+            # smart-update --after N will exit with error code 1 when it
+            # doesn't actually run the update code because to enough time
+            # has passed yet, but we don't actually consider it a failure.
+            smart_failed = False
+            if code != 0 and code != 1:
+                smart_failed = True
+            if code == 1 and err.strip() != "":
+                smart_failed = True
+            if smart_failed:
+                logging.warning("'%s' exited with status %d (%s)" % (
+                    self.smart_update_filename, code, err))
+            logging.debug("'%s' exited with status %d (out='%s', err='%s'" % (
+                self.smart_update_filename, code, out, err))
+            touch_file(self._config.update_stamp_filename)
+            if not smart_failed and not self._facade.get_channels():
+                code = 1
+                err = "There are no APT sources configured in %s or %s." % (
+                    self.sources_list_filename, self.sources_list_directory)
+            deferred = self._broker.call_if_accepted(
+                "package-reporter-result", self.send_result, code, err)
+            deferred.addCallback(lambda ignore: (out, err, code))
+            return deferred
+
+        result.addCallback(callback)
+        return result
+>>>>>>> MERGE-SOURCE
+
+    def _apt_update_timeout_expired(self, interval):
+        """Check if the apt-update timeout has passed."""
+        stamp = self._config.update_stamp_filename
+
+        if not os.path.exists(stamp):
+            return True
+        # check stamp file mtime
+        last_update = os.stat(stamp)[8]
+        now = int(time.time())
+        return (last_update + interval * 60) < now
+
+    def run_apt_update(self):
+        """Run apt-update and log a warning in case of non-zero exit code.
+
+        @return: a deferred returning (out, err, code)
+        """
+        if (self._config.force_smart_update or self._apt_sources_have_changed()
+            or self._apt_update_timeout_expired(self.smart_update_interval)):
+
+            result = spawn_process(self.apt_update_filename)
+
+            def callback((out, err, code)):
+                touch_file(self._config.update_stamp_filename)
+                logging.debug(
+                    "'%s' exited with status %d (out='%s', err='%s')" % (
+                        self.apt_update_filename, code, out, err))
+
+                if code != 0:
+                    logging.warning("'%s' exited with status %d (%s)" % (
+                            self.apt_update_filename, code, err))
+                elif not self._facade.get_channels():
+                    code = 1
+                    err = ("There are no APT sources configured in %s or %s." %
+                           (self.sources_list_filename,
+                            self.sources_list_directory))
+
+                deferred = self._broker.call_if_accepted(
+                    "package-reporter-result", self.send_result, code, err)
+                deferred.addCallback(lambda ignore: (out, err, code))
+                return deferred
+
+            return result.addCallback(callback)
+
+        else:
             logging.debug("'%s' didn't run, update interval has not passed" %
                           self.apt_update_filename)
             return succeed(("", "", 0))
@@ -559,6 +656,116 @@
 
         return result
 
+<<<<<<< TREE
+
+class FakeGlobalReporter(PackageReporter):
+    """
+    A standard reporter, which additionally stores messages sent into its
+    package store.
+    """
+
+    package_store_class = FakePackageStore
+
+    def send_message(self, message):
+        self._store.save_message(message)
+        return super(FakeGlobalReporter, self).send_message(message)
+
+
+class FakeReporter(PackageReporter):
+    """
+    A fake reporter which only sends messages previously stored by a
+    L{FakeGlobalReporter}.
+    """
+
+    package_store_class = FakePackageStore
+    global_store_filename = None
+
+    def run(self):
+        result = succeed(None)
+
+        # If the appropriate hash=>id db is not there, fetch it
+        result.addCallback(lambda x: self.fetch_hash_id_db())
+
+        result.addCallback(lambda x: self._store.clear_tasks())
+
+        # Finally, verify if we have anything new to send to the server.
+        result.addCallback(lambda x: self.send_pending_messages())
+=======
+    def detect_package_locks_changes(self):
+        """Detect changes in known package locks.
+
+        This method will verify if there are package locks that:
+
+        - are now set, and were not;
+        - were previously set but are not anymore;
+
+        In all cases, the server is notified of the new situation
+        with a "packages" message.
+
+        @return: A deferred resulting in C{True} if package lock changes were
+            detected with respect to the previous run, or C{False} otherwise.
+        """
+        old_package_locks = set(self._store.get_package_locks())
+        current_package_locks = set(self._facade.get_package_locks())
+
+        set_package_locks = current_package_locks - old_package_locks
+        unset_package_locks = old_package_locks - current_package_locks
+
+        message = {}
+        if set_package_locks:
+            message["created"] = sorted(set_package_locks)
+        if unset_package_locks:
+            message["deleted"] = sorted(unset_package_locks)
+
+        if not message:
+            return succeed(False)
+
+        message["type"] = "package-locks"
+        result = self.send_message(message)
+
+        logging.info("Queuing message with changes in known package locks:"
+                     " %d created, %d deleted." %
+                     (len(set_package_locks), len(unset_package_locks)))
+
+        def update_currently_known(result):
+            if set_package_locks:
+                self._store.add_package_locks(set_package_locks)
+            if unset_package_locks:
+                self._store.remove_package_locks(unset_package_locks)
+            return True
+
+        result.addCallback(update_currently_known)
+>>>>>>> MERGE-SOURCE
+
+        return result
+
+    def send_pending_messages(self):
+        """
+        As the last callback of L{PackageReporter}, sends messages stored.
+        """
+        if self.global_store_filename is None:
+            self.global_store_filename = os.environ["FAKE_PACKAGE_STORE"]
+        if not os.path.exists(self.global_store_filename):
+            return succeed(None)
+        message_sent = set(self._store.get_message_ids())
+        global_store = FakePackageStore(self.global_store_filename)
+        all_message_ids = set(global_store.get_message_ids())
+        not_sent = all_message_ids - message_sent
+        deferred = succeed(None)
+        got_type = set()
+        if not_sent:
+            messages = global_store.get_messages_by_ids(not_sent)
+            sent = []
+            for message_id, message in messages:
+                message = bpickle.loads(str(message))
+                if message["type"] not in got_type:
+                    got_type.add(message["type"])
+                    sent.append(message_id)
+                    deferred.addCallback(
+                        lambda x, message=message: self.send_message(message))
+            self._store.save_message_ids(sent)
+        return deferred
+
 
 class FakeGlobalReporter(PackageReporter):
     """
 
=== modified file 'landscape/package/skeleton.py'
--- landscape/package/skeleton.py	2012-06-19 15:12:07 +0000
+++ landscape/package/skeleton.py	2014-11-19 18:22:39 +0000
@@ -131,3 +131,94 @@
             skeleton.summary = skeleton.summary.decode("utf-8")
             skeleton.description = skeleton.description.decode("utf-8")
     return skeleton
+<<<<<<< TREE
+=======
+
+build_skeleton.inited = False
+
+
+def relation_to_string(relation_tuple):
+    """Convert an apt relation to a string representation.
+
+    @param relation_tuple: A tuple, (name, version, relation). version
+        and relation can be the empty string, if the relation is on a
+        name only.
+
+    Returns something like "name > 1.0"
+    """
+    name, version, relation_type = relation_tuple
+    relation_string = name
+    if relation_type:
+        relation_string += " %s %s" % (relation_type, version)
+    return relation_string
+
+
+def parse_record_field(record, record_field, relation_type,
+                       or_relation_type=None):
+    """Parse an apt C{Record} field and return skeleton relations
+
+    @param record: An C{apt.package.Record} instance with package information.
+    @param record_field: The name of the record field to parse.
+    @param relation_type: The deb relation that can be passed to
+        C{skeleton.add_relation()}
+    @param or_relation_type: The deb relation that should be used if
+        there is more than one value in a relation.
+    """
+    relations = set()
+    values = apt_pkg.parse_depends(record.get(record_field, ""))
+    for value in values:
+        value_strings = [relation_to_string(relation) for relation in value]
+        value_relation_type = relation_type
+        if len(value_strings) > 1:
+            value_relation_type = or_relation_type
+        relation_string = " | ".join(value_strings)
+        relations.add((value_relation_type, relation_string))
+    return relations
+
+
+def build_skeleton_apt(version, with_info=False, with_unicode=False):
+    """Build a package skeleton from an apt package.
+
+    @param version: An instance of C{apt.package.Version}
+    @param with_info: Whether to extract extra information about the
+        package, like description, summary, size.
+    @param with_unicode: Whether the C{name} and C{version} of the
+        skeleton should be unicode strings.
+    """
+    name, version_string = version.package.name, version.version
+    if with_unicode:
+        name, version_string = unicode(name), unicode(version_string)
+    skeleton = PackageSkeleton(DEB_PACKAGE, name, version_string)
+    relations = set()
+    relations.update(parse_record_field(
+        version.record, "Provides", DEB_PROVIDES))
+    relations.add((
+        DEB_NAME_PROVIDES,
+        "%s = %s" % (version.package.name, version.version)))
+    relations.update(parse_record_field(
+        version.record, "Pre-Depends", DEB_REQUIRES, DEB_OR_REQUIRES))
+    relations.update(parse_record_field(
+        version.record, "Depends", DEB_REQUIRES, DEB_OR_REQUIRES))
+
+    relations.add((
+        DEB_UPGRADES, "%s < %s" % (version.package.name, version.version)))
+
+    relations.update(parse_record_field(
+        version.record, "Conflicts", DEB_CONFLICTS))
+    relations.update(parse_record_field(
+        version.record, "Breaks", DEB_CONFLICTS))
+    skeleton.relations = sorted(relations)
+
+    if with_info:
+        skeleton.section = version.section
+        skeleton.summary = version.summary
+        skeleton.description = version.description
+        skeleton.size = version.size
+        if version.installed_size > 0:
+            skeleton.installed_size = version.installed_size
+        if with_unicode:
+            skeleton.section = skeleton.section.decode("utf-8")
+            skeleton.summary = skeleton.summary.decode("utf-8")
+            skeleton.description = skeleton.description.decode("utf-8")
+    return skeleton
+>>>>>>> MERGE-SOURCE
 
=== modified file 'landscape/package/store.py'
=== modified file 'landscape/package/taskhandler.py'
--- landscape/package/taskhandler.py	2012-06-19 15:12:07 +0000
+++ landscape/package/taskhandler.py	2014-11-19 18:22:39 +0000
@@ -258,11 +258,23 @@
     # 0644 so...
     os.umask(022)
 
+<<<<<<< TREE
     package_store = cls.package_store_class(config.store_filename)
     # Delay importing of the facades so that we don't
     # import Apt unless we need to.
     from landscape.package.facade import AptFacade
     package_facade = AptFacade()
+=======
+    package_store = cls.package_store_class(config.store_filename)
+    # Delay importing of the facades so that we don't
+    # import Smart unless we need to.
+    from landscape.package.facade import (
+        AptFacade, SmartFacade, has_new_enough_apt)
+    if  has_new_enough_apt:
+        package_facade = AptFacade()
+    else:
+        package_facade = SmartFacade()
+>>>>>>> MERGE-SOURCE
 
     def finish():
         connector.disconnect()
 
=== modified file 'landscape/package/tests/helpers.py'
--- landscape/package/tests/helpers.py	2012-06-19 15:12:07 +0000
+++ landscape/package/tests/helpers.py	2014-11-19 18:22:39 +0000
@@ -1,121 +1,256 @@
 import base64
 import os
-import textwrap
-import time
-
-import apt_inst
-import apt_pkg
-
-from landscape.lib.fs import append_file, create_file
-from landscape.package.facade import AptFacade
-
-
-class AptFacadeHelper(object):
-    """Helper that sets up an AptFacade with a tempdir as its root."""
-
-    def set_up(self, test_case):
-        test_case.apt_root = test_case.makeDir()
-        self.dpkg_status = os.path.join(
-            test_case.apt_root, "var", "lib", "dpkg", "status")
-        test_case.Facade = AptFacade
-        test_case.facade = AptFacade(root=test_case.apt_root)
-        test_case.facade.refetch_package_index = True
-        test_case._add_system_package = self._add_system_package
-        test_case._install_deb_file = self._install_deb_file
-        test_case._add_package_to_deb_dir = self._add_package_to_deb_dir
-        test_case._touch_packages_file = self._touch_packages_file
-        test_case._hash_packages_by_name = self._hash_packages_by_name
-
-    def _add_package(self, packages_file, name, architecture="all",
-                     version="1.0", control_fields=None):
-        if control_fields is None:
-            control_fields = {}
-        package_stanza = textwrap.dedent("""
-                Package: %(name)s
-                Priority: optional
-                Section: misc
-                Installed-Size: 1234
-                Maintainer: Someone
-                Architecture: %(architecture)s
-                Source: source
-                Version: %(version)s
-                Description: description
-                """ % {"name": name, "version": version,
-                       "architecture": architecture})
-        package_stanza = apt_pkg.rewrite_section(
-            apt_pkg.TagSection(package_stanza), apt_pkg.REWRITE_PACKAGE_ORDER,
-            control_fields.items())
-        append_file(packages_file, "\n" + package_stanza + "\n")
-
-    def _add_system_package(self, name, architecture="all", version="1.0",
-                            control_fields=None):
-        """Add a package to the dpkg status file."""
-        system_control_fields = {"Status": "install ok installed"}
-        if control_fields is not None:
-            system_control_fields.update(control_fields)
-        self._add_package(
-            self.dpkg_status, name, architecture=architecture, version=version,
-            control_fields=system_control_fields)
-
-    def _install_deb_file(self, path):
-        """Fake the the given deb file is installed in the system."""
-        deb_file = open(path)
-        deb = apt_inst.DebFile(deb_file)
-        control = deb.control.extractdata("control")
-        deb_file.close()
-        lines = control.splitlines()
-        lines.insert(1, "Status: install ok installed")
-        status = "\n".join(lines)
-        append_file(self.dpkg_status, status + "\n\n")
-
-    def _add_package_to_deb_dir(self, path, name, architecture="all",
-                                version="1.0", control_fields=None):
-        """Add fake package information to a directory.
-
-        There will only be basic information about the package
-        available, so that get_packages() have something to return.
-        There won't be an actual package in the dir.
-        """
-        if control_fields is None:
-            control_fields = {}
-        self._add_package(
-            os.path.join(path, "Packages"), name, architecture=architecture,
-            version=version, control_fields=control_fields)
-
-    def _touch_packages_file(self, deb_dir):
-        """Make sure the Packages file get a newer mtime value.
-
-        If we rely on simply writing to the file to update the mtime, we
-        might end up with the same as before, since the resolution is
-        seconds, which causes apt to not reload the file.
-        """
-        packages_path = os.path.join(deb_dir, "Packages")
-        mtime = int(time.time() + 1)
-        os.utime(packages_path, (mtime, mtime))
-
-    def _hash_packages_by_name(self, facade, store, package_name):
-        """
-        Ensure the named L{Package} is correctly recorded in the store so that
-        we can really test the functions of the facade that depend on it.
-        """
-        hash_ids = {}
-        for version in facade.get_packages_by_name(package_name):
-            skeleton = facade.get_package_skeleton(
-                version, with_info=False)
-            hash = skeleton.get_hash()
-            facade._pkg2hash[(version.package, version)] = hash
-            hash_ids[hash] = version.package.id
-        store.set_hash_ids(hash_ids)
-
-
-class SimpleRepositoryHelper(object):
-    """Helper for adding a simple repository to the facade.
-
-    This helper requires that C{test_case.facade} has already been set
-    up.
-    """
-
-    def set_up(self, test_case):
+<<<<<<< TREE
+import textwrap
+import time
+
+import apt_inst
+import apt_pkg
+
+from landscape.lib.fs import append_file, create_file
+from landscape.package.facade import AptFacade
+
+
+class AptFacadeHelper(object):
+    """Helper that sets up an AptFacade with a tempdir as its root."""
+
+    def set_up(self, test_case):
+        test_case.apt_root = test_case.makeDir()
+        self.dpkg_status = os.path.join(
+            test_case.apt_root, "var", "lib", "dpkg", "status")
+        test_case.Facade = AptFacade
+        test_case.facade = AptFacade(root=test_case.apt_root)
+        test_case.facade.refetch_package_index = True
+        test_case._add_system_package = self._add_system_package
+        test_case._install_deb_file = self._install_deb_file
+        test_case._add_package_to_deb_dir = self._add_package_to_deb_dir
+        test_case._touch_packages_file = self._touch_packages_file
+        test_case._hash_packages_by_name = self._hash_packages_by_name
+
+    def _add_package(self, packages_file, name, architecture="all",
+                     version="1.0", control_fields=None):
+        if control_fields is None:
+            control_fields = {}
+        package_stanza = textwrap.dedent("""
+                Package: %(name)s
+                Priority: optional
+                Section: misc
+                Installed-Size: 1234
+                Maintainer: Someone
+                Architecture: %(architecture)s
+                Source: source
+                Version: %(version)s
+                Description: description
+                """ % {"name": name, "version": version,
+                       "architecture": architecture})
+        package_stanza = apt_pkg.rewrite_section(
+            apt_pkg.TagSection(package_stanza), apt_pkg.REWRITE_PACKAGE_ORDER,
+            control_fields.items())
+        append_file(packages_file, "\n" + package_stanza + "\n")
+
+    def _add_system_package(self, name, architecture="all", version="1.0",
+                            control_fields=None):
+        """Add a package to the dpkg status file."""
+        system_control_fields = {"Status": "install ok installed"}
+        if control_fields is not None:
+            system_control_fields.update(control_fields)
+        self._add_package(
+            self.dpkg_status, name, architecture=architecture, version=version,
+            control_fields=system_control_fields)
+
+    def _install_deb_file(self, path):
+        """Fake the the given deb file is installed in the system."""
+        deb_file = open(path)
+        deb = apt_inst.DebFile(deb_file)
+        control = deb.control.extractdata("control")
+        deb_file.close()
+        lines = control.splitlines()
+        lines.insert(1, "Status: install ok installed")
+        status = "\n".join(lines)
+        append_file(self.dpkg_status, status + "\n\n")
+
+    def _add_package_to_deb_dir(self, path, name, architecture="all",
+                                version="1.0", control_fields=None):
+        """Add fake package information to a directory.
+
+        There will only be basic information about the package
+        available, so that get_packages() have something to return.
+        There won't be an actual package in the dir.
+        """
+        if control_fields is None:
+            control_fields = {}
+        self._add_package(
+            os.path.join(path, "Packages"), name, architecture=architecture,
+            version=version, control_fields=control_fields)
+
+    def _touch_packages_file(self, deb_dir):
+        """Make sure the Packages file get a newer mtime value.
+
+        If we rely on simply writing to the file to update the mtime, we
+        might end up with the same as before, since the resolution is
+        seconds, which causes apt to not reload the file.
+        """
+        packages_path = os.path.join(deb_dir, "Packages")
+        mtime = int(time.time() + 1)
+        os.utime(packages_path, (mtime, mtime))
+
+    def _hash_packages_by_name(self, facade, store, package_name):
+        """
+        Ensure the named L{Package} is correctly recorded in the store so that
+        we can really test the functions of the facade that depend on it.
+        """
+        hash_ids = {}
+        for version in facade.get_packages_by_name(package_name):
+            skeleton = facade.get_package_skeleton(
+                version, with_info=False)
+            hash = skeleton.get_hash()
+            facade._pkg2hash[(version.package, version)] = hash
+            hash_ids[hash] = version.package.id
+        store.set_hash_ids(hash_ids)
+
+
+class SimpleRepositoryHelper(object):
+    """Helper for adding a simple repository to the facade.
+
+    This helper requires that C{test_case.facade} has already been set
+    up.
+    """
+
+    def set_up(self, test_case):
+=======
+import textwrap
+import time
+
+try:
+    import smart
+except ImportError:
+    # Smart is optional if AptFacade is being used.
+    pass
+
+import apt_inst
+import apt_pkg
+
+from landscape.lib.fs import append_file, create_file
+from landscape.package.facade import AptFacade
+
+
+class AptFacadeHelper(object):
+    """Helper that sets up an AptFacade with a tempdir as its root."""
+
+    def set_up(self, test_case):
+        test_case.apt_root = test_case.makeDir()
+        self.dpkg_status = os.path.join(
+            test_case.apt_root, "var", "lib", "dpkg", "status")
+        test_case.Facade = AptFacade
+        test_case.facade = AptFacade(root=test_case.apt_root)
+        test_case.facade.refetch_package_index = True
+        test_case._add_system_package = self._add_system_package
+        test_case._install_deb_file = self._install_deb_file
+        test_case._add_package_to_deb_dir = self._add_package_to_deb_dir
+        test_case._touch_packages_file = self._touch_packages_file
+        test_case._hash_packages_by_name = self._hash_packages_by_name
+
+    def _add_package(self, packages_file, name, architecture="all",
+                     version="1.0", control_fields=None):
+        if control_fields is None:
+            control_fields = {}
+        package_stanza = textwrap.dedent("""
+                Package: %(name)s
+                Priority: optional
+                Section: misc
+                Installed-Size: 1234
+                Maintainer: Someone
+                Architecture: %(architecture)s
+                Source: source
+                Version: %(version)s
+                Description: description
+                """ % {"name": name, "version": version,
+                       "architecture": architecture})
+        package_stanza = apt_pkg.rewrite_section(
+            apt_pkg.TagSection(package_stanza), apt_pkg.REWRITE_PACKAGE_ORDER,
+            control_fields.items())
+        append_file(packages_file, "\n" + package_stanza + "\n")
+
+    def _add_system_package(self, name, architecture="all", version="1.0",
+                            control_fields=None):
+        """Add a package to the dpkg status file."""
+        system_control_fields = {"Status": "install ok installed"}
+        if control_fields is not None:
+            system_control_fields.update(control_fields)
+        self._add_package(
+            self.dpkg_status, name, architecture=architecture, version=version,
+            control_fields=system_control_fields)
+
+    def _install_deb_file(self, path):
+        """Fake the the given deb file is installed in the system."""
+        deb_file = open(path)
+        deb = apt_inst.DebFile(deb_file)
+        control = deb.control.extractdata("control")
+        deb_file.close()
+        lines = control.splitlines()
+        lines.insert(1, "Status: install ok installed")
+        status = "\n".join(lines)
+        append_file(self.dpkg_status, status + "\n\n")
+
+    def _add_package_to_deb_dir(self, path, name, architecture="all",
+                                version="1.0", control_fields=None):
+        """Add fake package information to a directory.
+
+        There will only be basic information about the package
+        available, so that get_packages() have something to return.
+        There won't be an actual package in the dir.
+        """
+        if control_fields is None:
+            control_fields = {}
+        self._add_package(
+            os.path.join(path, "Packages"), name, architecture=architecture,
+            version=version, control_fields=control_fields)
+
+    def _touch_packages_file(self, deb_dir):
+        """Make sure the Packages file get a newer mtime value.
+
+        If we rely on simply writing to the file to update the mtime, we
+        might end up with the same as before, since the resolution is
+        seconds, which causes apt to not reload the file.
+        """
+        packages_path = os.path.join(deb_dir, "Packages")
+        mtime = int(time.time() + 1)
+        os.utime(packages_path, (mtime, mtime))
+
+    def _hash_packages_by_name(self, facade, store, package_name):
+        """
+        Ensure the named L{Package} is correctly recorded in the store so that
+        we can really test the functions of the facade that depend on it.
+        """
+        hash_ids = {}
+        for version in facade.get_packages_by_name(package_name):
+            skeleton = facade.get_package_skeleton(
+                version, with_info=False)
+            hash = skeleton.get_hash()
+            facade._pkg2hash[(version.package, version)] = hash
+            hash_ids[hash] = version.package.id
+        store.set_hash_ids(hash_ids)
+
+
+class SimpleRepositoryHelper(object):
+    """Helper for adding a simple repository to the facade.
+
+    This helper requires that C{test_case.facade} has already been set
+    up.
+    """
+
+    def set_up(self, test_case):
+        test_case.repository_dir = test_case.makeDir()
+        create_simple_repository(test_case.repository_dir)
+        test_case.facade.add_channel_deb_dir(test_case.repository_dir)
+
+
+class SmartHelper(object):
+
+    def set_up(self, test_case):
+        test_case.smart_dir = test_case.makeDir()
+        test_case.smart_config = test_case.makeFile("")
+>>>>>>> MERGE-SOURCE
         test_case.repository_dir = test_case.makeDir()
         create_simple_repository(test_case.repository_dir)
         test_case.facade.add_channel_deb_dir(test_case.repository_dir)
 
=== modified file 'landscape/package/tests/test_changer.py'
--- landscape/package/tests/test_changer.py	2012-06-19 15:12:07 +0000
+++ landscape/package/tests/test_changer.py	2014-11-19 18:22:39 +0000
@@ -6,20 +6,35 @@
 
 from twisted.internet.defer import Deferred
 
-from landscape.lib.fs import create_file, read_file, touch_file
+<<<<<<< TREE
+from landscape.lib.fs import create_file, read_file, touch_file
+=======
+try:
+    from smart.cache import Provides
+except ImportError:
+    # Smart is optional if AptFacade is being used.
+    pass
+
+from landscape.lib.fs import create_file, read_file, touch_file
+>>>>>>> MERGE-SOURCE
 from landscape.package.changer import (
     PackageChanger, main, find_changer_command, UNKNOWN_PACKAGE_DATA_TIMEOUT,
     SUCCESS_RESULT, DEPENDENCY_ERROR_RESULT, POLICY_ALLOW_INSTALLS,
     POLICY_ALLOW_ALL_CHANGES, ERROR_RESULT)
 from landscape.package.store import PackageStore
 from landscape.package.facade import (
+<<<<<<< TREE
     DependencyError, TransactionError)
+=======
+    DependencyError, TransactionError, SmartError, has_new_enough_apt)
+>>>>>>> MERGE-SOURCE
 from landscape.package.changer import (
     PackageChangerConfiguration, ChangePackagesResult)
 from landscape.tests.mocker import ANY
 from landscape.tests.helpers import (
     LandscapeTest, BrokerServiceHelper)
 from landscape.package.tests.helpers import (
+<<<<<<< TREE
     HASH1, HASH2, HASH3, PKGDEB1, PKGDEB2,
     AptFacadeHelper, SimpleRepositoryHelper)
 from landscape.manager.manager import FAILED
@@ -47,7 +62,25 @@
 
         result = super(AptPackageChangerTest, self).setUp()
         return result.addCallback(set_up)
-
+=======
+    SmartFacadeHelper, HASH1, HASH2, HASH3, PKGDEB1, PKGDEB2, PKGNAME2,
+    AptFacadeHelper, SimpleRepositoryHelper)
+from landscape.manager.manager import FAILED, SUCCEEDED
+
+
+class PackageChangerTestMixin(object):
+
+    def disable_clear_channels(self):
+        """Disable clear_channels(), so that it doesn't remove test setup.
+
+        This is useful for change-packages tests, which will call
+        facade.clear_channels(). Normally that's safe, but since we used
+        the facade to set up channels, we don't want them to be removed.
+        """
+        self.facade.clear_channels = lambda: None
+>>>>>>> MERGE-SOURCE
+
+<<<<<<< TREE
     def set_pkg1_installed(self):
         """Return the hash of a package that is installed."""
         self._add_system_package("foo")
@@ -135,6 +168,19 @@
 
         self.addCleanup(reset_perform_changes, self.Facade)
         self.Facade.perform_changes = func
+=======
+    def get_pending_messages(self):
+        return self.broker_service.message_store.get_pending_messages()
+
+    def replace_perform_changes(self, func):
+        old_perform_changes = self.Facade.perform_changes
+
+        def reset_perform_changes(Facade):
+            Facade.perform_changes = old_perform_changes
+
+        self.addCleanup(reset_perform_changes, self.Facade)
+        self.Facade.perform_changes = func
+>>>>>>> MERGE-SOURCE
 
     def test_unknown_package_id_for_dependency(self):
         hash1, hash2 = self.set_pkg1_and_pkg2_satisfied()
@@ -511,6 +557,7 @@
                             {"type": "change-packages", "upgrade-all": True,
                              "operation-id": 124})
 
+<<<<<<< TREE
         result = self.changer.handle_tasks()
 
         def got_result(result):
@@ -554,6 +601,51 @@
             self.assertEqual(124, message2["operation-id"])
             self.assertEqual("change-packages-result", message2["type"])
             self.assertEqual(ERROR_RESULT, message2["result-code"])
+=======
+        result = self.changer.handle_tasks()
+
+        def got_result(result):
+            message = self.get_pending_messages()[1]
+            self.assertEqual(124, message["operation-id"])
+            self.assertEqual("change-packages-result", message["type"])
+            self.assertNotEqual(0, message["result-code"])
+
+        return result.addCallback(got_result)
+
+    def test_tasks_are_isolated_cache(self):
+        """
+        The package (apt/smart) cache should be reset between task runs.
+        In this test, we try to run two different operations, first
+        installing package 2, then removing package 1.  Both tasks will
+        fail for lack of superuser privileges.  If the package cache
+        isn't reset between tasks, the second operation will fail with a
+        dependency error, since it will be marked for installation, but
+        we haven't explicitly marked it so.
+        """
+        self.log_helper.ignore_errors(".*dpkg")
+
+        installable_hash = self.set_pkg2_satisfied()
+        installed_hash = self.set_pkg1_installed()
+        self.store.set_hash_ids({installed_hash: 1, installable_hash: 2})
+
+        self.store.add_task("changer",
+                            {"type": "change-packages", "install": [2],
+                             "operation-id": 123})
+        self.store.add_task("changer",
+                            {"type": "change-packages", "remove": [1],
+                             "operation-id": 124})
+
+        result = self.changer.handle_tasks()
+
+        def got_result(result):
+            message1, message2 = self.get_pending_messages()
+            self.assertEqual(123, message1["operation-id"])
+            self.assertEqual("change-packages-result", message1["type"])
+            self.assertEqual(ERROR_RESULT, message1["result-code"])
+            self.assertEqual(124, message2["operation-id"])
+            self.assertEqual("change-packages-result", message2["type"])
+            self.assertEqual(ERROR_RESULT, message2["result-code"])
+>>>>>>> MERGE-SOURCE
 
         return result.addCallback(got_result)
 
@@ -873,27 +965,72 @@
 
         def raise_error(self):
             raise TransactionError(u"áéíóú")
-        self.replace_perform_changes(raise_error)
-        self.disable_clear_channels()
-
-        result = self.changer.handle_tasks()
-
-        def got_result(result):
-            self.assertMessages(self.get_pending_messages(),
-                                [{"operation-id": 123,
-                                  "result-code": 100,
-                                  "result-text": u"áéíóú",
-                                  "type": "change-packages-result"}])
-        return result.addCallback(got_result)
-
-    def test_update_stamp_exists(self):
-        """
-        L{PackageChanger.update_exists} returns C{True} if the
-        update-stamp file is there, C{False} otherwise.
-        """
-        self.assertTrue(self.changer.update_stamp_exists())
-        os.remove(self.config.update_stamp_filename)
-        self.assertFalse(self.changer.update_stamp_exists())
+<<<<<<< TREE
+        self.replace_perform_changes(raise_error)
+        self.disable_clear_channels()
+
+        result = self.changer.handle_tasks()
+
+        def got_result(result):
+            self.assertMessages(self.get_pending_messages(),
+                                [{"operation-id": 123,
+                                  "result-code": 100,
+                                  "result-text": u"áéíóú",
+                                  "type": "change-packages-result"}])
+        return result.addCallback(got_result)
+
+    def test_update_stamp_exists(self):
+        """
+        L{PackageChanger.update_exists} returns C{True} if the
+        update-stamp file is there, C{False} otherwise.
+        """
+        self.assertTrue(self.changer.update_stamp_exists())
+        os.remove(self.config.update_stamp_filename)
+        self.assertFalse(self.changer.update_stamp_exists())
+=======
+        self.replace_perform_changes(raise_error)
+        self.disable_clear_channels()
+
+        result = self.changer.handle_tasks()
+
+        def got_result(result):
+            self.assertMessages(self.get_pending_messages(),
+                                [{"operation-id": 123,
+                                  "result-code": 100,
+                                  "result-text": u"áéíóú",
+                                  "type": "change-packages-result"}])
+        return result.addCallback(got_result)
+
+    def test_smart_error_with_unicode_data(self):
+        self.store.set_hash_ids({HASH1: 1})
+        self.store.add_task("changer",
+                            {"type": "change-packages", "install": [1],
+                             "operation-id": 123})
+
+        def raise_error(self):
+            raise SmartError(u"áéíóú")
+        self.replace_perform_changes(raise_error)
+        self.disable_clear_channels()
+
+        result = self.changer.handle_tasks()
+
+        def got_result(result):
+            self.assertMessages(self.get_pending_messages(),
+                                [{"operation-id": 123,
+                                  "result-code": 100,
+                                  "result-text": u"áéíóú",
+                                  "type": "change-packages-result"}])
+        return result.addCallback(got_result)
+
+    def test_update_stamp_exists(self):
+        """
+        L{PackageChanger.update_exists} returns C{True} if the
+        update-stamp file is there, C{False} otherwise.
+        """
+        self.assertTrue(self.changer.update_stamp_exists())
+        os.remove(self.config.update_stamp_filename)
+        self.assertFalse(self.changer.update_stamp_exists())
+>>>>>>> MERGE-SOURCE
 
     def test_binaries_path(self):
         self.assertEqual(
@@ -946,6 +1083,7 @@
         self.changer.init_channels([])
         self.assertFalse(os.path.exists(existing_deb_path))
 
+<<<<<<< TREE
 
     def test_binaries_available_in_cache(self):
         """
@@ -974,6 +1112,101 @@
         return result.addCallback(got_result)
 
     def test_change_package_holds(self):
+=======
+
+class SmartPackageChangerTest(LandscapeTest, PackageChangerTestMixin):
+
+    helpers = [SmartFacadeHelper, BrokerServiceHelper]
+
+    def setUp(self):
+
+        def set_up(ignored):
+
+            self.store = PackageStore(self.makeFile())
+            self.config = PackageChangerConfiguration()
+            self.config.data_path = self.makeDir()
+            os.mkdir(self.config.package_directory)
+            os.mkdir(self.config.binaries_path)
+            touch_file(self.config.update_stamp_filename)
+            self.changer = PackageChanger(
+                self.store, self.facade, self.remote, self.config)
+            service = self.broker_service
+            service.message_store.set_accepted_types(["change-packages-result",
+                                                      "operation-result"])
+
+        result = super(SmartPackageChangerTest, self).setUp()
+        return result.addCallback(set_up)
+
+    def set_pkg1_installed(self):
+        previous = self.Facade.channels_reloaded
+
+        def callback(self):
+            previous(self)
+            self.get_packages_by_name("name1")[0].installed = True
+        self.Facade.channels_reloaded = callback
+        return HASH1
+
+    def set_pkg2_upgrades_pkg1(self):
+        previous = self.Facade.channels_reloaded
+
+        def callback(self):
+            from smart.backends.deb.base import DebUpgrades
+            previous(self)
+            [pkg2] = self.get_packages_by_name("name2")
+            pkg2.upgrades += (DebUpgrades("name1", "=", "version1-release1"),)
+            self.reload_cache()  # Relink relations.
+        self.Facade.channels_reloaded = callback
+        self.set_pkg2_satisfied()
+        self.set_pkg1_installed()
+        return HASH1, HASH2
+
+    def set_pkg2_satisfied(self):
+        previous = self.Facade.channels_reloaded
+
+        def callback(self):
+            previous(self)
+            [pkg2] = self.get_packages_by_name("name2")
+            pkg2.requires = ()
+            self.reload_cache()  # Relink relations.
+        self.Facade.channels_reloaded = callback
+        return HASH2
+
+    def set_pkg1_and_pkg2_satisfied(self):
+        previous = self.Facade.channels_reloaded
+
+        def callback(self):
+            previous(self)
+
+            provide1 = Provides("prerequirename1", "prerequireversion1")
+            provide2 = Provides("requirename1", "requireversion1")
+            [pkg2] = self.get_packages_by_name("name2")
+            pkg2.provides += (provide1, provide2)
+
+            provide1 = Provides("prerequirename2", "prerequireversion2")
+            provide2 = Provides("requirename2", "requireversion2")
+            [pkg1] = self.get_packages_by_name("name1")
+            pkg1.provides += (provide1, provide2)
+
+            # Ask Smart to reprocess relationships.
+            self.reload_cache()
+        self.Facade.channels_reloaded = callback
+        return HASH1, HASH2
+
+    def remove_pkg2(self):
+        os.remove(os.path.join(self.repository_dir, PKGNAME2))
+
+    def get_transaction_error_message(self):
+        return "requirename1 = requireversion1"
+
+    def get_binaries_channels(self, binaries_path):
+        return {binaries_path: {"type": "deb-dir",
+                                "path": binaries_path}}
+
+    def get_package_name(self, package):
+        return package.name
+
+    def test_change_package_locks(self):
+>>>>>>> MERGE-SOURCE
         """
         The L{PackageChanger.handle_tasks} method appropriately creates and
         deletes package holds as requested by the C{change-packages}
@@ -1331,42 +1564,738 @@
                                         "operation-id": 123})
 
         def assert_result(result):
-            self.assertMessages(
-                self.get_pending_messages(),
-                [{"type": "operation-result",
-                  "operation-id": 123,
-                  "status": FAILED,
-                  "result-text": "This client doesn't support package locks.",
-                  "result-code": 1}])
-
-        result = self.changer.handle_tasks()
-        return result.addCallback(assert_result)
-
-    def test_change_packages_with_binaries_removes_binaries(self):
-        """
-        After the C{change-packages} handler has installed the binaries,
-        the binaries and the internal facade deb source is removed.
-        """
-        self.store.add_task("changer",
-                            {"type": "change-packages", "install": [2],
-                             "binaries": [(HASH2, 2, PKGDEB2)],
-                             "operation-id": 123})
-
-        def return_good_result(self):
-            return "Yeah, I did whatever you've asked for!"
-        self.replace_perform_changes(return_good_result)
-
-        result = self.changer.handle_tasks()
-
-        def got_result(result):
-            self.assertMessages(self.get_pending_messages(),
-                                [{"operation-id": 123,
-                                  "result-code": 1,
-                                  "result-text": "Yeah, I did whatever you've "
-                                                 "asked for!",
-                                  "type": "change-packages-result"}])
-            self.assertEqual([], os.listdir(self.config.binaries_path))
-            self.assertFalse(
-                os.path.exists(self.facade._get_internal_sources_list()))
-
-        return result.addCallback(got_result)
+<<<<<<< TREE
+            self.assertMessages(
+                self.get_pending_messages(),
+                [{"type": "operation-result",
+                  "operation-id": 123,
+                  "status": FAILED,
+                  "result-text": "This client doesn't support package locks.",
+                  "result-code": 1}])
+
+        result = self.changer.handle_tasks()
+        return result.addCallback(assert_result)
+
+    def test_change_packages_with_binaries_removes_binaries(self):
+        """
+        After the C{change-packages} handler has installed the binaries,
+        the binaries and the internal facade deb source is removed.
+        """
+        self.store.add_task("changer",
+                            {"type": "change-packages", "install": [2],
+                             "binaries": [(HASH2, 2, PKGDEB2)],
+                             "operation-id": 123})
+
+        def return_good_result(self):
+            return "Yeah, I did whatever you've asked for!"
+        self.replace_perform_changes(return_good_result)
+
+        result = self.changer.handle_tasks()
+
+        def got_result(result):
+            self.assertMessages(self.get_pending_messages(),
+                                [{"operation-id": 123,
+                                  "result-code": 1,
+                                  "result-text": "Yeah, I did whatever you've "
+                                                 "asked for!",
+                                  "type": "change-packages-result"}])
+            self.assertEqual([], os.listdir(self.config.binaries_path))
+            self.assertFalse(
+                os.path.exists(self.facade._get_internal_sources_list()))
+
+        return result.addCallback(got_result)
+=======
+            self.facade.deinit()
+            self.assertEqual(self.facade.get_package_locks(),
+                             [("foo", ">=", "1.0")])
+            self.assertIn("Queuing message with change package locks results "
+                          "to exchange urgently.", self.logfile.getvalue())
+            self.assertMessages(self.get_pending_messages(),
+                                [{"type": "operation-result",
+                                  "operation-id": 123,
+                                  "status": SUCCEEDED,
+                                  "result-text": "Package locks successfully"
+                                                 " changed.",
+                                  "result-code": 0}])
+
+        result = self.changer.handle_tasks()
+        return result.addCallback(assert_result)
+
+    def test_change_package_locks_create_with_already_existing(self):
+        """
+        The L{PackageChanger.handle_tasks} method gracefully handles requests
+        for creating package locks that already exist.
+        """
+        self.facade.set_package_lock("foo")
+        self.store.add_task("changer", {"type": "change-package-locks",
+                                        "create": [("foo", None, None)],
+                                        "operation-id": 123})
+
+        def assert_result(result):
+            self.facade.deinit()
+            self.assertEqual(self.facade.get_package_locks(),
+                             [("foo", "", "")])
+            self.assertMessages(self.get_pending_messages(),
+                                [{"type": "operation-result",
+                                  "operation-id": 123,
+                                  "status": SUCCEEDED,
+                                  "result-text": "Package locks successfully"
+                                                 " changed.",
+                                  "result-code": 0}])
+
+        result = self.changer.handle_tasks()
+        return result.addCallback(assert_result)
+
+    def test_change_package_locks_delete_without_already_existing(self):
+        """
+        The L{PackageChanger.handle_tasks} method gracefully handles requests
+        for deleting package locks that don't exist.
+        """
+        self.store.add_task("changer", {"type": "change-package-locks",
+                                        "delete": [("foo", ">=", "1.0")],
+                                        "operation-id": 123})
+
+        def assert_result(result):
+            self.facade.deinit()
+            self.assertEqual(self.facade.get_package_locks(), [])
+            self.assertMessages(self.get_pending_messages(),
+                                [{"type": "operation-result",
+                                  "operation-id": 123,
+                                  "status": SUCCEEDED,
+                                  "result-text": "Package locks successfully"
+                                                 " changed.",
+                                  "result-code": 0}])
+
+        result = self.changer.handle_tasks()
+        return result.addCallback(assert_result)
+
+    def test_dpkg_error(self):
+        """
+        Verify that errors emitted by dpkg are correctly reported to
+        the server as problems.
+
+        This test is to make sure that Smart reports the problem
+        correctly. It doesn't make sense for AptFacade, since there we
+        don't call dpkg.
+        """
+        self.log_helper.ignore_errors(".*dpkg")
+
+        installed_hash = self.set_pkg1_installed()
+        self.store.set_hash_ids({installed_hash: 1})
+        self.store.add_task("changer",
+                            {"type": "change-packages", "remove": [1],
+                             "operation-id": 123})
+
+        result = self.changer.handle_tasks()
+
+        def got_result(result):
+            messages = self.get_pending_messages()
+            self.assertEqual(len(messages), 1, "Too many messages")
+            message = messages[0]
+            self.assertEqual(message["operation-id"], 123)
+            self.assertEqual(message["result-code"], 100)
+            self.assertEqual(message["type"], "change-packages-result")
+            text = message["result-text"]
+            # We can't test the actual content of the message because the dpkg
+            # error can be localized
+            self.assertIn("\n[remove] name1_version1-release1\ndpkg: ", text)
+            self.assertIn("ERROR", text)
+            self.assertIn("(2)", text)
+        return result.addCallback(got_result)
+
+    def test_change_package_holds(self):
+        """
+        If C{SmartFacade} is used, the L{PackageChanger.handle_tasks}
+        method fails the activity, since it can't add or remove dpkg holds.
+        """
+        self.facade.reload_channels()
+        self.store.add_task("changer", {"type": "change-package-holds",
+                                        "create": [1],
+                                        "delete": [2],
+                                        "operation-id": 123})
+
+        def assert_result(result):
+            self.assertIn("Queuing message with change package holds results "
+                          "to exchange urgently.", self.logfile.getvalue())
+            self.assertMessages(
+                self.get_pending_messages(),
+                [{"type": "operation-result",
+                  "operation-id": 123,
+                  "status": FAILED,
+                  "result-text": "This client doesn't support package holds.",
+                  "result-code": 1}])
+
+        result = self.changer.handle_tasks()
+        return result.addCallback(assert_result)
+
+    def test_global_upgrade(self):
+        """
+        Besides asking for individual changes, the server may also request
+        the client to perform a global upgrade.  This would be the equivalent
+        of a "smart upgrade" command being executed in the command line.
+
+        This test should be run for both C{AptFacade} and
+        C{SmartFacade}, but due to the smart test setting up that two
+        packages with different names upgrade each other, the message
+        doesn't correctly report that the old version should be
+        uninstalled. The test is still useful, since it shows that the
+        message contains the changes that smart says are needed.
+
+        Making the test totally correct is a lot of work, that is not
+        worth doing, since we're removing smart soon.
+        """
+        hash1, hash2 = self.set_pkg2_upgrades_pkg1()
+        self.store.set_hash_ids({hash1: 1, hash2: 2})
+
+        self.store.add_task("changer",
+                            {"type": "change-packages", "upgrade-all": True,
+                             "operation-id": 123})
+
+        result = self.changer.handle_tasks()
+
+        def got_result(result):
+            self.assertMessages(self.get_pending_messages(),
+                                [{"operation-id": 123,
+                                  "must-install": [2],
+                                  "result-code": 101,
+                                  "type": "change-packages-result"}])
+
+        return result.addCallback(got_result)
+
+
+class AptPackageChangerTest(LandscapeTest, PackageChangerTestMixin):
+
+    if not has_new_enough_apt:
+        skip = "Can't use AptFacade on hardy"
+
+    helpers = [AptFacadeHelper, SimpleRepositoryHelper, BrokerServiceHelper]
+
+    def setUp(self):
+
+        def set_up(ignored):
+
+            self.store = PackageStore(self.makeFile())
+            self.config = PackageChangerConfiguration()
+            self.config.data_path = self.makeDir()
+            os.mkdir(self.config.package_directory)
+            os.mkdir(self.config.binaries_path)
+            touch_file(self.config.update_stamp_filename)
+            self.changer = PackageChanger(
+                self.store, self.facade, self.remote, self.config)
+            service = self.broker_service
+            service.message_store.set_accepted_types(["change-packages-result",
+                                                      "operation-result"])
+
+        result = super(AptPackageChangerTest, self).setUp()
+        return result.addCallback(set_up)
+
+    def set_pkg1_installed(self):
+        """Return the hash of a package that is installed."""
+        self._add_system_package("foo")
+        self.facade.reload_channels()
+        [foo] = self.facade.get_packages_by_name("foo")
+        return self.facade.get_package_hash(foo)
+
+    def set_pkg2_satisfied(self):
+        """Return the hash of a package that can be installed."""
+        self._add_package_to_deb_dir(self.repository_dir, "bar")
+        self.facade.reload_channels()
+        [bar] = self.facade.get_packages_by_name("bar")
+        return self.facade.get_package_hash(bar)
+
+    def set_pkg1_and_pkg2_satisfied(self):
+        """Make a package depend on another package.
+
+        Return the hashes of the two packages.
+        """
+        self._add_package_to_deb_dir(
+            self.repository_dir, "foo", control_fields={"Depends": "bar"})
+        self._add_package_to_deb_dir(self.repository_dir, "bar")
+        self.facade.reload_channels()
+        [foo] = self.facade.get_packages_by_name("foo")
+        [bar] = self.facade.get_packages_by_name("bar")
+        return (
+            self.facade.get_package_hash(foo),
+            self.facade.get_package_hash(bar))
+
+    def set_pkg2_upgrades_pkg1(self):
+        """Make it so that one package upgrades another.
+
+        Return the hashes of the two packages.
+        """
+        self._add_system_package("foo", version="1.0")
+        self._add_package_to_deb_dir(self.repository_dir, "foo", version="2.0")
+        self.facade.reload_channels()
+        foo_1, foo_2 = sorted(self.facade.get_packages_by_name("foo"))
+        return (
+            self.facade.get_package_hash(foo_1),
+            self.facade.get_package_hash(foo_2))
+
+    def remove_pkg2(self):
+        """Remove package name2 from its repository."""
+        packages_file = os.path.join(self.repository_dir, "Packages")
+        packages_contents = read_file(packages_file)
+        packages_contents = "\n\n".join(
+            [stanza for stanza in packages_contents.split("\n\n")
+             if "Package: name2" not in stanza])
+        create_file(packages_file, packages_contents)
+
+    def get_transaction_error_message(self):
+        """Return part of the apt transaction error message."""
+        return "Unable to correct problems"
+
+    def get_binaries_channels(self, binaries_path):
+        """Return the channels that will be used for the binaries."""
+        return [{"baseurl": "file://%s" % binaries_path,
+                 "components": "",
+                 "distribution": "./",
+                 "type": "deb"}]
+
+    def get_package_name(self, version):
+        """Return the name of the package."""
+        return version.package.name
+
+    def test_binaries_available_in_cache(self):
+        """
+        If binaries are included in the changes-packages message, those
+        will be added to the facade's cache.
+        """
+        # Make sure to turn off automatic rereading of Packages file,
+        # like it is by default.
+        self.facade.refetch_package_index = False
+        self.assertEqual(None, self.facade.get_package_by_hash(HASH2))
+        self.store.add_task("changer",
+                            {"type": "change-packages", "install": [2],
+                             "binaries": [(HASH2, 2, PKGDEB2)],
+                             "operation-id": 123})
+
+        def return_good_result(self):
+            return "Yeah, I did whatever you've asked for!"
+        self.replace_perform_changes(return_good_result)
+
+        result = self.changer.handle_tasks()
+
+        def got_result(result):
+            self.assertNotEqual(None, self.facade.get_package_by_hash(HASH2))
+            self.assertFalse(self.facade.refetch_package_index)
+
+        return result.addCallback(got_result)
+
+    def test_change_package_holds(self):
+        """
+        The L{PackageChanger.handle_tasks} method appropriately creates and
+        deletes package holds as requested by the C{change-package-holds}
+        message.
+        """
+        self._add_system_package("foo")
+        self._add_system_package("bar")
+        self.facade.reload_channels()
+        self._hash_packages_by_name(self.facade, self.store, "foo")
+        self._hash_packages_by_name(self.facade, self.store, "bar")
+        [foo] = self.facade.get_packages_by_name("foo")
+        [bar] = self.facade.get_packages_by_name("bar")
+        self.facade.set_package_hold(bar)
+        # Make sure that the mtime of the dpkg status file is old when
+        # apt loads it, so that it will be reloaded when asserting the
+        # test result.
+        old_mtime = time.time() - 10
+        os.utime(self.facade._dpkg_status, (old_mtime, old_mtime))
+        self.facade.reload_channels()
+        self.store.add_task("changer", {"type": "change-package-holds",
+                                        "create": [foo.package.id],
+                                        "delete": [bar.package.id],
+                                        "operation-id": 123})
+
+        def assert_result(result):
+            self.facade.reload_channels()
+            self.assertEqual(["foo"], self.facade.get_package_holds())
+            self.assertIn("Queuing message with change package holds results "
+                          "to exchange urgently.", self.logfile.getvalue())
+            self.assertMessages(
+                self.get_pending_messages(),
+                [{"type": "operation-result",
+                  "operation-id": 123,
+                  "status": SUCCEEDED,
+                  "result-text": "Package holds successfully changed.",
+                  "result-code": 0}])
+
+        result = self.changer.handle_tasks()
+        return result.addCallback(assert_result)
+
+    def test_create_package_holds_with_identical_version(self):
+        """
+        The L{PackageChanger.handle_tasks} method appropriately creates
+        holds as requested by the C{change-package-holds} message even
+        when versions from two different packages are the same.
+        """
+        self._add_system_package("foo", version="1.1")
+        self._add_system_package("bar", version="1.1")
+        self.facade.reload_channels()
+        self._hash_packages_by_name(self.facade, self.store, "foo")
+        self._hash_packages_by_name(self.facade, self.store, "bar")
+        [foo] = self.facade.get_packages_by_name("foo")
+        [bar] = self.facade.get_packages_by_name("bar")
+        self.facade.reload_channels()
+        self.store.add_task("changer", {"type": "change-package-holds",
+                                        "create": [foo.package.id,
+                                                   bar.package.id],
+                                        "operation-id": 123})
+
+        def assert_result(result):
+            self.assertEqual(["foo", "bar"], self.facade.get_package_holds())
+
+        result = self.changer.handle_tasks()
+        return result.addCallback(assert_result)
+
+    def test_delete_package_holds_with_identical_version(self):
+        """
+        The L{PackageChanger.handle_tasks} method appropriately deletes
+        holds as requested by the C{change-package-holds} message even
+        when versions from two different packages are the same.
+        """
+        self._add_system_package("foo", version="1.1")
+        self._add_system_package("bar", version="1.1")
+        self.facade.reload_channels()
+        self._hash_packages_by_name(self.facade, self.store, "foo")
+        self._hash_packages_by_name(self.facade, self.store, "bar")
+        [foo] = self.facade.get_packages_by_name("foo")
+        [bar] = self.facade.get_packages_by_name("bar")
+        self.facade.set_package_hold(foo)
+        self.facade.set_package_hold(bar)
+        self.facade.reload_channels()
+        self.store.add_task("changer", {"type": "change-package-holds",
+                                        "delete": [foo.package.id,
+                                                   bar.package.id],
+                                        "operation-id": 123})
+
+        def assert_result(result):
+            self.assertEqual([], self.facade.get_package_holds())
+
+        result = self.changer.handle_tasks()
+        return result.addCallback(assert_result)
+
+    def test_change_package_holds_create_already_held(self):
+        """
+        If the C{change-package-holds} message requests to add holds for
+        packages that are already held, the activity succeeds, since the
+        end result is that the requested package holds are there.
+        """
+        self._add_system_package("foo")
+        self.facade.reload_channels()
+        self._hash_packages_by_name(self.facade, self.store, "foo")
+        [foo] = self.facade.get_packages_by_name("foo")
+        self.facade.set_package_hold(foo)
+        self.facade.reload_channels()
+        self.store.add_task("changer", {"type": "change-package-holds",
+                                        "create": [foo.package.id],
+                                        "operation-id": 123})
+
+        def assert_result(result):
+            self.facade.reload_channels()
+            self.assertEqual(["foo"], self.facade.get_package_holds())
+            self.assertIn("Queuing message with change package holds results "
+                          "to exchange urgently.", self.logfile.getvalue())
+            self.assertMessages(
+                self.get_pending_messages(),
+                [{"type": "operation-result",
+                  "operation-id": 123,
+                  "status": SUCCEEDED,
+                  "result-text": "Package holds successfully changed.",
+                  "result-code": 0}])
+
+        result = self.changer.handle_tasks()
+        return result.addCallback(assert_result)
+
+    def test_change_package_holds_create_other_version_installed(self):
+        """
+        If the C{change-package-holds} message requests to add holds for
+        packages that have a different version installed than the one
+        being requested to hold, the activity fails.
+
+        The whole activity is failed, meaning that other valid hold
+        requests won't get processed.
+        """
+        self._add_system_package("foo", version="1.0")
+        self._add_package_to_deb_dir(
+            self.repository_dir, "foo", version="2.0")
+        self._add_system_package("bar", version="1.0")
+        self._add_package_to_deb_dir(
+            self.repository_dir, "bar", version="2.0")
+        self.facade.reload_channels()
+        [foo1, foo2] = sorted(self.facade.get_packages_by_name("foo"))
+        [bar1, bar2] = sorted(self.facade.get_packages_by_name("bar"))
+        self.store.set_hash_ids({self.facade.get_package_hash(foo1): 1,
+                                 self.facade.get_package_hash(foo2): 2,
+                                 self.facade.get_package_hash(bar1): 3,
+                                 self.facade.get_package_hash(bar2): 4})
+        self.facade.reload_channels()
+        self.store.add_task("changer", {"type": "change-package-holds",
+                                        "create": [2, 3],
+                                        "operation-id": 123})
+
+        def assert_result(result):
+            self.facade.reload_channels()
+            self.assertEqual([], self.facade.get_package_holds())
+            self.assertIn("Queuing message with change package holds results "
+                          "to exchange urgently.", self.logfile.getvalue())
+            self.assertMessages(
+                self.get_pending_messages(),
+                [{"type": "operation-result",
+                  "operation-id": 123,
+                  "status": FAILED,
+                  "result-text": "Package holds not changed, since the" +
+                                 " following packages are not installed: 2",
+                  "result-code": 1}])
+
+        result = self.changer.handle_tasks()
+        return result.addCallback(assert_result)
+
+    def test_change_package_holds_create_not_installed(self):
+        """
+        If the C{change-package-holds} message requests to add holds for
+        packages that aren't installed, the whole activity is failed. If
+        multiple holds are specified, those won't be added. There's no
+        difference between a package that is available in some
+        repository and a package that the facade doesn't know about at
+        all.
+        """
+        self._add_system_package("foo")
+        self._add_package_to_deb_dir(self.repository_dir, "bar")
+        self._add_package_to_deb_dir(self.repository_dir, "baz")
+        self.facade.reload_channels()
+        self._hash_packages_by_name(self.facade, self.store, "foo")
+        self._hash_packages_by_name(self.facade, self.store, "bar")
+        self._hash_packages_by_name(self.facade, self.store, "baz")
+        [foo] = self.facade.get_packages_by_name("foo")
+        [bar] = self.facade.get_packages_by_name("bar")
+        [baz] = self.facade.get_packages_by_name("baz")
+        self.store.add_task("changer", {"type": "change-package-holds",
+                                        "create": [foo.package.id,
+                                                   bar.package.id,
+                                                   baz.package.id],
+                                        "operation-id": 123})
+
+        def assert_result(result):
+            self.facade.reload_channels()
+            self.assertEqual([], self.facade.get_package_holds())
+            self.assertIn("Queuing message with change package holds results "
+                          "to exchange urgently.", self.logfile.getvalue())
+            self.assertMessages(
+                self.get_pending_messages(),
+                [{"type": "operation-result",
+                  "operation-id": 123,
+                  "status": FAILED,
+                  "result-text": "Package holds not changed, since the "
+                  "following packages are not installed: "
+                  "%s, %s" % tuple(sorted([bar.package.id,
+                                               baz.package.id])),
+                  "result-code": 1}])
+
+        result = self.changer.handle_tasks()
+        return result.addCallback(assert_result)
+
+    def test_change_package_holds_create_unknown_hash(self):
+        """
+        If the C{change-package-holds} message requests to add holds for
+        packages that the client doesn't know about, it's being treated
+        as the packages not being installed.
+        """
+        self.facade.reload_channels()
+        self.store.add_task("changer", {"type": "change-package-holds",
+                                        "create": [1],
+                                        "operation-id": 123})
+
+        def assert_result(result):
+            self.facade.reload_channels()
+            self.assertEqual([], self.facade.get_package_holds())
+            self.assertIn("Queuing message with change package holds results "
+                          "to exchange urgently.", self.logfile.getvalue())
+            self.assertMessages(
+                self.get_pending_messages(),
+                [{"type": "operation-result",
+                  "operation-id": 123,
+                  "status": FAILED,
+                  "result-text": "Package holds not changed, since the" +
+                                 " following packages are not installed: 1",
+                  "result-code": 1}])
+
+        result = self.changer.handle_tasks()
+        return result.addCallback(assert_result)
+
+    def test_change_package_holds_delete_not_held(self):
+        """
+        If the C{change-package-holds} message requests to remove holds
+        for packages that aren't held, the activity succeeds if the
+        right version is installed, since the end result is that the
+        hold is removed.
+        """
+        self._add_package_to_deb_dir(self.repository_dir, "foo")
+        self.facade.reload_channels()
+        self._hash_packages_by_name(self.facade, self.store, "foo")
+        [foo] = self.facade.get_packages_by_name("foo")
+        self.store.add_task("changer", {"type": "change-package-holds",
+                                        "delete": [foo.package.id],
+                                        "operation-id": 123})
+
+        def assert_result(result):
+            self.facade.reload_channels()
+            self.assertEqual([], self.facade.get_package_holds())
+            self.assertIn("Queuing message with change package holds results "
+                          "to exchange urgently.", self.logfile.getvalue())
+            self.assertMessages(
+                self.get_pending_messages(),
+                [{"type": "operation-result",
+                  "operation-id": 123,
+                  "status": SUCCEEDED,
+                  "result-text": "Package holds successfully changed.",
+                  "result-code": 0}])
+
+        result = self.changer.handle_tasks()
+        return result.addCallback(assert_result)
+
+    def test_change_package_holds_delete_different_version_held(self):
+        """
+        If the C{change-package-holds} message requests to remove holds
+        for packages that aren't held, the activity succeeds if the
+        right version is installed, since the end result is that the
+        hold is removed.
+        """
+        self._add_system_package("foo", version="1.0")
+        self._add_package_to_deb_dir(
+            self.repository_dir, "foo", version="2.0")
+        self.facade.reload_channels()
+        [foo1, foo2] = sorted(self.facade.get_packages_by_name("foo"))
+        self.facade.set_package_hold(foo1)
+        self.store.set_hash_ids({self.facade.get_package_hash(foo1): 1,
+                                 self.facade.get_package_hash(foo2): 2})
+        self.facade.reload_channels()
+        self.store.add_task("changer", {"type": "change-package-holds",
+                                        "delete": [2],
+                                        "operation-id": 123})
+
+        def assert_result(result):
+            self.facade.reload_channels()
+            self.assertEqual(["foo"], self.facade.get_package_holds())
+            self.assertIn("Queuing message with change package holds results "
+                          "to exchange urgently.", self.logfile.getvalue())
+            self.assertMessages(
+                self.get_pending_messages(),
+                [{"type": "operation-result",
+                  "operation-id": 123,
+                  "status": SUCCEEDED,
+                  "result-text": "Package holds successfully changed.",
+                  "result-code": 0}])
+
+        result = self.changer.handle_tasks()
+        return result.addCallback(assert_result)
+
+    def test_change_package_holds_delete_unknown_hash(self):
+        """
+        If the C{change-package-holds} message requests to remove holds
+        for packages that aren't known by the client, the activity
+        succeeds, since the end result is that the package isn't
+        held at that version.
+        """
+        self.store.add_task("changer", {"type": "change-package-holds",
+                                        "delete": [1],
+                                        "operation-id": 123})
+
+        def assert_result(result):
+            self.facade.reload_channels()
+            self.assertEqual([], self.facade.get_package_holds())
+            self.assertIn("Queuing message with change package holds results "
+                          "to exchange urgently.", self.logfile.getvalue())
+            self.assertMessages(
+                self.get_pending_messages(),
+                [{"type": "operation-result",
+                  "operation-id": 123,
+                  "status": SUCCEEDED,
+                  "result-text": "Package holds successfully changed.",
+                  "result-code": 0}])
+
+        result = self.changer.handle_tasks()
+        return result.addCallback(assert_result)
+
+    def test_change_package_holds_delete_not_installed(self):
+        """
+        If the C{change-package-holds} message requests to remove holds
+        for packages that aren't installed, the activity succeeds, since
+        the end result is still that the package isn't held at the
+        requested version.
+        """
+        self._add_system_package("foo")
+        self.facade.reload_channels()
+        self._hash_packages_by_name(self.facade, self.store, "foo")
+        [foo] = self.facade.get_packages_by_name("foo")
+        self.store.add_task("changer", {"type": "change-package-holds",
+                                        "delete": [foo.package.id],
+                                        "operation-id": 123})
+
+        def assert_result(result):
+            self.facade.reload_channels()
+            self.assertEqual([], self.facade.get_package_holds())
+            self.assertIn("Queuing message with change package holds results "
+                          "to exchange urgently.", self.logfile.getvalue())
+            self.assertMessages(
+                self.get_pending_messages(),
+                [{"type": "operation-result",
+                  "operation-id": 123,
+                  "status": SUCCEEDED,
+                  "result-text": "Package holds successfully changed.",
+                  "result-code": 0}])
+
+        result = self.changer.handle_tasks()
+        return result.addCallback(assert_result)
+
+    def test_change_package_locks(self):
+        """
+        If C{AptFacade} is used, the L{PackageChanger.handle_tasks}
+        method fails the activity, since it can't add or remove locks because
+        apt doesn't support this.
+        """
+        self.store.add_task("changer", {"type": "change-package-locks",
+                                        "create": [("foo", ">=", "1.0")],
+                                        "delete": [("bar", None, None)],
+                                        "operation-id": 123})
+
+        def assert_result(result):
+            self.assertMessages(
+                self.get_pending_messages(),
+                [{"type": "operation-result",
+                  "operation-id": 123,
+                  "status": FAILED,
+                  "result-text": "This client doesn't support package locks.",
+                  "result-code": 1}])
+
+        result = self.changer.handle_tasks()
+        return result.addCallback(assert_result)
+
+    def test_change_packages_with_binaries_removes_binaries(self):
+        """
+        After the C{change-packages} handler has installed the binaries,
+        the binaries and the internal facade deb source is removed.
+        """
+        self.store.add_task("changer",
+                            {"type": "change-packages", "install": [2],
+                             "binaries": [(HASH2, 2, PKGDEB2)],
+                             "operation-id": 123})
+
+        def return_good_result(self):
+            return "Yeah, I did whatever you've asked for!"
+        self.replace_perform_changes(return_good_result)
+
+        result = self.changer.handle_tasks()
+
+        def got_result(result):
+            self.assertMessages(self.get_pending_messages(),
+                                [{"operation-id": 123,
+                                  "result-code": 1,
+                                  "result-text": "Yeah, I did whatever you've "
+                                                 "asked for!",
+                                  "type": "change-packages-result"}])
+            self.assertEqual([], os.listdir(self.config.binaries_path))
+            self.assertFalse(
+                os.path.exists(self.facade._get_internal_sources_list()))
+
+        return result.addCallback(got_result)
+>>>>>>> MERGE-SOURCE
 
=== modified file 'landscape/package/tests/test_facade.py'
--- landscape/package/tests/test_facade.py	2012-06-19 15:12:07 +0000
+++ landscape/package/tests/test_facade.py	2014-11-19 18:22:39 +0000
@@ -1,19 +1,53 @@
 import os
-import textwrap
-import tempfile
-
-import apt_pkg
-from apt.package import Package
-from aptsources.sourceslist import SourcesList
-
-from landscape.constants import UBUNTU_PATH
-from landscape.lib.fs import read_file, create_file
+<<<<<<< TREE
+import textwrap
+import tempfile
+
+import apt_pkg
+from apt.package import Package
+from aptsources.sourceslist import SourcesList
+
+from landscape.constants import UBUNTU_PATH
+from landscape.lib.fs import read_file, create_file
+=======
+import re
+import sys
+import textwrap
+import tempfile
+
+try:
+    import smart
+    from smart.control import Control
+    from smart.cache import Provides
+    from smart.const import NEVER, ALWAYS
+except ImportError:
+    # Smart is optional if AptFacade is being used.
+    pass
+
+import apt_pkg
+from apt.package import Package
+from aptsources.sourceslist import SourcesList
+
+from twisted.internet import reactor
+from twisted.internet.defer import Deferred
+from twisted.internet.utils import getProcessOutputAndValue
+
+from landscape.constants import UBUNTU_PATH
+from landscape.lib.fs import read_file, create_file
+from landscape.package import facade as facade_module
+>>>>>>> MERGE-SOURCE
 from landscape.package.facade import (
+<<<<<<< TREE
     TransactionError, DependencyError, ChannelError, AptFacade)
+=======
+    TransactionError, DependencyError, ChannelError, SmartError, AptFacade,
+    has_new_enough_apt)
+>>>>>>> MERGE-SOURCE
 
 from landscape.tests.mocker import ANY
 from landscape.tests.helpers import LandscapeTest, EnvironSaverHelper
 from landscape.package.tests.helpers import (
+<<<<<<< TREE
     HASH1, HASH2, HASH3, PKGNAME1, PKGNAME2, PKGNAME3,
     PKGDEB1, PKGNAME_MINIMAL, PKGDEB_MINIMAL,
     create_deb, AptFacadeHelper,
@@ -622,42 +656,2524 @@
             ["amd64-package"],
             sorted(version.package.name
                    for version in self.facade.get_packages()))
-
-    def test_get_package_skeleton(self):
-        """
-        C{get_package_skeleton} returns a C{PackageSkeleton} for a
-        package. By default extra information is included, but it's
-        possible to specify that only basic information should be
-        included.
-
-        The information about the package are unicode strings.
-        """
-        deb_dir = self.makeDir()
-        create_simple_repository(deb_dir)
-        self.facade.add_channel_deb_dir(deb_dir)
-        self.facade.reload_channels()
-        [pkg1] = self.facade.get_packages_by_name("name1")
-        [pkg2] = self.facade.get_packages_by_name("name2")
-        skeleton1 = self.facade.get_package_skeleton(pkg1)
-        self.assertTrue(isinstance(skeleton1.summary, unicode))
-        self.assertEqual("Summary1", skeleton1.summary)
-        skeleton2 = self.facade.get_package_skeleton(pkg2, with_info=False)
-        self.assertIs(None, skeleton2.summary)
-        self.assertEqual(HASH1, skeleton1.get_hash())
-        self.assertEqual(HASH2, skeleton2.get_hash())
-
-    def test_get_package_hash(self):
-        """
-        C{get_package_hash} returns the hash for a given package.
-        """
-        deb_dir = self.makeDir()
-        create_simple_repository(deb_dir)
-        self.facade.add_channel_deb_dir(deb_dir)
-        self.facade.reload_channels()
-        [pkg] = self.facade.get_packages_by_name("name1")
-        self.assertEqual(HASH1, self.facade.get_package_hash(pkg))
-        [pkg] = self.facade.get_packages_by_name("name2")
-        self.assertEqual(HASH2, self.facade.get_package_hash(pkg))
+=======
+    SmartFacadeHelper, HASH1, HASH2, HASH3, PKGNAME1, PKGNAME2, PKGNAME3,
+    PKGNAME4, PKGDEB4, PKGDEB1, PKGNAME_MINIMAL, PKGDEB_MINIMAL,
+    create_full_repository, create_deb, AptFacadeHelper,
+    create_simple_repository)
+
+
+class FakeOwner(object):
+    """Fake Owner object that apt.progress.text.AcquireProgress expects."""
+
+    def __init__(self, filesize, error_text=""):
+        self.id = None
+        self.filesize = filesize
+        self.complete = False
+        self.status = None
+        self.STAT_DONE = object()
+        self.error_text = error_text
+
+
+class FakeFetchItem(object):
+    """Fake Item object that apt.progress.text.AcquireProgress expects."""
+
+    def __init__(self, owner, description):
+        self.owner = owner
+        self.description = description
+
+
+class AptFacadeTest(LandscapeTest):
+
+    if not has_new_enough_apt:
+        skip = "Can't use AptFacade on hardy"
+
+    helpers = [AptFacadeHelper, EnvironSaverHelper]
+
+    def version_sortkey(self, version):
+        """Return a key by which a Version object can be sorted."""
+        return (version.package, version)
+
+    def patch_cache_commit(self, commit_function=None):
+        """Patch the apt cache's commit function as to not call dpkg.
+
+        @param commit_function: A function accepting two parameters,
+            fetch_progress and install_progress.
+        """
+
+        def commit(fetch_progress, install_progress):
+            install_progress.dpkg_exited = True
+            if commit_function:
+                commit_function(fetch_progress, install_progress)
+
+        self.facade._cache.commit = commit
+
+    def test_default_root(self):
+        """
+        C{AptFacade} can be created by not providing a root directory,
+        which means that the currently configured root (most likely /)
+        will be used.
+        """
+        original_dpkg_root = apt_pkg.config.get("Dir")
+        facade = AptFacade()
+        self.assertEqual(original_dpkg_root, apt_pkg.config.get("Dir"))
+        # Make sure that at least reloading the channels work.
+        facade.reload_channels()
+
+    def test_custom_root_create_required_files(self):
+        """
+        If a custom root is passed to the constructor, the directory and
+        files that apt expects to be there will be created.
+        """
+        root = self.makeDir()
+        AptFacade(root=root)
+        self.assertTrue(os.path.exists(os.path.join(root, "etc", "apt")))
+        self.assertTrue(
+            os.path.exists(os.path.join(root, "etc", "apt", "sources.list.d")))
+        self.assertTrue(os.path.exists(
+            os.path.join(root, "var", "cache", "apt", "archives", "partial")))
+        self.assertTrue(os.path.exists(
+            os.path.join(root, "var", "lib", "apt", "lists", "partial")))
+        self.assertTrue(
+            os.path.exists(os.path.join(root, "var", "lib", "dpkg", "status")))
+
+    def test_no_system_packages(self):
+        """
+        If the dpkg status file is empty, not packages are reported by
+        C{get_packages()}.
+        """
+        self.facade.reload_channels()
+        self.assertEqual([], list(self.facade.get_packages()))
+
+    def test_get_packages_single_version(self):
+        """
+        If the dpkg status file contains some packages, those packages
+        are reported by C{get_packages()}.
+        """
+        self._add_system_package("foo")
+        self._add_system_package("bar")
+        self.facade.reload_channels()
+        self.assertEqual(
+            ["bar", "foo"],
+            sorted(version.package.name
+                   for version in self.facade.get_packages()))
+
+    def test_get_packages_multiple_version(self):
+        """
+        If there are multiple versions of a package, C{get_packages()}
+        returns one object per version.
+        """
+        deb_dir = self.makeDir()
+        self._add_system_package("foo", version="1.0")
+        self._add_package_to_deb_dir(deb_dir, "foo", version="1.5")
+        self.facade.add_channel_apt_deb("file://%s" % deb_dir, "./")
+        self.facade.reload_channels()
+        self.assertEqual(
+            [("foo", "1.0"), ("foo", "1.5")],
+            sorted((version.package.name, version.version)
+                   for version in self.facade.get_packages()))
+
+    def test_get_packages_multiple_architectures(self):
+        """
+        If there are multiple architectures for a package, only the native
+        architecture is reported by C{get_packages()}.
+        """
+        apt_pkg.config.clear("APT::Architectures")
+        apt_pkg.config.set("APT::Architecture", "amd64")
+        apt_pkg.config.set("APT::Architectures::", "amd64")
+        apt_pkg.config.set("APT::Architectures::", "i386")
+        facade = AptFacade(apt_pkg.config.get("Dir"))
+
+        self._add_system_package("foo", version="1.0", architecture="amd64")
+        self._add_system_package("bar", version="1.1", architecture="i386")
+        facade.reload_channels()
+        self.assertEqual([("foo", "1.0")],
+                         [(version.package.name, version.version)
+                          for version in facade.get_packages()])
+
+    def test_add_channel_apt_deb_without_components(self):
+        """
+        C{add_channel_apt_deb()} adds a new deb URL to a file in
+        sources.list.d.
+
+        If no components are given, nothing is written after the dist.
+        """
+        self.facade.add_channel_apt_deb("http://example.com/ubuntu", "lucid")
+        list_filename = (
+            self.apt_root +
+            "/etc/apt/sources.list.d/_landscape-internal-facade.list")
+        sources_contents = read_file(list_filename)
+        self.assertEqual(
+            "deb http://example.com/ubuntu lucid\n",
+            sources_contents)
+
+    def test_add_channel_apt_deb_no_duplicate(self):