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)
