def purple_handle_acct_connection(self, obj, proto): """This will handle account events coming from purple..""" evt = obj.evt log_info(evt) acct_id = evt.objid if evt.event in (yobotproto.YOBOT_EVENT_AUTH_FAIL, yobotproto.YOBOT_EVENT_LOGIN_ERR, yobotproto.YOBOT_EVENT_DISCONNECTED): #find account and trigger its errback: try: acct, _ = self.accounts.byId(acct_id) except TypeError: log_err("account does not exist (anymore)") return try: acct.timeoutCb.cancel() except Exception, e: log_warn(e) #relay the segment now because the client/account lookup will be #broken after the account has been deleted: self._relay_segment(obj, acct_id) try: if not evt.event == yobotproto.YOBOT_EVENT_DISCONNECTED: acct.connectedCb.errback(AccountRemoved("Login Failed")) else: acct.connectedCb.errback(AccountRemoved("Disconnected")) except defer.AlreadyCalledError, e: log_err(e)
def fill_from(self, account_dict): w = self.widgets w.username.setText(account_dict.get("name", "")) w.password.setText(account_dict.get("password", "")) #get protocol constant improto_constant = getattr(yobotproto, str(account_dict.get("improto"))) log_debug("improto_constant", improto_constant) #find it in the combobox i = w.improto.findData(QVariant(improto_constant)) if i >= 0: w.improto.setCurrentIndex(i) else: log_warn("couldn't find improto_constant", improto_constant) if account_dict.get("use_proxy", False) and account_dict.get("proxy_params", False): w.use_proxy.setChecked(True) pp = account_dict["proxy_params"] proxy_type_index = w.improto.findText(pp.get("proxy_type", "").upper()) if proxy_type_index >= 0: w.proxy_type.setCurrentIndex(proxy_type_index) w.proxy_address.setText(pp.get("proxy_address")) w.proxy_port.setText(pp.get("proxy_port")) w.proxy_username.setText(pp.get("proxy_username", "")) w.proxy_password.setText(pp.get("proxy_password", "")) else: w.use_proxy.setChecked(False)
def encode(self): if not self.user or not self.passw or not self.improto or not self.id: raise TypeError("missing parameters") info = yobot_mkacctinfo() info.user = self.user info.password = self.passw info.acctid = self.id info.improto = self.improto if self._proxy_host: proxy_info_xml = "<foo><proxy_info proxy_host='%s' " % (self._proxy_host) if self._proxy_port: proxy_info_xml += "proxy_port='%s' " % (str(self._proxy_port)) if self._proxy_username: proxy_info_xml += "proxy_username='******' " % (self._proxy_username) if self._proxy_password: proxy_info_xml += "proxy_password='******' " % (self._proxy_password) if self._proxy_type in ("socks4", "socks5", "http"): proxy_info_xml += "proxy_type='%d' " % ( getattr(yobotproto, "PURPLE_PROXY_" + self._proxy_type.upper())) else: log_warn("unknown proxy type", self._proxy_type) proxy_info_xml = "" if proxy_info_xml: proxy_info_xml += "/></foo>" info.attr_xml = proxy_info_xml log_debug(proxy_info_xml) else: log_debug("proxy info is null?") ptr = yobot_protoclient_mkacct_encode(info, None, YOBOT_PROTOCLIENT_TO_BUF) return ptr
def addAcct(self, acct): #add an account and request an ID.. if acct in self._all_accounts: log_warn( "request already completed or pending.. not adding") return self.pending_accounts.put(acct) self.yobot_server.sendCommand(yobotproto.YOBOT_CMD_ACCT_ID_REQUEST,0) log_debug( "send account connect command for account %s" % (acct, ))
def delConnection(self, connection, id=None, userproto=(None,None)): """Removes a connection from the account's data list""" #FIXME: accept iterables for id and userproto ((acct, st), lookup_table) = self._getacct(id, userproto) try: st.remove(connection) except KeyError, e: log_warn( e) return
def fn(cls, obj, proto): tbl = getattr(cls, tbl_name) #get required attribute: target = obj try: for attr in attrs.split("."): target = getattr(target, attr) except AttributeError, e: log_warn( e) return None
def callback(self, ret): if not self.svc: log_warn("service was not specified") return cmd = YobotCommand() cmd.acctid = self.evt.objid cmd.cmd = yobotproto.YOBOT_CMD_PURPLE_REQUEST_GENERIC_RESPONSE cmd.data = str(ret) cmd.reference = self.evt.reference self.svc.sendSegment(cmd) log_info("send response - %s" % (cmd.reference,))
def _addItem(self, item, key): if item in self: log_warn( "item exists") return self.beginAdd(len(self._t)) #log_debug("passing %d" % len(self._t)) l = list(self._t) l.append(item) self._t = tuple(l) item.index = len(l)-1 self._d[key] = item self.endAdd()
def __init__(self, account, txt, refid=0): if not txt: log_warn("no text") txt = "" log_debug(txt) self.refid = refid self._initvars() self.acct = account self.options.append(("Ok", lambda: None, yobotproto.YOBOT_ACTIONTYPE_OK)) self._prettyformat(txt)
def startup(args=sys.argv): import optparse options = optparse.OptionParser() options.add_option("-p", "--plugin", dest="selected_plugins", action="append", help="include this plugin") options.add_option("-U", "--username", dest="username", help="use this IM username") options.add_option("-P", "--password", dest="password", help="use this password") options.add_option("-I", "--improto", dest="improto", help="use this IM protocol [see documentation for a list]") options.add_option("-c", "--config-dir", dest="configdir", help="client configuration directory", default=yobot_interfaces.get_yobot_homedir()) options.add_option("--use-proxy", dest="use_proxy", action="store_true", help="use env proxy settings", default=False) options.add_option("--agent-address", dest="agent_addrinfo", help="agent server:port") options, args = options.parse_args(args) #set our configuration directory yobot_interfaces.component_registry.register_component("yobot-config-dir", options.configdir) if options.selected_plugins: #generate dict: name_object = {} for plugin in yobot_interfaces.component_registry.get_plugins(): name_object[plugin.plugin_name] = plugin for p in options.selected_plugins: plugin_object = name_object.get(p) if not plugin_object: log_warn("couldn't find plugin", p) continue yobot_interfaces.component_registry.activate_plugin(plugin_object) tmp = options.agent_addrinfo if tmp: tmp = tmp.rsplit(":", 1) address = tmp[0] if len(tmp) >= 2: port = int(tmp[1]) else: #no address specified on the command line address, port = None, None debuglog.init("Client", title_color="green") yobotproto.yobot_proto_setlogger("Client") ui = UIClient() ui.run(address, port)
def buddyEvent(self, obj, proto): #find account... log_info( "id: ", obj.evt.objid) acct = self.accounts.getAccount(obj.evt.objid) if not acct: log_warn( "Couldn't find account!") log_debug(acct) name, data = getNameAndData(obj) if name == "*": name = None if obj.evt.event == yobotproto.YOBOT_EVENT_BUDDY_GOT_ICON: acct.gotBuddyIcon(name, data) else: acct.gotBuddyStatus(name, obj.evt.event, data)
def unregisterClient(self, proto): """ Hook for connectionLost(). Removes the CID (if any) and its associated protocol instance from the table of clients """ log_debug( "UNREGISTERING: ", proto.cid) #first remove it from the accounts list: acct_refs = self.accounts.getConnectionData(proto) if acct_refs: acct_refs = acct_refs.copy() for acctid in acct_refs: self.accounts.delConnection(proto, id = acctid) #finally, remove the client.. need to find a better way for this try: self.accounts._connections.pop(proto) except KeyError, e: log_warn( e, "don't care")
def sendMsg(self): w = self.widgets if not w.input.toPlainText(): log_debug("empty input") return if self._send_html: txt = unicode(w.input.toHtml().toUtf8(), "utf-8") txt = simplify_css(txt.encode("utf-8")) else: txt = unicode(w.input.toPlainText().toUtf8(), "utf-8") if not txt: return log_warn(txt) w.input.clear() chat = True if self.type == CHAT else False self.account.sendmsg(self.target, str(txt), chat=chat)
def chatUserEvent(self, obj, proto): evt = obj.evt joined = False if evt.event == yobotproto.YOBOT_EVENT_ROOM_USER_LEFT else True room, user = evt.txt.split(yobotproto.YOBOT_TEXT_DELIM, 1) log_info("room:", room, "user:"******"couldn't find account") return if joined: self.uihooks.chatUserJoined(acct, room, user) else: self.uihooks.chatUserLeft(acct, room, user) log_info( obj.evt)
def load_settings(self): w = self.widgets if not self.config: log_warn("config object not available! bailing") return #for font.. appearance = self.config.globals.setdefault("appearance", {}) family = appearance.get("font_family", None) size = appearance.get("font_size", None) color = appearance.get("font_color", None) if family: self.font.setFamily(family) if size: self.font.setPointSize(size) if color: self.color.setNamedColor(color) bold = appearance.get("font_bold", False) italic = appearance.get("font_italic", False) underline = appearance.get("font_underline", False) html_relsize = appearance.get("use_html_relsize", False) show_joinpart = appearance.get("show_joinpart", False) self.font.setBold(bold) self.font.setItalic(italic) self.font.setUnderline(underline) w.html_relsize.setChecked(html_relsize) w.show_joinpart.setChecked(show_joinpart) self.change_formatting() #for the agent... agent = self.config.globals.get("agent_address", None) if agent: w.agent_address.setText(agent) self.change_agent() #for accounts: for a in self.config.accounts: log_warn("got account", a) if a.get("name", None) and a.get("improto", None): #get name and icon name, icon = getProtoIconAndName(getattr(yobotproto, a["improto"], "")) log_debug(icon, name) i = QTreeWidgetItem((a["name"], name)) i.setIcon(1, icon) i.setData(0, ITEM_PLACEHOLDER_ROLE, a) self.account_items[i] = a self.widgets.accounts.addTopLevelItem(i)
def getMsgs(self, account_name, protocol_name, other_user=None, timerange=None,type=None,count=50): """-> list of message, in order of time""" account_id_internal = self._get_account_id_internal(account_name, protocol_name) if not account_id_internal: return where_params = { "account_id_internal" : account_id_internal } if other_user: conv_id = self._getConvId(account_id_internal, other_user) if not conv_id: return where_params["conv_id"] = conv_id query_string = "SELECT timestamp, who, body, type, other_user FROM messages WHERE " value_l = [] ands = [] for k, v in where_params.items(): ands.append(k + "=? ") value_l.append(v) query_string += " AND ".join(ands) if timerange: start, end = timerange query_string += " AND timestamp BETWEEN ? AND ? " value_l += [int(start), int(end)] query_string += "ORDER BY timestamp " if count: query_string += "LIMIT ? " value_l.append(count) log_warn(query_string, value_l) del ands for res in self._cursor.execute(query_string, value_l): msg = YobotMessage() msg.time = int(res["timestamp"]) msg.name = res["other_user"] msg.who = res["who"] msg.txt = res["body"] type = res["type"] msg.yprotoflags |= yobotproto.YOBOT_MSG_TYPE_CHAT if type == CONV_TYPE_CHAT else yobotproto.YOBOT_MSG_TYPE_IM msg.prplmsgflags |= yobotproto.PURPLE_MESSAGE_SEND if msg.who == account_name else yobotproto.PURPLE_MESSAGE_RECV yield msg
def load_appearance_config(self): w = self.widgets if self.appearance_config: #navigate around.. this could be tricky c = self.appearance_config if c.get("font_family", None): f = QFont() f.setFamily(c["font_family"]) w.font.setCurrentFont(f) if c.get("font_size", None): log_warn("setting font size to ", c["font_size"]) w.fontsize.setValue(c["font_size"]) w.input.setFontPointSize(c["font_size"]) if c.get("font_color", None): self._choosecolor(set_color=QColor(c["font_color"])) if c.get("font_bold", False): w.bold.setChecked(True) if c.get("font_italic", False): w.italic.setChecked(True) if c.get("font_underline", False): w.underline.setChecked(True) if c.get("show_joinpart", False): w.actionShow_Join_Leave.setChecked(True) self.use_relsize = c.get("use_html_relsize", False)
def relayOfflines(self, obj, proto): acct, _ = self.accounts.byId(obj.cmd.acctid) if not acct: log_err("account is none") return if not acct.lastClientDisconnected: log_info("not relaying offlines while other clients are still connected") return for msg in self.logger.getMsgs(acct.name, yobotops.imprototostr(acct.improto), timerange = (acct.lastClientDisconnected, time.time()), count=0): msg.acctid = obj.cmd.acctid msg.yprotoflags |= (yobotproto.YOBOT_BACKLOG|yobotproto.YOBOT_OFFLINE_MSG) proto.sendSegment(msg) print msg self.logger.dump() log_warn("done") log_info(acct.lastClientDisconnected) acct.lastClientDisconnected = 0
def rm_account(self, cbresult): log_debug( "rm_account...") #tell the client we've timed out if self.timedOut: log_debug( "sending event..") self.proto.sendAccountEvent(yobotproto.YOBOT_EVENT_LOGIN_TIMEOUT, self.newacct.id,severity=yobotproto.YOBOT_WARN, txt="Yobot Server did not get a response from purple") log_debug( "Sent event") #tell purple to forget about our account log_debug( "telling purple to remove the account...") self.prpl.sendCommand(yobotproto.YOBOT_CMD_ACCT_REMOVE,self.newacct.id) log_debug( "done") try: log_debug( "deleting account from relay...") self.acct_mgr.delAcct(id=self.newacct.id) log_debug( "done") except Exception,e: log_warn( err)
def handle_request(self, obj, proto): """Mainly for buddy auth requests but can also possibly be used for other stuff""" evt = obj.evt acct = self.accounts.getAccount(obj.evt.objid) if evt.event == yobotproto.YOBOT_EVENT_USER_ADDREQ: req = BuddyAuthorize(self, evt.txt, acct) self.uihooks.gotRequest(req) elif evt.event == yobotproto.YOBOT_EVENT_PURPLE_REQUEST_GENERIC: req = YCRequest(self, obj.evt, acct) log_warn(req) self.uihooks.gotRequest(req) elif evt.event in (yobotproto.YOBOT_EVENT_PURPLE_NOTICE_GENERIC, yobotproto.YOBOT_EVENT_AGENT_NOTICE_GENERIC): #get the text.. req = SimpleNotice(acct, obj.evt.txt, obj.evt.reference) self.uihooks.gotRequest(req) elif evt.event == yobotproto.YOBOT_EVENT_PURPLE_REQUEST_GENERIC_CLOSED: log_debug("closed") #get request id.. refid = obj.evt.reference self.uihooks.delRequest(acct, refid)
def model_dump(self): return for a in self.backend: log_warn(a) for b in a.blist: log_warn("\t", b) log_err("now recursing") rows = self.rowCount() log_err("rows: ", rows) if rows > 0: for r in xrange(0, rows): acct_index = self.index(r) log_warn("Account", acct_index.internalPointer().name) c_rows = self.rowCount(acct_index) if c_rows > 0: for cr in xrange(0, c_rows): c_index = self.index(cr, 0, acct_index) log_warn("\tBuddy", c_index.internalPointer().name)
def unhandled(self, obj, proto): log_warn("UNHANDLED", obj) return NotImplemented
return try: if connection in acct.authenticated_clients and len(acct.authenticated_clients) == 1: #we're removing the last connection acct.lastClientDisconnected = time() acct.authenticated_clients.remove(connection) except KeyError: log_info("seems connection %s was not authenticated" % (str(connection),)) self._update_both(acct, st, lookup_table) try: self._connections[connection].remove(acct.id) except KeyError, e: log_warn( e) return def getConnectionData(self, connection): return self._connections.get(connection, None) def reserveId(self,bits): if bits > 31: return None for _ in range(1,10): tmp = random.getrandbits(bits) tmp = abs(tmp) if not self._ids.has_key(tmp): self._ids[tmp] = RESERVED_ID return tmp return None
def wrap(*args, **kwargs): log_warn("Function ", in_fn.func_name, "is not implemented.") in_fn(*args, **kwargs)
def _tabRemoved(index): if self.tabwidget.count() == 0: log_warn("last tab removed..") self.close()
sys.path.append("../") from debuglog import log_debug, log_err, log_warn, log_crit, log_info from gui_util import adjust_stylesheet_palette if __name__ == "__main__": import debuglog debuglog.init("Tabbed Windows", title_color="red") except ImportError, e: def log_generic(*args): print " ".join([str(a) for a in args]) log_debug = log_err = log_warn = log_crit = log_info = log_generic adjust_stylesheet_palette = lambda x: x log_err(e) import os if os.environ.get("USE_PYSIDE"): log_warn("Using PySide") from PySide.QtCore import * from PySide.QtGui import * else: from PyQt4.Qt import (QHBoxLayout, QTabBar, QWidget, QMainWindow, QFrame, QCursor, QVBoxLayout, QMenu, QPixmap, QApplication, QPoint, QPushButton, QSizePolicy, QTabWidget, QMenuBar, QLabel, QDrag, QTabBar, QAction, QPainter, QStyleOptionTab, QImage, QDesktopWidget, QRect) from PyQt4.QtCore import (QMimeData, QObject, SIGNAL, QPoint, Qt, QTimer, QSize, pyqtSignal) #make a few classes here
def connectToAgent(self, address=None, port=None, disconnect_from_server=True): try: self.disconnectAll(disconnect_from_server) except Exception, e: log_warn(e)
acct_refs = self.accounts.getConnectionData(proto) if acct_refs: acct_refs = acct_refs.copy() for acctid in acct_refs: self.accounts.delConnection(proto, id = acctid) #finally, remove the client.. need to find a better way for this try: self.accounts._connections.pop(proto) except KeyError, e: log_warn( e, "don't care") log_info( "Unregistered connection from all accounts") try: self.clients.pop(proto.cid) except KeyError, e: log_warn( e, "(don't care)") log_debug( "CURRENT CONNECTIONS: ", self.clients) log_debug( "Connections: ", self.accounts._connections, "Accounts ", self.accounts._ids) ######################### HANDLERS #################################### #event handlers for the YobotServer relay agent/bouncer def verifyObj(self, obj, proto): """Verify that the acct ID referenced in the incoming client message indeed belongs to the client""" acctid = 0 if obj.cmd: acctid = obj.cmd.acctid elif obj.evt: acctid = obj.evt.objid
def accountConnectionRemoved(self, acct): acct._logged_in = False self._plugin_hook_invoke("accountConnectionRemoved", (acct,)) log_warn( "ACCOUNT REMOVED!")