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
