← Back to branch summary

~aaronp/software-center/tests

« back to all changes in this revision

Viewing changes to softwarecenter/backend/aptd.py

  • Committer: Aaron Peachey
  • Date: 2011-06-20 09:50:42 UTC
  • mfrom: (1805.10.18 software-center)
  • Revision ID: alpeachey@gmail.com-20110620095042-a5s30o4vtx9l9fgr
merge from trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
softwarecenter/backend/aptd.py
40
40
from defer import inline_callbacks, return_value
41
41
 
42
42
import gtk
43
 
from softwarecenter.backend.transactionswatcher import TransactionsWatcher
 
43
from softwarecenter.backend.transactionswatcher import BaseTransactionsWatcher, BaseTransaction
44
44
from softwarecenter.backend.installbackend import InstallBackend
45
45
from softwarecenter.utils import get_http_proxy_string_from_gconf
46
46
from softwarecenter.ui.gtk import dialogs
74
74
        self.meta_data = trans.meta_data
75
75
        self.progress = trans.progress
76
76
 
77
 
class AptdaemonBackend(gobject.GObject, TransactionsWatcher, InstallBackend):
 
77
class AptdaemonTransaction(BaseTransaction):
 
78
    def __init__(self, trans):
 
79
        self._trans = trans
 
80
 
 
81
    @property
 
82
    def tid(self):
 
83
        return self._trans.tid
 
84
 
 
85
    @property
 
86
    def status_details(self):
 
87
        return self._trans.status_details
 
88
 
 
89
    @property
 
90
    def meta_data(self):
 
91
        return self._trans.meta_data
 
92
 
 
93
    @property
 
94
    def cancellable(self):
 
95
        return self._trans.cancellable
 
96
 
 
97
    @property
 
98
    def progress(self):
 
99
        return self._trans.progress
 
100
 
 
101
    def get_role_description(self, role=None):
 
102
        role = self._trans.role if role is None else role
 
103
        return enums.get_role_localised_present_from_enum(role)
 
104
 
 
105
    def get_status_description(self, status=None):
 
106
        status = self._trans.status if status is None else status
 
107
        return enums.get_status_string_from_enum(status)
 
108
 
 
109
    def is_waiting(self):
 
110
        return self._trans.status == enums.STATUS_WAITING_LOCK
 
111
 
 
112
    def is_downloading(self):
 
113
        return self._trans.status == enums.STATUS_DOWNLOADING
 
114
 
 
115
    def cancel(self):
 
116
        return self._trans.cancel()
 
117
 
 
118
    def connect(self, signal, handler, *args):
 
119
        """ append the real handler to the arguments """
 
120
        args = args + (handler, )
 
121
        return self._trans.connect(signal, self._handler, *args)
 
122
 
 
123
    def _handler(self, trans, *args):
 
124
        """ translate trans to BaseTransaction type.
 
125
        call the real handler after that
 
126
        """
 
127
        real_handler = args[-1]
 
128
        args = tuple(args[:-1])
 
129
        if isinstance(trans, client.AptTransaction):
 
130
            trans = AptdaemonTransaction(trans)
 
131
        return real_handler(trans, *args)
 
132
 
 
133
class AptdaemonTransactionsWatcher(BaseTransactionsWatcher):
 
134
    """ 
 
135
    base class for objects that need to watch the aptdaemon 
 
136
    for transaction changes. it registers a handler for the daemon
 
137
    going away and reconnects when it appears again
 
138
    """
 
139
 
 
140
    def __init__(self):
 
141
        super(AptdaemonTransactionsWatcher, self).__init__()
 
142
        # watch the daemon exit and (re)register the signal
 
143
        bus = dbus.SystemBus()
 
144
        self._owner_watcher = bus.watch_name_owner(
 
145
            "org.debian.apt", self._register_active_transactions_watch)
 
146
 
 
147
    def _register_active_transactions_watch(self, connection):
 
148
        #print "_register_active_transactions_watch", connection
 
149
        apt_daemon = client.get_aptdaemon()
 
150
        apt_daemon.connect_to_signal("ActiveTransactionsChanged", 
 
151
                                     self._on_transactions_changed)
 
152
        current, queued = apt_daemon.GetActiveTransactions()
 
153
        self._on_transactions_changed(current, queued)
 
154
 
 
155
    def _on_transactions_changed(self, current, queued):
 
156
        self.emit("lowlevel-transactions-changed", current, queued)
 
157
 
 
158
    def get_transaction(self, tid):
 
159
        """ synchroneously return a transaction """
 
160
        trans = client.get_transaction(tid)
 
161
        return AptdaemonTransaction(trans)
 
162
 
 
163
class AptdaemonBackend(gobject.GObject, InstallBackend):
78
164
    """ software center specific code that interacts with aptdaemon """
79
165
 
80
166
    __gsignals__ = {'transaction-started':(gobject.SIGNAL_RUN_FIRST,
105
191
 
106
192
    def __init__(self):
107
193
        gobject.GObject.__init__(self)
108
 
        TransactionsWatcher.__init__(self)
 
194
        
109
195
        self.aptd_client = client.AptClient()
110
196
        self.pending_transactions = {}
 
197
        self._transactions_watcher = AptdaemonTransactionsWatcher()
 
198
        self._transactions_watcher.connect("lowlevel-transactions-changed",
 
199
                                           self._on_lowlevel_transactions_changed)
111
200
        # dict of pkgname -> FakePurchaseTransaction
112
201
        self.pending_purchases = {}
113
202
        self._progress_signal = None
521
610
                                     app, trans.meta_data, sourcepart)
522
611
 
523
612
    # internal helpers
524
 
    def on_transactions_changed(self, current, pending):
 
613
    def _on_lowlevel_transactions_changed(self, watcher, current, pending):
525
614
        # cleanup progress signal (to be sure to not leave dbus matchers around)
526
615
        if self._progress_signal:
527
616
            gobject.source_remove(self._progress_signal)