Esempio n. 1
0
    def __init__(self, client, jid):
        log.debug("Initializing channel %s", jid)

        # Avoid invalid channel names
        user, domain = jid.split("@", 1)
        if len(user) == 0 or len(domain) == 0:
            raise InvalidChannelName(jid)

        self.client = client
        self.jid = jid

        # All the channels items, newest first (as returned by the server)
        self.atoms = UpdatableAtomsList()
        self.atoms_lock = threading.RLock()
        self.load_event = threading.Event()
        self.loading = False
        self.oldest_id = None

        # Callbacks
        self.callback_config  = None
        self.callback_post    = None
        self.callback_retract = None
        self.callback_status  = None
Esempio n. 2
0
class Channel:
    """A buddycloud channel, tied to a client"""

    # {{{ Channel init
    CONFIG_MAP = (
        ("title",       "pubsub#title"),
        ("description", "pubsub#description"),
        ("creation",    "pubsub#creation_date"),
        ("type",        "buddycloud#channel_type")
    )

    def __init__(self, client, jid):
        log.debug("Initializing channel %s", jid)

        # Avoid invalid channel names
        user, domain = jid.split("@", 1)
        if len(user) == 0 or len(domain) == 0:
            raise InvalidChannelName(jid)

        self.client = client
        self.jid = jid

        # All the channels items, newest first (as returned by the server)
        self.atoms = UpdatableAtomsList()
        self.atoms_lock = threading.RLock()
        self.load_event = threading.Event()
        self.loading = False
        self.oldest_id = None

        # Callbacks
        self.callback_config  = None
        self.callback_post    = None
        self.callback_retract = None
        self.callback_status  = None

    def __iter__(self):
        return iter(self.atoms)

    def __repr__(self):
        return "<bccc.client.Channel {}>".format(self.jid)

    def set_callbacks(self, cb_config=None, cb_post=None, cb_retract=None, cb_status=None):
        if cb_config is not None:
            self.callback_config = cb_config
        if cb_post is not None:
            self.callback_post = cb_post
        if cb_retract is not None:
            self.callback_retract = cb_retract
        if cb_status is not None:
            self.callback_status = cb_status
    # }}}
    # {{{ Subscriptions/affiliations
    def get_subscriptions(self):
        channels = []
        subnode = "/user/" + self.jid + "/subscriptions"
        items = self.client.ps.get_items(self.client.inbox_jid, subnode, block=True)
        for item in items["pubsub"]["items"]:
            try:
                chan = self.client.get_channel(item["id"])
                channels.append(chan)
            except ChannelError:
                pass
        return channels
    # }}}
    # {{{ PubSub event handlers
    def handle_post_event(self, entries):
        # Incoming entries: add them and trigger the callback
        if len(entries) == 0:
            return
        atoms = []
        for elt in entries:
            a = self.atoms.add(elt)
            if a is not None:
                atoms.append(a)
        if len(atoms) > 0 and self.callback_post is not None:
            self.callback_post(atoms)

    def handle_retract_event(self, entries):
        if len(entries) == 0:
            return
        # Remove retracted items from self.atoms
        with self.atoms_lock:
            for id_ in entries:
                self.atoms.remove(id_)
        if self.callback_retract is not None:
            self.callback_retract(entries)

    def handle_status_event(self, entries):
        if len(entries) == 0:
            return
        elt = entries[0]
        if elt is not None:
            a = Atom(elt)
            if self.callback_status is not None:
                self.callback_status(a)

    def handle_config_event(self, config_events):
        for conf in config_events:
            # Convert conf to a dict
            val = conf["form"]["values"]
            config = {}
            for (dk, ik) in self.CONFIG_MAP:
                if ik in val:
                    config[dk] = val[ik].strip()
            if "creation" in config:
                config["creation"] = dateutil.parser.parse(config["creation"])

            if self.callback_config is not None:
                self.callback_config(config)
    # }}}
    # {{{ Internal helpers
    def _items_to_atoms(self, items, callback=None):
        atoms = []
        with self.atoms_lock:
            for item in items["pubsub"]["items"]:
                elt = item.get_payload()
                a = self.atoms.add(elt)
                if a is not None:
                    atoms.append(a)
        if len(atoms) > 0 and callback is not None:
            callback(atoms)
        return atoms
    # }}}
    # {{{ PubSub requests
    def pubsub_get_items(self, node, callback, max=None, before=None, after=None):
        """
        Request the contents of a node's items.

        This is based on sleekxmpp.plugins.xep_0060.pubsub.xep_0060.get_items(),
        but uses XEP-0059 instead of the "max_items" attribute (cf.
        XEP-0060:6.5.7).
        """
        iq = self.client.ps.xmpp.Iq(sto=self.client.inbox_jid, stype="get")
        iq["pubsub"]["items"]["node"] = node
        if max is not None:
            iq["pubsub"]["rsm"]["max"] = str(max)
        if before is not None:
            iq["pubsub"]["rsm"]["before"] = before
        if after is not None:
            iq["pubsub"]["rsm"]["after"] = after

        iq.send(callback=callback)

    def pubsub_get_post(self, item_id):
        node = "/user/{}/posts".format(self.jid)
        cb = lambda items: self._items_to_atoms(items, self.callback_post)
        self.client.ps.get_item(self.client.inbox_jid, node, item_id, block=False, callback=cb)

    def pubsub_get_posts(self, max=None, before=None, after=None):
        node = "/user/{}/posts".format(self.jid)
        cb = lambda items: self._items_to_atoms(items, self.callback_post)
        return self.pubsub_get_items(node, cb, max, before, after)

    def pubsub_get_status(self):
        def _status_cb(items):
            entries = [item.get_payload() for item in items["pubsub"]["items"]]
            while None in entries:
                entries.remove(None)
            if len(entries) > 0:
                self.handle_status_event(entries)

        node = "/user/{}/status".format(self.jid)
        self.pubsub_get_items(node, callback=_status_cb, max=1)

    def pubsub_get_config(self):
        def _config_cb(iq):
            conf = iq["pubsub_owner"]["configure"]
            self.handle_config_event([conf])

        node = "/user/{}/posts".format(self.jid)
        self.client.ps.get_node_config(self.client.inbox_jid, node, callback=_config_cb)
    # }}}
    # {{{ Thread loading
    def get_partial_thread(self, first_id, last_id):
        # Hard to read. Sorry.
        node = "/user/{}/posts".format(self.jid)

        # Callback for items after first_id. Requests more items until last_id is found.
        def _other_posts_cb(atoms):
            if self.callback_post is not None:
                self.callback_post(atoms)
            ids = [a.id for a in atoms]
            if last_id not in ids:
                # Request next
                self.pubsub_get_items(node, cb2, max=20, before=ids[0])

        # Callback for first item. If found, will request the next ones.
        def _first_post_cb(atoms):
            if self.callback_post is not None:
                self.callback_post(atoms)
            ids = [a.id for a in atoms]
            if first_id in ids:
                self.pubsub_get_items(node, cb2, max=20, before=first_id)

        cb1 = lambda items: self._items_to_atoms(items, _first_post_cb)
        cb2 = lambda items: self._items_to_atoms(items, _other_posts_cb)

        # Request first item
        self.client.ps.get_item(self.client.inbox_jid, node, first_id, block=False, callback=cb1)
    # }}}
    # {{{ Items publishing
    def _make_atom(self, text, author_name=None, id_=None, in_reply_to=None, update_time=None):
        # Build something that looks like an Atom and return it
        entry = ET.Element("entry", xmlns=ATOM_NS)

        if author_name is None:
            author_name = self.client.boundjid.bare
        if update_time is None:
            update_time = datetime.datetime.utcnow().isoformat()

        content = ET.SubElement(entry, "content")
        author  = ET.SubElement(entry, "author")
        name    = ET.SubElement(author, "name")
        updated = ET.SubElement(entry, "updated")

        content.text = text
        name.text = author_name
        updated.text = update_time

        if id_ is not None:
            # Probably not necessary: added by the server.
            id_el = ET.SubElement(entry, "id")
            id_el.text = id_
        if in_reply_to is not None:
            irt = ET.SubElement(entry, "{{{}}}in-reply-to".format(ATOM_THR_NS), ref=in_reply_to)

        return entry

    def publish(self, text, author_name=None, id_=None, in_reply_to=None):
        log.debug("Publishing to channel %s...", self.jid)
        entry = self._make_atom(text, author_name=author_name, id_=id_, in_reply_to=in_reply_to)
        node = "/user/{}/posts".format(self.jid)
        res = self.client.ps.publish(self.client.inbox_jid, node, payload=entry, id=id_)
        new_id = res["pubsub"]["publish"]["item"]["id"]
        log.info("Published to channel %s with id %s", self.jid, new_id)
        return new_id

    def retract(self, id_):
        log.debug("Retracting %s from channel %s", id_, self.jid)
        node = "/user/{}/posts".format(self.jid)
        self.client.ps.retract(self.client.inbox_jid, node, id_, notify=True)

    def set_status(self, text, author_name=None):
        log.debug("Setting status for channel %s...", self.jid)
        entry = self._make_atom(text, author_name=author_name)
        node = "/user/{}/status".format(self.jid)
        res = self.client.ps.publish(self.client.inbox_jid, node, payload=entry)
        id_ = res["pubsub"]["publish"]["item"]["id"]
        log.info("Status set for channel %s with id %s", self.jid, id_)
        return id_

    def update_config(self, **kwds):
        # Create config form
        form = self.client.data_forms.make_form(ftype="submit")
        form.add_field(var="FORM_TYPE", ftype="hidden", value="http://jabber.org/protocol/pubsub#node_config")
        for (dk, ik) in self.CONFIG_MAP:
            if dk in kwds:
                form.add_field(var=ik, value=kwds[dk])

        log.info("Updating config for channel %s", self.jid)
        node = "/user/{}/posts".format(self.jid)
        self.client.ps.set_node_config(self.client.inbox_jid, node, form)