def update_file(self, file_name, size): """available to wx navigators only. update downloaded file in specific dialog""" if self.download_dlg: self.download_dlg.update_file(file_name, size) else: display_status("downloading %s (%d)" % (file_name, size))
def complete_all_files(self): self.files_deferred.callback("callback complete all") if self.download_dlg: self.download_dlg.complete_all_files() self.download_dlg = None else: display_status("All files downloaded")
def retro_compatibility(blogs): """make sure that downloaded version is the good one""" if blogs.version == "0.4.0": return blogs else: display_status(_("Could not read blog file. Using a blank one.")) return Blogs()
def display(self, key): if key in self: nb_tries = self.count(key) if nb_tries > 1: display_status(_("%d failures on '%s'. Last: %s"\ % (nb_tries, key, self[key][-1]))) elif nb_tries == 1: display_status(_("ERR on '%s': %s"\ % (key, self[key][0])))
def _set_repositories(self): """update list of repos""" repos_list = self.get_repositories() if repos_list == None: display_status("No repo to set.") return if not self.config.has_section(SECTION_PERSONAL): self.config.add_section(SECTION_PERSONAL) self.config.set(SECTION_PERSONAL, "repositories", ",".join(repos_list))
def load(self, path): if not os.path.exists(path): display_status(_("profile %s does not exists"\ % os.path.basename(path))) return False else: profile_file = open(path) self.encoding = load_encoding(profile_file) self.config = CustomConfigParser(self.encoding) self.config.readfp(profile_file) profile_file.close() return True
def load_encoding(file_obj): """load from profile document its encoding""" encoding_tag = file_obj.readline() if not encoding_tag.startswith("# profile-encoding::"): # wrong format # first line has been wastes: rewind file_obj.seek(0) # return default display_status(_("could not read encoding from profile file. " "Using %s"% ENCODING)) return ENCODING else: encoding = encoding_tag.split("::")[-1].strip() display_status(_("Profile read with encoding %s"% encoding)) return encoding
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 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 _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 _fail_client(self, transport, reason): try: display_status("Action [%s] failed: %s" % (str(self[transport].message), reason)) except SecurityAlert: display_status("Action failed: %s" % reason)
def _stun_succeed(address): """Discovery succeeded""" self.public_ip, self.public_port = address display_status(_("STUN discovery found address %s:%d" % (self.public_ip, self.public_port))) self.listener = reactor.listenTCP(self.local_port, self) return True