def on_change_peer(self, peer, service): """tries to connect to new peer""" if self.peers.remote_ids.has_key(peer.id_): self.peers.remote_ids[peer.id_].lose() else: log("on_change_peer. Unknow", peer.id_) self.on_new_peer(peer)
def on_select_filter(self, event): # wxGlade: FilterFrame.<event_handler> filter_names = get_selected_labels(self.filter_list) if filter_names: selected_filter = get_filter_facade().get_filter(filter_names[0]) if isinstance(selected_filter, PeerFilter): # update edit panel self.set_profile_view() self.edit_profile_panel.update(selected_filter) self.view_profile_panel.update(filter_names[0]) elif isinstance(selected_filter, FileFilter): # update edit panel self.set_file_view() self.edit_file_panel.update(selected_filter) self.view_file_panel.update(filter_names[0]) else: log("unrecognised filter", selected_filter.__class__.__name__) # get ids to display in notebook peer_ids = [] for filter_name in filter_names: try: for result_id, mathes in get_filter_facade().get_results(filter_name).items(): if result_id not in peer_ids and len(mathes) > 0: peer_ids.append(result_id) except KeyError: pass # update notebook for peer_id in peer_ids: self.set_tab(peer_id) for peer_id in self.tabs: if not peer_id in peer_ids: self.hide_tab(peer_id) event.Skip()
def clientConnectionFailed(self, connector, reason): """Called when a connection has failed to connect.""" if id(connector) in self.transports: peer = self.transports[id(connector)] peer.client._fail_client(connector.transport, reason) else: log("Connection failed. Unknown,:", reason)
def lineReceived(self, line): """incomming connection from other peer""" if line == "ping": self.sendLine("pong") else: log("lineReceived", line) message = Message.create_message(line) self.factory.network.peers.add_message(message)
def from_str(name, desc): try: description, activated = desc.split(', ') return FilterValue(name=name, value=description, activate= activated=="(1)" and True or False) except ValueError: log("could not read filter", desc)
def connect(self, peer): """connect to remote server""" log("Connecting", peer.ip, peer.port) connector = reactor.connectTCP(peer.ip, peer.port, self) self.transports[id(connector)] = peer return connector
def connectionLost(self, reason): """called when transfer complete""" remote_ip = self.transport.getPeer().host if self.factory.network.peers.assert_ip(remote_ip): log(_("%s disconnected" % remote_ip)) peer = self.factory.network.peers.remote_ips[remote_ip] peer.server.disconnected() else: log(_("%s already disconnected" % remote_ip))
def connectionMade(self): """a peer has connect to us""" remote_ip = self.transport.getPeer().host # check that ip has been suscribed (by high-level funciton 'on_new_peer') if not self.factory.network.peers.assert_ip(remote_ip): self.transport.loseConnection() else: log(_("%s has connected" % remote_ip)) peer = self.factory.network.peers.remote_ips[remote_ip] peer.server.connected(self)
def send_udp_message(self, peer_id, command, data=None): from solipsis.services.profile.plugin import Plugin message = Message(command) message.ip = self.public_ip message.port = self.public_port message.data = data if Plugin.service_api: log("sending udp", message) Plugin.service_api.SendData(peer_id, str(message))
def force_unicode(chars): """return unicode string trying different encodings if locale one failed""" if isinstance(chars, unicode): return chars for encoding in KNOWN_ENCODINGS: try: return unicode(chars, encoding) except UnicodeDecodeError: log(encoding, "does not apply on", chars)
def connectionMade(self): """a peer has connected to us""" remote_ip = self.transport.getPeer().host # check that ip has been suscribed (by high-level funciton 'on_new_peer') if not self.factory.network.peers.assert_ip(remote_ip): self.transport.loseConnection() else: log("connected to", remote_ip) self.setRawMode() peer = self.factory.network.peers.remote_ips[remote_ip] self.peer_client = peer.client self.peer_client._on_connected(self.transport)
def ChangedNode(self, node): """need to update node_id""" # ChangedNode is call more than one time on change. Thus, be # careful not to do the job every time log("ChangedNode", node.pseudo) if get_facade() is None or get_facade()._desc.document.get_pseudo() != node.pseudo: # creation facade = create_facade(node.id_) filter_facade = create_filter_facade(node.id_) if not facade.load(): log( _(u"You have no profile yet for pseudo %s."% node.pseudo)) if not filter_facade.load(): log( _(u"You have no filters defined yet for pseudo %s."% node.pseudo)) facade.change_pseudo(node.pseudo) # updating views if self.editor_frame: facade.add_view(EditorView(facade._desc, self.editor_frame)) self.editor_frame.on_change_facade() facade.add_view(ViewerView(facade._desc, self.viewer_frame)) self.viewer_frame.on_change_facade() if self.filter_frame: filter_facade.add_view(FilterView(filter_facade._desc, self.filter_frame)) self.filter_frame.on_change_facade() log(_("Loaded data for %s"% node.pseudo))
def _on_complete_pickle(self, donwload_msg): """callback when finished downloading blog""" log("_on_complete_pickle: ", self.peer.peer_id) try: return pickle.load(donwload_msg.file) except Exception, err: display_error( _( "Your version of Solipsis is not compatible " "with the peer'sone you wish to download from " "Make sure you both use the latest (%s)" % VERSION ), title="Download error", error=err, )
def load_blogs(path): """use pickle to load blogs. file name given without extension (same model as profile""" # loading if os.path.exists(path): try: blog_file = open(path, "rb") blogs = pickle.load(blog_file) blog_file.close() except: log(_("Could not read blog file. Using a blank one.")) return Blogs() return retro_compatibility(blogs) else: return Blogs()
def execute(self, message): log("*exec*: ", message, self.peer_server.peer.peer_id) transport = self.peer_server.protocol.transport def on_failure(reason, transfert): log("transfert of %s failed: %s" % (transfert, str(reason))) transport.loseConnection() def on_success(result, transfert): log("transfert of %s complete" % transfert) transport.loseConnection() if message.command in [MESSAGE_HELLO, MESSAGE_PROFILE]: file_obj = get_facade()._desc.document.to_stream() deferred = basic.FileSender().beginFileTransfer(file_obj, transport) deferred.addCallback(on_success, "profile") deferred.addErrback(on_failure, "profile") elif message.command == MESSAGE_BLOG: blog_stream = get_facade().get_blog_file() deferred = basic.FileSender().beginFileTransfer(blog_stream, transport) deferred.addCallback(on_success, "blog") deferred.addErrback(on_failure, "blog") elif message.command == MESSAGE_SHARED: files_stream = get_facade().get_shared_files() deferred = basic.FileSender().beginFileTransfer(files_stream, transport) deferred.addCallback(on_success, "shared files") deferred.addErrback(on_failure, "shared files") elif message.command == MESSAGE_FILES: split_path, file_size = extract_data_file(message.data) file_name = os.sep.join(split_path) try: file_desc = get_facade().get_file_container(file_name) # check shared if file_desc._shared: display_status("sending %s" % file_name) deferred = basic.FileSender().beginFileTransfer(open(file_name, "rb"), transport) deferred.addCallback(on_success, file_name) deferred.addErrback(on_failure, file_name) else: self.peer_server.protocol.factory.send_udp_message( self.peer_server.peer.peer_id, MESSAGE_ERROR, message.data ) SecurityAlert(self.peer_server.peer.peer_id, "Trying to download unshare file %s" % file_name) except ContainerException: SecurityAlert(self.peer_server.peer.peer_id, "Trying to download unvalid file %s" % file_name) else: SecurityAlert(self.peer_server.peer.peer_id, "ERROR in _connect: %s not valid" % message.command)
def _on_complete_file(self, donwload_msg): """callback when finished downloading file""" log("_on_complete_file: ", self.peer.peer_id) # write downloaded file split_path = extract_data_file(donwload_msg.message.data)[0] download_path = os.path.join(get_prefs("download_repo"), split_path[-1]) download_file = open(download_path, "wb") download_file.write(donwload_msg.file.read()) download_file.close() # download next if self.files: split_path, size = self.files.pop() self.update_file(split_path[-1], size) self._connect(MESSAGE_FILES, format_data_file(split_path, size)) else: self.complete_all_files()
def on_service_data(self, peer_id, message): """demand to establish connection from peer that failed to connect through TCP""" if not self.peers.remote_ids.has_key(peer_id): log("on_service_data. Unknow", peer_id, message) self.peers.add_peer(peer_id) else: log("on_service_data", peer_id, message) try: message = Message.create_message(message) if message.command != MESSAGE_HELLO: SecurityAlert(peer_id, "unvalid message '%s' from %s"\ % (str(message), peer_id)) else: self.peers.set_peer(peer_id, message) except ValueError, err: SecurityAlert(peer_id, str(err))
def _try_change(self, setter, updater, *args, **kwargs): """Calls the setting function on a document (wich can be passed in **kwargs with the key 'document'), and calls the getting function on all views linked to the facade. returns value returned by setter""" if not "document" in kwargs: document = self._desc.document else: document = kwargs["document"] try: result = getattr(document, setter)(*args) for view in self.views.values(): getattr(view, updater)() return result except TypeError, error: log(error) raise
def load_personals(self): try: self.pseudo = unicode(self.config.get(SECTION_PERSONAL, "pseudo"), self.encoding) self.title = unicode(self.config.get(SECTION_PERSONAL, "title"), self.encoding) self.firstname = unicode(self.config.get(SECTION_PERSONAL, "firstname"), self.encoding) self.lastname = unicode(self.config.get(SECTION_PERSONAL, "lastname"), self.encoding) self.photo = unicode(self.config.get(SECTION_PERSONAL, "photo"), self.encoding) self.email = unicode(self.config.get(SECTION_PERSONAL, "email"), self.encoding) except (ConfigParser.NoSectionError, ConfigParser.NoOptionError): log("could not read details")
def run(self): while True: try: # block until new message or TIMEOUT message = self.queue.get(timeout=self.CHECKING_FREQUENCY) if message is None: break else: if message.ip in self.remote_ips: log("new message", message) self.remote_ips[message.ip].server.execute(message) else: SecurityAlert(message.ip, _("Message '%s' out of date." % str(message))) self._check_peers(datetime.datetime.now()) except Empty: # Empty exception is expected when no message received # during period defined by CHECKING_FREQUENCY. self._check_peers(datetime.datetime.now()) log("stopping server")
def update(self, filter_name): self.reset() try: results = get_filter_facade().get_results(filter_name) for peer_id, matches in results.items(): # add peer if matches if matches: if not peer_id in self.items: child = self.matching_list.AppendItem(self.root, peer_id) self.matching_list.SetItemImage(child, self.fldridx, which=wx.TreeItemIcon_Normal) self.matching_list.SetItemImage(child, self.fldropenidx, which=wx.TreeItemIcon_Expanded) self.items[peer_id] = child else: child = self.items[peer_id] # add matches for matche in matches: match_item = self.matching_list.AppendItem(child, matche.get_name()) self.matching_list.SetItemImage(match_item, self.fileidx, which=wx.TreeItemIcon_Normal) self.matching_list.SetItemText(match_item, matche.match, 1) self.matching_list.Expand(self.root) except KeyError: log("no match for", filter_name)
def _connect(self, command, data=None): log("connect: ", command, self.peer.peer_id) # set download information message = self.peer.wrap_message(command, data) connector = self.connect(self.peer) deferred = defer.Deferred() download = DownloadMessage(connector.transport, deferred, message) self[connector.transport] = download # set callback if command == MESSAGE_HELLO: deferred.addCallback(self._on_hello) elif command == MESSAGE_PROFILE: deferred.addCallback(self._on_complete_profile) elif command == MESSAGE_BLOG: deferred.addCallback(self._on_complete_pickle) elif command == MESSAGE_SHARED: deferred.addCallback(self._on_complete_pickle) elif command == MESSAGE_FILES: deferred.addCallback(self._on_complete_file) deferred.addErrback(lambda x: display_status("Could not get file %s: %s" % (data, str(x)))) else: raise ValueError("ERROR in _connect: %s not valid" % command) return deferred
def get_files(self): """returns {root: Container}""" # lazy initialisation if self.files != {}: return FileSharingMixin.get_files(self) # full init for repo in self.init_repos(): try: self.files[repo] = create_container(repo, checked=False) except AssertionError: display_status("non valid repo '%s'"% repo) # if no valid repo found, does not try any further... if self.files == {}: return self.files for option in self.config.options(SECTION_FILE): # get share & tag try: o_description = self.config.get(SECTION_FILE, option) o_file, o_share, o_size, o_tag = o_description.split(',', 3) o_file = (o_file == 'F') and True or False o_share = (o_share == SHARED_TAG) o_tag = force_unicode(o_tag) o_size = int(o_size) except (ValueError, ConfigParser.NoSectionError, ConfigParser.NoOptionError), err: log("option '%s' not well formated: %s"% (o_description, err)) o_file, o_share, o_tag, o_size = False, False, DEFAULT_TAG, 0 # add container try: file_container = o_file and self.get_file(option) \ or self.get_container(option) file_container.share(o_share) file_container.tag(o_tag) file_container.size = o_size except KeyError: log("non valid file '%s'"% option)
def get_peers(self): """returns Peers""" # lazy initialisation if self.peers != {}: return ContactsMixin.get_peers(self) # full init if not self.config.has_section(SECTION_OTHERS): self.config.add_section(SECTION_OTHERS) options = self.config.options(SECTION_OTHERS) for peer_id in options: # check unicode if isinstance(peer_id, str): peer_id = unicode(peer_id, self.encoding) # get info description = self.config.get(SECTION_OTHERS, peer_id) try: pseudo, state, timestamp = description.split(',') peer_desc = PeerDescriptor(peer_id, state=state) ContactsMixin.set_peer(self, peer_id, peer_desc) peer_desc.load() # TODO: use timestamp except Exception, error: log(error, ": peer %s not retreived"% description)
def on_activate(self, evt): """activate service""" activate = self.activate_item.IsChecked() log(activate and "Activating..." \ or "Disactivated") get_facade()._activated = activate
def load(self, doc_extension, directory=None): """load .profile.solipsis""" try: self._desc.load(directory=directory, doc_extension=doc_extension) except ValueError, err: log(err, ": Using blank one")
def send_message(self): log("sending", self.message) self.transport.write(str(self.message)+"\r\n")
def lineReceived(self, line): log(_("Unexpected line received: %s"% line))
def teardown_download(self): log("download complete. received", self.size) self.file.seek(0) self.deferred.callback(self)
def on_lost_peer(self, peer_id): """tries to connect to new peer""" if self.peers.remote_ids.has_key(peer_id): self.peers.remote_ids[peer_id].lose() else: log("on_lost_peer. Unknow", peer_id)