libervia-web: libervia/server/server.py comparison

comparison libervia/server/server.py @ 1216:b2d067339de3

python 3 port: /!\ Python 3.6+ is now needed to use libervia /!\ instability may occur and features may not be working anymore, this will improve with time /!\ TxJSONRPC dependency has been removed The same procedure as in backend has been applied (check backend commit ab2696e34d29 logs for details). Removed now deprecated code (Pyjamas compiled browser part, legacy blog, JSON RPC related code). Adapted code to work without `html` and `themes` dirs.

author	Goffi <goffi@goffi.org>
date	Tue, 13 Aug 2019 19:12:31 +0200
parents	a2df53dfbf46
children	fe9782391f63

comparison

equal deleted inserted replaced

-:f14ab8a25e8b
+:b2d067339de3
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import re
-import glob
 import os.path
 import sys
-import tempfile
+import urllib.parse
-import shutil
+import urllib.request, urllib.error
-import uuid
-import urlparse
-import urllib
 import time
 import copy
 from twisted.application import service
 from twisted.internet import reactor, defer, inotify
 from twisted.web import server
 from twisted.web import static
 from twisted.web import resource as web_resource
 from twisted.web import util as web_util
-from twisted.web import http
 from twisted.web import vhost
 from twisted.python.components import registerAdapter
 from twisted.python import failure
 from twisted.python import filepath
 from twisted.words.protocols.jabber import jid
-from txjsonrpc.web import jsonrpc
-from txjsonrpc import jsonrpclib
 from sat.core.log import getLogger
 from sat_frontends.bridge.dbus_bridge import (
 Bridge,
 from sat.tools import utils
 from sat.tools import config
 from sat.tools.common import regex
 from sat.tools.common import template
 from sat.tools.common import uri as common_uri
-from httplib import HTTPS_PORT
 import libervia
 from libervia.server import websockets
 from libervia.server.pages import LiberviaPage
 from libervia.server.utils import quote, ProgressHandler
 from libervia.server.tasks import TasksManager
 from twisted.internet import ssl
 except ImportError:
 ssl = None
 from libervia.server.constants import Const as C
-from libervia.server.blog import MicroBlog
 from libervia.server import session_iface
 log = getLogger(__name__)
 # following value are set from twisted.plugins.libervia_server initialise
 # (see the comment there)
-DATA_DIR_DEFAULT = OPT_PARAMETERS_BOTH = OPT_PARAMETERS_CFG = coerceDataDir = None
+DATA_DIR_DEFAULT = OPT_PARAMETERS_BOTH = OPT_PARAMETERS_CFG = None
 DEFAULT_MASK = (inotify.IN_CREATE | inotify.IN_MODIFY | inotify.IN_MOVE_SELF
 | inotify.IN_MOVED_TO)
 class FilesWatcher(object):
 notifier.startReading()
 return self._notifier
 def watchDir(self, dir_path, callback, mask=DEFAULT_MASK, auto_add=False,
 recursive=False, **kwargs):
-log.info(_(u"Watching directory {dir_path}").format(dir_path=dir_path))
+log.info(_("Watching directory {dir_path}").format(dir_path=dir_path))
 callbacks = [lambda __, filepath, mask: callback(self.host, filepath,
 inotify.humanReadableMask(mask), **kwargs)]
 self.notifier.watch(
 filepath.FilePath(dir_path), mask=mask, autoAdd=auto_add, recursive=recursive,
 callbacks=callbacks)
 server.Session.__init__(self, *args, **kwargs)
 def lock(self):
 """Prevent session from expiring"""
 self.__lock = True
-self._expireCall.reset(sys.maxint)
+self._expireCall.reset(sys.maxsize)
 def unlock(self):
 """Allow session to expire again, and touch it"""
 self.__lock = False
 self.touch()
 super(ProtectedFile, self).__init__(*args, **kwargs)
 def directoryListing(self):
 return web_resource.NoResource()
+def getChild(self, path, request):
+return super().getChild(path, request)
+def getChildWithDefault(self, path, request):
+return super().getChildWithDefault(path, request)
+def getChildForRequest(self, request):
+return super().getChildForRequest(request)
 class LiberviaRootResource(ProtectedFile):
 """Specialized resource for Libervia root
 handle redirections declared in sat.conf
 self.uri_callbacks = {}
 self.pages_redirects = {}
 self.cached_urls = {}
 self.main_menu = None
-def __unicode__(self):
+def __str__(self):
-return (u"Root resource for {host_name} using {site_name} at {site_path} and "
+return ("Root resource for {host_name} using {site_name} at {site_path} and "
-u"deserving files at {path}".format(
+"deserving files at {path}".format(
 host_name=self.host_name, site_name=self.site_name,
 site_path=self.site_path, path=self.path))
-def __str__(self):
-return self.__unicode__.encode('utf-8')
 def _initRedirections(self, options):
 url_redirections = options["url_redirections_dict"]
 url_redirections = url_redirections.get(self.site_name, {})
 ## redirections
 self.redirections = {}
 self.inv_redirections = {}  # new URL to old URL map
-for old, new_data in url_redirections.iteritems():
+for old, new_data in url_redirections.items():
 # new_data can be a dictionary or a unicode url
 if isinstance(new_data, dict):
 # new_data dict must contain either "url", "page" or "path" key
 # (exclusive)
 # if "path" is used, a file url is constructed with it
-if len({"path", "url", "page"}.intersection(new_data.keys())) != 1:
+if len({"path", "url", "page"}.intersection(list(new_data.keys()))) != 1:
 raise ValueError(
-u'You must have one and only one of "url", "page" or "path" key '
+'You must have one and only one of "url", "page" or "path" key '
-u'in your url_redirections_dict data')
+'in your url_redirections_dict data')
 if "url" in new_data:
 new = new_data["url"]
 elif "page" in new_data:
 new = new_data
 new["type"] = "page"
 new.setdefault("path_args", [])
 if not isinstance(new["path_args"], list):
 log.error(
-_(u'"path_args" in redirection of {old} must be a list. '
+_('"path_args" in redirection of {old} must be a list. '
-u'Ignoring the redirection'.format(old=old)))
+'Ignoring the redirection'.format(old=old)))
 continue
 new.setdefault("query_args", {})
 if not isinstance(new["query_args"], dict):
 log.error(
 _(
-u'"query_args" in redirection of {old} must be a '
+'"query_args" in redirection of {old} must be a '
-u'dictionary. Ignoring the redirection'.format(old=old)))
+'dictionary. Ignoring the redirection'.format(old=old)))
 continue
 new["path_args"] = [quote(a) for a in new["path_args"]]
 # we keep an inversed dict of page redirection
 # (page/path_args => redirecting URL)
 # so getURL can return the redirecting URL if the same arguments
 args_hash
 ] = old
 # we need lists in query_args because it will be used
 # as it in request.path_args
-for k, v in new["query_args"].iteritems():
+for k, v in new["query_args"].items():
-if isinstance(v, basestring):
+if isinstance(v, str):
 new["query_args"][k] = [v]
 elif "path" in new_data:
-new = "file:{}".format(urllib.quote(new_data["path"]))
+new = "file:{}".format(urllib.parse.quote(new_data["path"]))
-elif isinstance(new_data, basestring):
+elif isinstance(new_data, str):
 new = new_data
 new_data = {}
 else:
 log.error(
-_(u"ignoring invalid redirection value: {new_data}").format(
+_("ignoring invalid redirection value: {new_data}").format(
 new_data=new_data
 )
 )
 continue
 # some normalization
 if not old.strip():
 # root URL special case
 old = ""
 elif not old.startswith("/"):
-log.error(_(u"redirected url must start with '/', got {value}. Ignoring")
+log.error(_("redirected url must start with '/', got {value}. Ignoring")
 .format(value=old))
 continue
 else:
 old = self._normalizeURL(old)
 if isinstance(new, dict):
 # dict are handled differently, they contain data
 # which ared use dynamically when the request is done
 self.redirections[old] = new
 if not old:
-if new[u"type"] == u"page":
+if new["type"] == "page":
 log.info(
-_(u"Root URL redirected to page {name}").format(
+_("Root URL redirected to page {name}").format(
-name=new[u"page"]
+name=new["page"]
 )
 )
 else:
-if new[u"type"] == u"page":
+if new["type"] == "page":
-page = self.getPageByName(new[u"page"])
+page = self.getPageByName(new["page"])
-url = page.getURL(*new.get(u"path_args", []))
+url = page.getURL(*new.get("path_args", []))
 self.inv_redirections[url] = old
 continue
 # at this point we have a redirection URL in new, we can parse it
-new_url = urlparse.urlsplit(new.encode("utf-8"))
+new_url = urllib.parse.urlsplit(new)
 # we handle the known URL schemes
 if new_url.scheme == "xmpp":
 location = self.getPagePathFromURI(new)
 if location is None:
 log.warning(
-_(u"ignoring redirection, no page found to handle this URI: "
+_("ignoring redirection, no page found to handle this URI: "
-u"{uri}").format(uri=new))
+"{uri}").format(uri=new))
 continue
 request_data = self._getRequestData(location)
 if old:
 self.inv_redirections[location] = old
 elif new_url.scheme in ("", "http", "https"):
 # direct redirection
 if new_url.netloc:
 raise NotImplementedError(
-u"netloc ({netloc}) is not implemented yet for "
+"netloc ({netloc}) is not implemented yet for "
-u"url_redirections_dict, it is not possible to redirect to an "
+"url_redirections_dict, it is not possible to redirect to an "
-u"external website".format(netloc=new_url.netloc))
+"external website".format(netloc=new_url.netloc))
-location = urlparse.urlunsplit(
+location = urllib.parse.urlunsplit(
 ("", "", new_url.path, new_url.query, new_url.fragment)
-).decode("utf-8")
+)
 request_data = self._getRequestData(location)
 if old:
 self.inv_redirections[location] = old
-elif new_url.scheme in ("file"):
+elif new_url.scheme == "file":
 # file or directory
 if new_url.netloc:
 raise NotImplementedError(
-u"netloc ({netloc}) is not implemented for url redirection to "
+"netloc ({netloc}) is not implemented for url redirection to "
-u"file system, it is not possible to redirect to an external "
+"file system, it is not possible to redirect to an external "
 "host".format(
 netloc=new_url.netloc))
-path = urllib.unquote(new_url.path)
+path = urllib.parse.unquote(new_url.path)
 if not os.path.isabs(path):
 raise ValueError(
-u"file redirection must have an absolute path: e.g. "
+"file redirection must have an absolute path: e.g. "
-u"file:/path/to/my/file")
+"file:/path/to/my/file")
 # for file redirection, we directly put child here
 segments, __, last_segment = old.rpartition("/")
 url_segments = segments.split("/") if segments else []
 current = self
 for segment in url_segments:
 current = resource
 resource_class = (
 ProtectedFile if new_data.get("protected", True) else static.File
 )
 current.putChild(
-last_segment,
+last_segment.encode('utf-8'),
 resource_class(path, defaultType="application/octet-stream")
 )
-log.info(u"[{host_name}] Added redirection from /{old} to file system "
+log.info("[{host_name}] Added redirection from /{old} to file system "
-u"path {path}".format(host_name=self.host_name,
+"path {path}".format(host_name=self.host_name,
-old=old.decode("utf-8"),
+old=old,
-path=path.decode("utf-8")))
+path=path))
 continue  # we don't want to use redirection system, so we continue here
 else:
 raise NotImplementedError(
-u"{scheme}: scheme is not managed for url_redirections_dict".format(
+"{scheme}: scheme is not managed for url_redirections_dict".format(
 scheme=new_url.scheme
 )
 )
 self.redirections[old] = request_data
 if not old:
-log.info(_(u"[{host_name}] Root URL redirected to {uri}")
+log.info(_("[{host_name}] Root URL redirected to {uri}")
 .format(host_name=self.host_name,
-uri=request_data[1].decode("utf-8")))
+uri=request_data[1]))
 # the default root URL, if not redirected
 if not "" in self.redirections:
 self.redirections[""] = self._getRequestData(C.LIBERVIA_PAGE_START)
 def _setMenu(self, menus):
 menus = menus.get(self.site_name, [])
 main_menu = []
 for menu in menus:
 if not menu:
-msg = _(u"menu item can't be empty")
+msg = _("menu item can't be empty")
 log.error(msg)
 raise ValueError(msg)
 elif isinstance(menu, list):
 if len(menu) != 2:
 msg = _(
-u"menu item as list must be in the form [page_name, absolue URL]"
+"menu item as list must be in the form [page_name, absolue URL]"
 )
 log.error(msg)
 raise ValueError(msg)
 page_name, url = menu
 else:
 page_name = menu
 try:
 url = self.getPageByName(page_name).url
 except KeyError as e:
-log_msg = _(u"Can'find a named page ({msg}), please check "
+log_msg = _("Can'find a named page ({msg}), please check "
-u"menu_json in configuration.").format(msg=e.args[0])
+"menu_json in configuration.").format(msg=e.args[0])
 log.error(log_msg)
 raise exceptions.ConfigError(log_msg)
 main_menu.append((page_name, url))
 self.main_menu = main_menu
 @param lower(bool): lower case of url if True
 @return (str): normalized URL
 """
 if lower:
 url = url.lower()
-return "/".join((p for p in url.encode("utf-8").split("/") if p))
+return "/".join((p for p in url.split("/") if p))
 def _getRequestData(self, uri):
 """Return data needed to redirect request
 @param url(unicode): destination url
 splitted path as in Request.postpath
 uri as in Request.uri
 path as in Request.path
 args as in Request.args
 """
-uri = uri.encode("utf-8")
+uri = uri
 # XXX: we reuse code from twisted.web.http.py here
 #      as we need to have the same behaviour
-x = uri.split(b"?", 1)
+x = uri.split("?", 1)
 if len(x) == 1:
 path = uri
 args = {}
 else:
 path, argstring = x
-args = http.parse_qs(argstring, 1)
+args = urllib.parse.parse_qs(argstring, True)
 # XXX: splitted path case must not be changed, as it may be significant
 #      (e.g. for blog items)
 return (
-self._normalizeURL(path.decode("utf-8"), lower=False).split("/"),
+self._normalizeURL(path, lower=False).split("/"),
 uri,
 path,
 args,
 )
 pass
 else:
 try:
 __, uri, __, __ = request_data
 except ValueError:
-uri = u""
+uri = ""
-log.error(D_( u"recursive redirection, please fix this URL:\n"
+log.error(D_( "recursive redirection, please fix this URL:\n"
-u"{old} ==> {new}").format(
+"{old} ==> {new}").format(
-old=request.uri.decode("utf-8"), new=uri.decode("utf-8")))
+old=request.uri.decode("utf-8"), new=uri))
 return web_resource.NoResource()
 request._redirected = True  # here to avoid recursive redirections
 if isinstance(request_data, dict):
 try:
 page = self.getPageByName(request_data["page"])
 except KeyError:
 log.error(
 _(
-u'Can\'t find page named "{name}" requested in redirection'
+'Can\'t find page named "{name}" requested in redirection'
 ).format(name=request_data["page"])
 )
 return web_resource.NoResource()
-request.postpath = request_data["path_args"][:] + request.postpath
+path_args = [pa.encode('utf-8') for pa in request_data["path_args"]]
+request.postpath = path_args + request.postpath
 try:
 request.args.update(request_data["query_args"])
 except (TypeError, ValueError):
 log.error(
-_(u"Invalid args in redirection: {query_args}").format(
+_("Invalid args in redirection: {query_args}").format(
 query_args=request_data["query_args"]
 )
 )
 return web_resource.NoResource()
 return page
 else:
-raise exceptions.InternalError(u"unknown request_data type")
+raise exceptions.InternalError("unknown request_data type")
 else:
 path_list, uri, path, args = request_data
+path_list = [p.encode('utf-8') for p in path_list]
 log.debug(
-u"Redirecting URL {old} to {new}".format(
+"Redirecting URL {old} to {new}".format(
-old=request.uri.decode("utf-8"), new=uri.decode("utf-8")
+old=request.uri.decode('utf-8'), new=uri
 )
 )
 # we change the request to reflect the new url
 request.postpath = path_list[1:] + request.postpath
 request.args.update(args)
 return url
 def getChildWithDefault(self, name, request):
 # XXX: this method is overriden only for root url
 #      which is the only ones who need to be handled before other children
-if name == "" and not request.postpath:
+if name == b"" and not request.postpath:
 return self._redirect(request, self.redirections[""])
 return super(LiberviaRootResource, self).getChildWithDefault(name, request)
 def getChild(self, name, request):
 resource = super(LiberviaRootResource, self).getChild(name, request)
 if isinstance(resource, web_resource.NoResource):
 # if nothing was found, we try our luck with redirections
 # XXX: we want redirections to happen only if everything else failed
 path_elt = request.prepath + request.postpath
-for idx in xrange(len(path_elt), 0, -1):
+for idx in range(len(path_elt), 0, -1):
-test_url = "/".join(path_elt[:idx]).lower()
+test_url = b"/".join(path_elt[:idx]).decode('utf-8').lower()
 if test_url in self.redirections:
 request_data = self.redirections[test_url]
 request.postpath = path_elt[idx:]
 return self._redirect(request, request_data)
 return resource
 def putChild(self, path, resource):
 """Add a child to the root resource"""
+if not isinstance(path, bytes):
+raise ValueError("path must be specified in bytes")
 if not isinstance(resource, web_resource.EncodingResourceWrapper):
 # FIXME: check that no information is leaked (c.f. https://twistedmatrix.com/documents/current/web/howto/using-twistedweb.html#request-encoders)
 resource = web_resource.EncodingResourceWrapper(
 resource, [server.GzipEncoderFactory()])
 f.indexNames = self.indexNames[:]
 f.childNotFound = self.childNotFound
 return f
-class JSONRPCMethodManager(jsonrpc.JSONRPC):
-def __init__(self, sat_host):
-jsonrpc.JSONRPC.__init__(self)
-self.sat_host = sat_host
-def _bridgeCallEb(self, failure_):
-"""Raise a jsonrpclib failure for the frontend"""
-return failure.Failure(
-jsonrpclib.Fault(C.ERRNUM_BRIDGE_ERRBACK, failure_.value.classname)
-)
-def asyncBridgeCall(self, method_name, *args, **kwargs):
-d = self.sat_host.bridgeCall(method_name, *args, **kwargs)
-d.addErrback(self._bridgeCallEb)
-return d
-class MethodHandler(JSONRPCMethodManager):
-def __init__(self, sat_host):
-JSONRPCMethodManager.__init__(self, sat_host)
-def render(self, request):
-self.session = request.getSession()
-profile = session_iface.ISATSession(self.session).profile
-if not profile:
-# user is not identified, we return a jsonrpc fault
-parsed = jsonrpclib.loads(request.content.read())
-fault = jsonrpclib.Fault(
-C.ERRNUM_LIBERVIA, C.NOT_ALLOWED
-)  # FIXME: define some standard error codes for libervia
-return jsonrpc.JSONRPC._cbRender(
-self, fault, request, parsed.get("id"), parsed.get("jsonrpc")
-)  # pylint: disable=E1103
-return jsonrpc.JSONRPC.render(self, request)
-@defer.inlineCallbacks
-def jsonrpc_getVersion(self):
-"""Return SàT version"""
-try:
-defer.returnValue(self._version_cache)
-except AttributeError:
-self._version_cache = yield self.sat_host.bridgeCall("getVersion")
-defer.returnValue(self._version_cache)
-def jsonrpc_getLiberviaVersion(self):
-"""Return Libervia version"""
-return self.sat_host.full_version
-def jsonrpc_disconnect(self):
-"""Disconnect the profile"""
-sat_session = session_iface.ISATSession(self.session)
-profile = sat_session.profile
-self.sat_host.bridgeCall("disconnect", profile)
-def jsonrpc_getContacts(self):
-"""Return all passed args."""
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall("getContacts", profile)
-@defer.inlineCallbacks
-def jsonrpc_addContact(self, entity, name, groups):
-"""Subscribe to contact presence, and add it to the given groups"""
-profile = session_iface.ISATSession(self.session).profile
-yield self.sat_host.bridgeCall("addContact", entity, profile)
-yield self.sat_host.bridgeCall("updateContact", entity, name, groups, profile)
-def jsonrpc_delContact(self, entity):
-"""Remove contact from contacts list"""
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall("delContact", entity, profile)
-def jsonrpc_updateContact(self, entity, name, groups):
-"""Update contact's roster item"""
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall("updateContact", entity, name, groups, profile)
-def jsonrpc_subscription(self, sub_type, entity):
-"""Confirm (or infirm) subscription,
-and setup user roster in case of subscription"""
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall("subscription", sub_type, entity, profile)
-def jsonrpc_getWaitingSub(self):
-"""Return list of room already joined by user"""
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall("getWaitingSub", profile)
-def jsonrpc_setStatus(self, presence, status):
-"""Change the presence and/or status
-@param presence: value from ("", "chat", "away", "dnd", "xa")
-@param status: any string to describe your status
-"""
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall(
-"setPresence", "", presence, {"": status}, profile
-)
-def jsonrpc_messageSend(self, to_jid, msg, subject, type_, extra={}):
-"""send message"""
-profile = session_iface.ISATSession(self.session).profile
-return self.asyncBridgeCall(
-"messageSend", to_jid, msg, subject, type_, extra, profile
-)
-## PubSub ##
-def jsonrpc_psNodeDelete(self, service, node):
-"""Delete a whole node
-@param service (unicode): service jid
-@param node (unicode): node to delete
-"""
-profile = session_iface.ISATSession(self.session).profile
-return self.asyncBridgeCall("psNodeDelete", service, node, profile)
-# def jsonrpc_psRetractItem(self, service, node, item, notify):
-#     """Delete a whole node
-#     @param service (unicode): service jid
-#     @param node (unicode): node to delete
-#     @param items (iterable): id of item to retract
-#     @param notify (bool): True if notification is required
-#     """
-#     profile = session_iface.ISATSession(self.session).profile
-#     return self.asyncBridgeCall("psRetractItem", service, node, item, notify,
-#                                 profile)
-# def jsonrpc_psRetractItems(self, service, node, items, notify):
-#     """Delete a whole node
-#     @param service (unicode): service jid
-#     @param node (unicode): node to delete
-#     @param items (iterable): ids of items to retract
-#     @param notify (bool): True if notification is required
-#     """
-#     profile = session_iface.ISATSession(self.session).profile
-#     return self.asyncBridgeCall("psRetractItems", service, node, items, notify,
-#                                 profile)
-## microblogging ##
-def jsonrpc_mbSend(self, service, node, mb_data):
-"""Send microblog data
-@param service (unicode): service jid or empty string to use profile's microblog
-@param node (unicode): publishing node, or empty string to use microblog node
-@param mb_data(dict): microblog data
-@return: a deferred
-"""
-profile = session_iface.ISATSession(self.session).profile
-return self.asyncBridgeCall("mbSend", service, node, mb_data, profile)
-def jsonrpc_mbRetract(self, service, node, items):
-"""Delete a whole node
-@param service (unicode): service jid, empty string for PEP
-@param node (unicode): node to delete, empty string for default node
-@param items (iterable): ids of items to retract
-"""
-profile = session_iface.ISATSession(self.session).profile
-return self.asyncBridgeCall("mbRetract", service, node, items, profile)
-def jsonrpc_mbGet(self, service_jid, node, max_items, item_ids, extra):
-"""Get last microblogs from publisher_jid
-@param service_jid (unicode): pubsub service, usually publisher jid
-@param node(unicode): mblogs node, or empty string to get the defaut one
-@param max_items (int): maximum number of item to get or C.NO_LIMIT to get
-everything
-@param item_ids (list[unicode]): list of item IDs
-@param rsm (dict): TODO
-@return: a deferred couple with the list of items and metadatas.
-"""
-profile = session_iface.ISATSession(self.session).profile
-return self.asyncBridgeCall(
-"mbGet", service_jid, node, max_items, item_ids, extra, profile
-)
-def jsonrpc_mbGetFromMany(self, publishers_type, publishers, max_items, extra):
-"""Get many blog nodes at once
-@param publishers_type (unicode): one of "ALL", "GROUP", "JID"
-@param publishers (tuple(unicode)): tuple of publishers (empty list for all,
-list of groups or list of jids)
-@param max_items (int): maximum number of item to get or C.NO_LIMIT to get
-everything
-@param extra (dict): TODO
-@return (str): RT Deferred session id
-"""
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall(
-"mbGetFromMany", publishers_type, publishers, max_items, extra, profile
-)
-def jsonrpc_mbGetFromManyRTResult(self, rt_session):
-"""Get results from RealTime mbGetFromMany session
-@param rt_session (str): RT Deferred session id
-"""
-profile = session_iface.ISATSession(self.session).profile
-return self.asyncBridgeCall("mbGetFromManyRTResult", rt_session, profile)
-def jsonrpc_mbGetFromManyWithComments(
-self,
-publishers_type,
-publishers,
-max_items,
-max_comments,
-rsm_dict,
-rsm_comments_dict,
-):
-"""Helper method to get the microblogs and their comments in one shot
-@param publishers_type (str): type of the list of publishers (one of "GROUP" or
-"JID" or "ALL")
-@param publishers (list): list of publishers, according to publishers_type
-(list of groups or list of jids)
-@param max_items (int): optional limit on the number of retrieved items.
-@param max_comments (int): maximum number of comments to retrieve
-@param rsm_dict (dict): RSM data for initial items only
-@param rsm_comments_dict (dict): RSM data for comments only
-@param profile_key: profile key
-@return (str): RT Deferred session id
-"""
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall(
-"mbGetFromManyWithComments",
-publishers_type,
-publishers,
-max_items,
-max_comments,
-rsm_dict,
-rsm_comments_dict,
-profile,
-)
-def jsonrpc_mbGetFromManyWithCommentsRTResult(self, rt_session):
-"""Get results from RealTime mbGetFromManyWithComments session
-@param rt_session (str): RT Deferred session id
-"""
-profile = session_iface.ISATSession(self.session).profile
-return self.asyncBridgeCall(
-"mbGetFromManyWithCommentsRTResult", rt_session, profile
-)
-# def jsonrpc_sendMblog(self, type_, dest, text, extra={}):
-#     """ Send microblog message
-#     @param type_ (unicode): one of "PUBLIC", "GROUP"
-#     @param dest (tuple(unicode)): recipient groups (ignored for "PUBLIC")
-#     @param text (unicode): microblog's text
-#     """
-#     profile = session_iface.ISATSession(self.session).profile
-#     extra['allow_comments'] = 'True'
-#     if not type_:  # auto-detect
-#         type_ = "PUBLIC" if dest == [] else "GROUP"
-#     if type_ in ("PUBLIC", "GROUP") and text:
-#         if type_ == "PUBLIC":
-#             #This text if for the public microblog
-#             log.debug("sending public blog")
-#             return self.sat_host.bridge.sendGroupBlog("PUBLIC", (), text, extra,
-#                                                       profile)
-#         else:
-#             log.debug("sending group blog")
-#             dest = dest if isinstance(dest, list) else [dest]
-#             return self.sat_host.bridge.sendGroupBlog("GROUP", dest, text, extra,
-#                                                       profile)
-#     else:
-#         raise Exception("Invalid data")
-# def jsonrpc_deleteMblog(self, pub_data, comments):
-#     """Delete a microblog node
-#     @param pub_data: a tuple (service, comment node identifier, item identifier)
-#     @param comments: comments node identifier (for main item) or False
-#     """
-#     profile = session_iface.ISATSession(self.session).profile
-#     return self.sat_host.bridge.deleteGroupBlog(pub_data, comments if comments
-#         else '', profile)
-# def jsonrpc_updateMblog(self, pub_data, comments, message, extra={}):
-#     """Modify a microblog node
-#     @param pub_data: a tuple (service, comment node identifier, item identifier)
-#     @param comments: comments node identifier (for main item) or False
-#     @param message: new message
-#     @param extra: dict which option name as key, which can be:
-#         - allow_comments: True to accept an other level of comments, False else
-#               (default: False)
-#         - rich: if present, contain rich text in currently selected syntax
-#     """
-#     profile = session_iface.ISATSession(self.session).profile
-#     if comments:
-#         extra['allow_comments'] = 'True'
-#     return self.sat_host.bridge.updateGroupBlog(pub_data, comments if comments
-#         else '', message, extra, profile)
-# def jsonrpc_sendMblogComment(self, node, text, extra={}):
-#     """ Send microblog message
-#     @param node: url of the comments node
-#     @param text: comment
-#     """
-#     profile = session_iface.ISATSession(self.session).profile
-#     if node and text:
-#         return self.sat_host.bridge.sendGroupBlogComment(node, text, extra, profile)
-#     else:
-#         raise Exception("Invalid data")
-# def jsonrpc_getMblogs(self, publisher_jid, item_ids, max_items=C.RSM_MAX_ITEMS):
-#     """Get specified microblogs posted by a contact
-#     @param publisher_jid: jid of the publisher
-#     @param item_ids: list of microblogs items IDs
-#     @return list of microblog data (dict)"""
-#     profile = session_iface.ISATSession(self.session).profile
-#     d = self.asyncBridgeCall("getGroupBlogs", publisher_jid, item_ids, {'max_': unicode(max_items)}, False, profile)
-#     return d
-# def jsonrpc_getMblogsWithComments(self, publisher_jid, item_ids, max_comments=C.RSM_MAX_COMMENTS):
-#     """Get specified microblogs posted by a contact and their comments
-#     @param publisher_jid: jid of the publisher
-#     @param item_ids: list of microblogs items IDs
-#     @return list of couple (microblog data, list of microblog data)"""
-#     profile = session_iface.ISATSession(self.session).profile
-#     d = self.asyncBridgeCall("getGroupBlogsWithComments", publisher_jid, item_ids, {}, max_comments, profile)
-#     return d
-# def jsonrpc_getMassiveMblogs(self, publishers_type, publishers, rsm=None):
-#     """Get lasts microblogs posted by several contacts at once
-#     @param publishers_type (unicode): one of "ALL", "GROUP", "JID"
-#     @param publishers (tuple(unicode)): tuple of publishers (empty list for all, list of groups or list of jids)
-#     @param rsm (dict): TODO
-#     @return: dict{unicode: list[dict])
-#         key: publisher's jid
-#         value: list of microblog data (dict)
-#     """
-#     profile = session_iface.ISATSession(self.session).profile
-#     if rsm is None:
-#         rsm = {'max_': unicode(C.RSM_MAX_ITEMS)}
-#     d = self.asyncBridgeCall("getMassiveGroupBlogs", publishers_type, publishers, rsm, profile)
-#     self.sat_host.bridge.massiveSubscribeGroupBlogs(publishers_type, publishers, profile)
-#     return d
-# def jsonrpc_getMblogComments(self, service, node, rsm=None):
-#     """Get all comments of given node
-#     @param service: jid of the service hosting the node
-#     @param node: comments node
-#     """
-#     profile = session_iface.ISATSession(self.session).profile
-#     if rsm is None:
-#         rsm = {'max_': unicode(C.RSM_MAX_COMMENTS)}
-#     d = self.asyncBridgeCall("getGroupBlogComments", service, node, rsm, profile)
-#     return d
-def jsonrpc_getPresenceStatuses(self):
-"""Get Presence information for connected contacts"""
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall("getPresenceStatuses", profile)
-def jsonrpc_historyGet(self, from_jid, to_jid, size, between, search=""):
-"""Return history for the from_jid/to_jid couple"""
-sat_session = session_iface.ISATSession(self.session)
-profile = sat_session.profile
-sat_jid = sat_session.jid
-if not sat_jid:
-raise exceptions.InternalError("session jid should be set")
-if (
-jid.JID(from_jid).userhost() != sat_jid.userhost()
-and jid.JID(to_jid).userhost() != sat_jid.userhost()
-):
-log.error(
-u"Trying to get history from a different jid (given (browser): {}, real "
-u"(backend): {}), maybe a hack attempt ?".format( from_jid, sat_jid))
-return {}
-d = self.asyncBridgeCall(
-"historyGet", from_jid, to_jid, size, between, search, profile)
-def show(result_dbus):
-result = []
-for line in result_dbus:
-# XXX: we have to do this stupid thing because Python D-Bus use its own
-#      types instead of standard types and txJsonRPC doesn't accept
-#      D-Bus types, resulting in a empty query
-uuid, timestamp, from_jid, to_jid, message, subject, mess_type, extra = (
-line
-)
-result.append(
-(
-unicode(uuid),
-float(timestamp),
-unicode(from_jid),
-unicode(to_jid),
-dict(message),
-dict(subject),
-unicode(mess_type),
-dict(extra),
-)
-)
-return result
-d.addCallback(show)
-return d
-def jsonrpc_mucJoin(self, room_jid, nick):
-"""Join a Multi-User Chat room
-@param room_jid (unicode): room JID or empty string to generate a unique name
-@param nick (unicode): user nick
-"""
-profile = session_iface.ISATSession(self.session).profile
-d = self.asyncBridgeCall("joinMUC", room_jid, nick, {}, profile)
-return d
-def jsonrpc_inviteMUC(self, contact_jid, room_jid):
-"""Invite a user to a Multi-User Chat room
-@param contact_jid (unicode): contact to invite
-@param room_jid (unicode): room JID or empty string to generate a unique name
-"""
-profile = session_iface.ISATSession(self.session).profile
-room_id = room_jid.split("@")[0]
-service = room_jid.split("@")[1]
-return self.sat_host.bridgeCall(
-"inviteMUC", contact_jid, service, room_id, {}, profile
-)
-def jsonrpc_mucLeave(self, room_jid):
-"""Quit a Multi-User Chat room"""
-profile = session_iface.ISATSession(self.session).profile
-try:
-room_jid = jid.JID(room_jid)
-except:
-log.warning("Invalid room jid")
-return
-return self.sat_host.bridgeCall("mucLeave", room_jid.userhost(), profile)
-def jsonrpc_mucGetRoomsJoined(self):
-"""Return list of room already joined by user"""
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall("mucGetRoomsJoined", profile)
-def jsonrpc_mucGetDefaultService(self):
-"""@return: the default MUC"""
-d = self.asyncBridgeCall("mucGetDefaultService")
-return d
-def jsonrpc_launchTarotGame(self, other_players, room_jid=""):
-"""Create a room, invite the other players and start a Tarot game.
-@param other_players (list[unicode]): JIDs of the players to play with
-@param room_jid (unicode): room JID or empty string to generate a unique name
-"""
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall(
-"tarotGameLaunch", other_players, room_jid, profile
-)
-def jsonrpc_getTarotCardsPaths(self):
-"""Give the path of all the tarot cards"""
-_join = os.path.join
-_media_dir = _join(self.sat_host.media_dir, "")
-return map(
-lambda x: _join(C.MEDIA_DIR, x[len(_media_dir) :]),
-glob.glob(_join(_media_dir, C.CARDS_DIR, "*_*.png")),
-)
-def jsonrpc_tarotGameReady(self, player, referee):
-"""Tell to the server that we are ready to start the game"""
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall("tarotGameReady", player, referee, profile)
-def jsonrpc_tarotGamePlayCards(self, player_nick, referee, cards):
-"""Tell to the server the cards we want to put on the table"""
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall(
-"tarotGamePlayCards", player_nick, referee, cards, profile
-)
-def jsonrpc_launchRadioCollective(self, invited, room_jid=""):
-"""Create a room, invite people, and start a radio collective.
-@param invited (list[unicode]): JIDs of the contacts to play with
-@param room_jid (unicode): room JID or empty string to generate a unique name
-"""
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall("radiocolLaunch", invited, room_jid, profile)
-def jsonrpc_getEntitiesData(self, jids, keys):
-"""Get cached data for several entities at once
-@param jids: list jids from who we wants data, or empty list for all jids in cache
-@param keys: name of data we want (list)
-@return: requested data"""
-if not C.ALLOWED_ENTITY_DATA.issuperset(keys):
-raise exceptions.PermissionError(
-"Trying to access unallowed data (hack attempt ?)"
-)
-profile = session_iface.ISATSession(self.session).profile
-try:
-return self.sat_host.bridgeCall("getEntitiesData", jids, keys, profile)
-except Exception as e:
-raise failure.Failure(jsonrpclib.Fault(C.ERRNUM_BRIDGE_ERRBACK, unicode(e)))
-def jsonrpc_getEntityData(self, jid, keys):
-"""Get cached data for an entity
-@param jid: jid of contact from who we want data
-@param keys: name of data we want (list)
-@return: requested data"""
-if not C.ALLOWED_ENTITY_DATA.issuperset(keys):
-raise exceptions.PermissionError(
-"Trying to access unallowed data (hack attempt ?)"
-)
-profile = session_iface.ISATSession(self.session).profile
-try:
-return self.sat_host.bridgeCall("getEntityData", jid, keys, profile)
-except Exception as e:
-raise failure.Failure(jsonrpclib.Fault(C.ERRNUM_BRIDGE_ERRBACK, unicode(e)))
-def jsonrpc_getCard(self, jid_):
-"""Get VCard for entiry
-@param jid_: jid of contact from who we want data
-@return: id to retrieve the profile"""
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall("getCard", jid_, profile)
-@defer.inlineCallbacks
-def jsonrpc_avatarGet(self, entity, cache_only, hash_only):
-session_data = session_iface.ISATSession(self.session)
-profile = session_data.profile
-# profile_uuid = session_data.uuid
-avatar = yield self.asyncBridgeCall(
-"avatarGet", entity, cache_only, hash_only, profile
-)
-if hash_only:
-defer.returnValue(avatar)
-else:
-filename = os.path.basename(avatar)
-avatar_url = os.path.join(session_data.cache_dir, filename)
-defer.returnValue(avatar_url)
-def jsonrpc_getAccountDialogUI(self):
-"""Get the dialog for managing user account
-@return: XML string of the XMLUI"""
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall("getAccountDialogUI", profile)
-def jsonrpc_getParamsUI(self):
-"""Return the parameters XML for profile"""
-profile = session_iface.ISATSession(self.session).profile
-return self.asyncBridgeCall("getParamsUI", C.SECURITY_LIMIT, C.APP_NAME, profile)
-def jsonrpc_asyncGetParamA(self, param, category, attribute="value"):
-"""Return the parameter value for profile"""
-profile = session_iface.ISATSession(self.session).profile
-if category == "Connection":
-# we need to manage the followings params here, else SECURITY_LIMIT would
-# block them
-if param == "JabberID":
-return self.asyncBridgeCall(
-"asyncGetParamA", param, category, attribute, profile_key=profile
-)
-elif param == "autoconnect":
-return defer.succeed(C.BOOL_TRUE)
-d = self.asyncBridgeCall(
-"asyncGetParamA",
-param,
-category,
-attribute,
-C.SECURITY_LIMIT,
-profile_key=profile,
-)
-return d
-def jsonrpc_setParam(self, name, value, category):
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall(
-"setParam", name, value, category, C.SECURITY_LIMIT, profile
-)
-def jsonrpc_launchAction(self, callback_id, data):
-# FIXME: any action can be launched, this can be a huge security issue if
-#        callback_id can be guessed a security system with authorised
-#        callback_id must be implemented, similar to the one for authorised params
-profile = session_iface.ISATSession(self.session).profile
-d = self.asyncBridgeCall("launchAction", callback_id, data, profile)
-return d
-def jsonrpc_chatStateComposing(self, to_jid_s):
-"""Call the method to process a "composing" state.
-@param to_jid_s: contact the user is composing to
-"""
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall("chatStateComposing", to_jid_s, profile)
-def jsonrpc_getNewAccountDomain(self):
-"""@return: the domain for new account creation"""
-d = self.asyncBridgeCall("getNewAccountDomain")
-return d
-def jsonrpc_syntaxConvert(
-self, text, syntax_from=C.SYNTAX_XHTML, syntax_to=C.SYNTAX_CURRENT
-):
-""" Convert a text between two syntaxes
-@param text: text to convert
-@param syntax_from: source syntax (e.g. "markdown")
-@param syntax_to: dest syntax (e.g.: "XHTML")
-@param safe: clean resulting XHTML to avoid malicious code if True (forced here)
-@return: converted text """
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall(
-"syntaxConvert", text, syntax_from, syntax_to, True, profile
-)
-def jsonrpc_getLastResource(self, jid_s):
-"""Get the last active resource of that contact."""
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall("getLastResource", jid_s, profile)
-def jsonrpc_getFeatures(self):
-"""Return the available features in the backend for profile"""
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall("getFeatures", profile)
-def jsonrpc_skipOTR(self):
-"""Tell the backend to leave OTR handling to Libervia."""
-profile = session_iface.ISATSession(self.session).profile
-return self.sat_host.bridgeCall("skipOTR", profile)
-def jsonrpc_namespacesGet(self):
-return self.sat_host.bridgeCall("namespacesGet")
 class WaitingRequests(dict):
 def setRequest(self, request, profile, register_with_ext_jid=False):
 """Add the given profile to the waiting list.
 @param request (server.Request): the connection request
 @return: bool or None
 """
 return self[profile][2] if profile in self else None
-class Register(JSONRPCMethodManager):
-"""This class manage the registration procedure with SàT
-It provide an api for the browser, check password and setup the web server"""
-def __init__(self, sat_host):
-JSONRPCMethodManager.__init__(self, sat_host)
-self.profiles_waiting = {}
-self.request = None
-def render(self, request):
-"""
-Render method with some hacks:
-- if login is requested, try to login with form data
-- except login, every method is jsonrpc
-- user doesn't need to be authentified for explicitely listed methods,
-but must be for all others
-"""
-if request.postpath == ["login"]:
-return self.loginOrRegister(request)
-_session = request.getSession()
-parsed = jsonrpclib.loads(request.content.read())
-method = parsed.get("method")  # pylint: disable=E1103
-if method not in ["getSessionMetadata", "registerParams", "menusGet"]:
-# if we don't call these methods, we need to be identified
-profile = session_iface.ISATSession(_session).profile
-if not profile:
-# user is not identified, we return a jsonrpc fault
-fault = jsonrpclib.Fault(
-C.ERRNUM_LIBERVIA, C.NOT_ALLOWED
-)  # FIXME: define some standard error codes for libervia
-return jsonrpc.JSONRPC._cbRender(
-self, fault, request, parsed.get("id"), parsed.get("jsonrpc")
-)  # pylint: disable=E1103
-self.request = request
-return jsonrpc.JSONRPC.render(self, request)
-def loginOrRegister(self, request):
-"""This method is called with the POST information from the registering form.
-@param request: request of the register form
-@return: a constant indicating the state:
-- C.BAD_REQUEST: something is wrong in the request (bad arguments)
-- a return value from self._loginAccount or self._registerNewAccount
-"""
-try:
-submit_type = request.args["submit_type"][0]
-except KeyError:
-return C.BAD_REQUEST
-if submit_type == "register":
-self._registerNewAccount(request)
-return server.NOT_DONE_YET
-elif submit_type == "login":
-self._loginAccount(request)
-return server.NOT_DONE_YET
-return Exception("Unknown submit type")
-@defer.inlineCallbacks
-def _registerNewAccount(self, request):
-try:
-login = request.args["register_login"][0]
-password = request.args["register_password"][0]
-email = request.args["email"][0]
-except KeyError:
-request.write(C.BAD_REQUEST)
-request.finish()
-return
-status = yield self.sat_host.registerNewAccount(request, login, password, email)
-request.write(status)
-request.finish()
-@defer.inlineCallbacks
-def _loginAccount(self, request):
-"""Try to authenticate the user with the request information.
-will write to request a constant indicating the state:
-- C.PROFILE_LOGGED: profile is connected
-- C.PROFILE_LOGGED_EXT_JID: profile is connected and an external jid has
-been used
-- C.SESSION_ACTIVE: session was already active
-- C.BAD_REQUEST: something is wrong in the request (bad arguments)
-- C.PROFILE_AUTH_ERROR: either the profile (login) or the profile password
-is wrong
-- C.XMPP_AUTH_ERROR: the profile is authenticated but the XMPP password
-is wrong
-- C.ALREADY_WAITING: a request has already been submitted for this profile,
-C.PROFILE_LOGGED_EXT_JID)
-- C.NOT_CONNECTED: connection has not been established
-the request will then be finished
-@param request: request of the register form
-"""
-try:
-login = request.args["login"][0]
-password = request.args["login_password"][0]
-except KeyError:
-request.write(C.BAD_REQUEST)
-request.finish()
-return
-assert login
-try:
-status = yield self.sat_host.connect(request, login, password)
-except (
-exceptions.DataError,
-exceptions.ProfileUnknownError,
-exceptions.PermissionError,
-):
-request.write(C.PROFILE_AUTH_ERROR)
-request.finish()
-return
-except exceptions.NotReady:
-request.write(C.ALREADY_WAITING)
-request.finish()
-return
-except exceptions.TimeOutError:
-request.write(C.NO_REPLY)
-request.finish()
-return
-except exceptions.InternalError as e:
-request.write(e.message)
-request.finish()
-return
-except exceptions.ConflictError:
-request.write(C.SESSION_ACTIVE)
-request.finish()
-return
-except ValueError as e:
-if e.message in (C.PROFILE_AUTH_ERROR, C.XMPP_AUTH_ERROR):
-request.write(e.message)
-request.finish()
-return
-else:
-raise e
-assert status
-request.write(status)
-request.finish()
-def jsonrpc_isConnected(self):
-_session = self.request.getSession()
-profile = session_iface.ISATSession(_session).profile
-return self.sat_host.bridgeCall("isConnected", profile)
-def jsonrpc_connect(self):
-_session = self.request.getSession()
-profile = session_iface.ISATSession(_session).profile
-if self.waiting_profiles.getRequest(profile):
-raise jsonrpclib.Fault(
-1, C.ALREADY_WAITING
-)  # FIXME: define some standard error codes for libervia
-self.waiting_profiles.setRequest(self.request, profile)
-self.sat_host.bridgeCall("connect", profile)
-return server.NOT_DONE_YET
-def jsonrpc_getSessionMetadata(self):
-"""Return metadata useful on session start
-@return (dict): metadata which can have the following keys:
-"plugged" (bool): True if a profile is already plugged
-"warning" (unicode): a security warning message if plugged is False and if
-it make sense.
-This key may not be present.
-"allow_registration" (bool): True if registration is allowed
-this key is only present if profile is unplugged
-@return: a couple (registered, message) with:
-- registered:
-- message:
-"""
-metadata = {}
-_session = self.request.getSession()
-profile = session_iface.ISATSession(_session).profile
-if profile:
-metadata["plugged"] = True
-else:
-metadata["plugged"] = False
-metadata["warning"] = self._getSecurityWarning()
-metadata["allow_registration"] = self.sat_host.options["allow_registration"]
-return metadata
-def jsonrpc_registerParams(self):
-"""Register the frontend specific parameters"""
-# params = """<params><individual>...</category></individual>"""
-# self.sat_host.bridge.paramsRegisterApp(params, C.SECURITY_LIMIT, C.APP_NAME)
-def jsonrpc_menusGet(self):
-"""Return the parameters XML for profile"""
-# XXX: we put this method in Register because we get menus before being logged
-return self.sat_host.bridgeCall("menusGet", "", C.SECURITY_LIMIT)
-def _getSecurityWarning(self):
-"""@return: a security warning message, or None if the connection is secure"""
-if (
-self.request.URLPath().scheme == "https"
-or not self.sat_host.options["security_warning"]
-):
-return None
-text = (
-"<p>"
-+ D_("You are about to connect to an unsecure service.")
-+ "</p><p>&nbsp;</p><p>"
-)
-if self.sat_host.options["connection_type"] == "both":
-new_port = (
-(":%s" % self.sat_host.options["port_https_ext"])
-if self.sat_host.options["port_https_ext"] != HTTPS_PORT
-else ""
-)
-url = "https://%s" % self.request.URLPath().netloc.replace(
-":%s" % self.sat_host.options["port"], new_port
-)
-text += D_(
-"Please read our %(faq_prefix)ssecurity notice%(faq_suffix)s regarding HTTPS"
-) % {
-"faq_prefix": '<a href="http://salut-a-toi.org/faq.html#https" target="#">',
-"faq_suffix": "</a>",
-}
-text += "</p><p>" + D_("and use the secure version of this website:")
-text += '</p><p>&nbsp;</p><p align="center"><a href="%(url)s">%(url)s</a>' % {
-"url": url
-}
-else:
-text += D_("You should ask your administrator to turn on HTTPS.")
-return text + "</p><p>&nbsp;</p>"
-class SignalHandler(jsonrpc.JSONRPC):
-def __init__(self, sat_host):
-web_resource.Resource.__init__(self)
-self.register = None
-self.sat_host = sat_host
-self._last_service_prof_disconnect = time.time()
-self.signalDeferred = {}  # dict of deferred (key: profile, value: Deferred)
-# which manages the long polling HTTP request with signals
-self.queue = {}
-def plugRegister(self, register):
-self.register = register
-def jsonrpc_getSignals(self):
-"""Keep the connection alive until a signal is received, then send it
-@return: (signal, *signal_args)"""
-_session = self.request.getSession()
-profile = session_iface.ISATSession(_session).profile
-if profile in self.queue:  # if we have signals to send in queue
-if self.queue[profile]:
-return self.queue[profile].pop(0)
-else:
-# the queue is empty, we delete the profile from queue
-del self.queue[profile]
-_session.lock()  # we don't want the session to expire as long as this
-# connection is active
-def unlock(signal, profile):
-_session.unlock()
-try:
-source_defer = self.signalDeferred[profile]
-if source_defer.called and source_defer.result[0] == "disconnected":
-log.info(u"[%s] disconnected" % (profile,))
-try:
-_session.expire()
-except KeyError:
-#  FIXME: happen if session is ended using login page
-#        when pyjamas page is also launched
-log.warning(u"session is already expired")
-except IndexError:
-log.error("Deferred result should be a tuple with fonction name first")
-self.signalDeferred[profile] = defer.Deferred()
-self.request.notifyFinish().addBoth(unlock, profile)
-return self.signalDeferred[profile]
-def getGenericCb(self, function_name):
-"""Return a generic function which send all params to signalDeferred.callback
-function must have profile as last argument"""
-def genericCb(*args):
-profile = args[-1]
-if not profile in self.sat_host.prof_connected:
-return
-signal_data = (function_name, args[:-1])
-try:
-signal_callback = self.signalDeferred[profile].callback
-except KeyError:
-self.queue.setdefault(profile, []).append(signal_data)
-else:
-signal_callback(signal_data)
-del self.signalDeferred[profile]
-return genericCb
-def actionNewHandler(self, action_data, action_id, security_limit, profile):
-"""actionNew handler
-XXX: We need need a dedicated handler has actionNew use a security_limit
-which must be managed
-@param action_data(dict): see bridge documentation
-@param action_id(unicode): identitifer of the action
-@param security_limit(int): %(doc_security_limit)s
-@param profile(unicode): %(doc_profile)s
-"""
-if not profile in self.sat_host.prof_connected:
-return
-# FIXME: manage security limit in a dedicated method
-#        raise an exception if it's not OK
-#        and read value in sat.conf
-if security_limit >= C.SECURITY_LIMIT:
-log.debug(
-u"Ignoring action  {action_id}, blocked by security limit".format(
-action_id=action_id
-)
-)
-return
-signal_data = ("actionNew", (action_data, action_id, security_limit))
-try:
-signal_callback = self.signalDeferred[profile].callback
-except KeyError:
-self.queue.setdefault(profile, []).append(signal_data)
-else:
-signal_callback(signal_data)
-del self.signalDeferred[profile]
-def connected(self, profile, jid_s):
-"""Connection is done.
-@param profile (unicode): %(doc_profile)s
-@param jid_s (unicode): the JID that we were assigned by the server, as the
-resource might differ from the JID we asked for.
-"""
-#  FIXME: _logged should not be called from here, check this code
-#  FIXME: check if needed to connect with external jid
-# jid_s is handled in QuickApp.connectionHandler already
-# assert self.register  # register must be plugged
-# request = self.sat_host.waiting_profiles.getRequest(profile)
-# if request:
-#     self.sat_host._logged(profile, request)
-def disconnected(self, profile):
-if profile == C.SERVICE_PROFILE:
-# if service profile has been disconnected, we try to reconnect it
-# if we can't we show error message
-# and if we have 2 disconnection in a short time, we don't try to reconnect
-# and display an error message
-disconnect_delta = time.time() - self._last_service_prof_disconnect
-if disconnect_delta < 15:
-log.error(
-_(u"Service profile disconnected twice in a short time, please "
-u"check connection"))
-else:
-log.info(
-_(u"Service profile has been disconnected, but we need it! "
-u"Reconnecting it..."))
-d = self.sat_host.bridgeCall(
-"connect", profile, self.sat_host.options["passphrase"], {}
-)
-d.addErrback(
-lambda failure_: log.error(_(
-u"Can't reconnect service profile, please check connection: "
-u"{reason}").format(reason=failure_)))
-self._last_service_prof_disconnect = time.time()
-return
-if not profile in self.sat_host.prof_connected:
-log.info(_(u"'disconnected' signal received for a not connected profile "
-u"({profile})").format(profile=profile))
-return
-self.sat_host.prof_connected.remove(profile)
-if profile in self.signalDeferred:
-self.signalDeferred[profile].callback(("disconnected",))
-del self.signalDeferred[profile]
-else:
-if profile not in self.queue:
-self.queue[profile] = []
-self.queue[profile].append(("disconnected",))
-def render(self, request):
-"""
-Render method wich reject access if user is not identified
-"""
-_session = request.getSession()
-parsed = jsonrpclib.loads(request.content.read())
-profile = session_iface.ISATSession(_session).profile
-if not profile:
-# FIXME: this method should not use _cbRender
-#        but all txJsonRPC code will be removed in 0.8 in favor of webRTC
-#        and it is currently used only with Libervia legacy app,
-#        so we do a is_jsonp workaround for now
-self.is_jsonp = False
-# user is not identified, we return a jsonrpc fault
-fault = jsonrpclib.Fault(
-C.ERRNUM_LIBERVIA, C.NOT_ALLOWED
-)  # FIXME: define some standard error codes for libervia
-return jsonrpc.JSONRPC._cbRender(
-self, fault, request, parsed.get("id"), parsed.get("jsonrpc")
-)
-self.request = request
-return jsonrpc.JSONRPC.render(self, request)
-class UploadManager(web_resource.Resource):
-"""This class manage the upload of a file
-It redirect the stream to SàT core backend"""
-isLeaf = True
-NAME = "path"  # name use by the FileUpload
-def __init__(self, sat_host):
-self.sat_host = sat_host
-self.upload_dir = tempfile.mkdtemp()
-self.sat_host.addCleanup(shutil.rmtree, self.upload_dir)
-def getTmpDir(self):
-return self.upload_dir
-def _getFileName(self, request):
-"""Generate unique filename for a file"""
-raise NotImplementedError
-def _fileWritten(self, request, filepath):
-"""Called once the file is actually written on disk
-@param request: HTTP request object
-@param filepath: full filepath on the server
-@return: a tuple with the name of the async bridge method
-to be called followed by its arguments.
-"""
-raise NotImplementedError
-def render(self, request):
-"""
-Render method with some hacks:
-- if login is requested, try to login with form data
-- except login, every method is jsonrpc
-- user doesn't need to be authentified for getSessionMetadata, but must be
-for all other methods
-"""
-filename = self._getFileName(request)
-filepath = os.path.join(self.upload_dir, filename)
-# FIXME: the uploaded file is fully loaded in memory at form parsing time so far
-#       (see twisted.web.http.Request.requestReceived). A custom requestReceived
-#       should be written in the futur. In addition, it is not yet possible to
-#       get progression informations (see
-#       http://twistedmatrix.com/trac/ticket/288)
-with open(filepath, "w") as f:
-f.write(request.args[self.NAME][0])
-def finish(d):
-error = isinstance(d, Exception) or isinstance(d, failure.Failure)
-request.write(C.UPLOAD_KO if error else C.UPLOAD_OK)
-# TODO: would be great to re-use the original Exception class and message
-# but it is lost in the middle of the backtrace and encapsulated within
-# a DBusException instance --> extract the data from the backtrace?
-request.finish()
-d = JSONRPCMethodManager(self.sat_host).asyncBridgeCall(
-*self._fileWritten(request, filepath)
-)
-d.addCallbacks(lambda d: finish(d), lambda failure: finish(failure))
-return server.NOT_DONE_YET
-class UploadManagerRadioCol(UploadManager):
-NAME = "song"
-def _getFileName(self, request):
-extension = os.path.splitext(request.args["filename"][0])[1]
-return "%s%s" % (
-str(uuid.uuid4()),
-extension,
-)  # XXX: chromium doesn't seem to play song without the .ogg extension, even
-#      with audio/ogg mime-type
-def _fileWritten(self, request, filepath):
-"""Called once the file is actually written on disk
-@param request: HTTP request object
-@param filepath: full filepath on the server
-@return: a tuple with the name of the async bridge method
-to be called followed by its arguments.
-"""
-profile = session_iface.ISATSession(request.getSession()).profile
-return ("radiocolSongAdded", request.args["referee"][0], filepath, profile)
-class UploadManagerAvatar(UploadManager):
-NAME = "avatar_path"
-def _getFileName(self, request):
-return str(uuid.uuid4())
-def _fileWritten(self, request, filepath):
-"""Called once the file is actually written on disk
-@param request: HTTP request object
-@param filepath: full filepath on the server
-@return: a tuple with the name of the async bridge method
-to be called followed by its arguments.
-"""
-profile = session_iface.ISATSession(request.getSession()).profile
-return ("setAvatar", filepath, profile)
 class Libervia(service.Service):
 debug = defer.Deferred.debug  # True if twistd/Libervia is launched in debug mode
 def __init__(self, options):
 self.options = options
 if self.options["base_url_ext"]:
 self.base_url_ext = self.options.pop("base_url_ext")
 if self.base_url_ext[-1] != "/":
 self.base_url_ext += "/"
-self.base_url_ext_data = urlparse.urlsplit(self.base_url_ext)
+self.base_url_ext_data = urllib.parse.urlsplit(self.base_url_ext)
 else:
 self.base_url_ext = None
 # we split empty string anyway so we can do things like
 # scheme = self.base_url_ext_data.scheme or 'https'
-self.base_url_ext_data = urlparse.urlsplit("")
+self.base_url_ext_data = urllib.parse.urlsplit("")
 if not self.options["port_https_ext"]:
 self.options["port_https_ext"] = self.options["port_https"]
-if self.options["data_dir"] == DATA_DIR_DEFAULT:
-coerceDataDir(
-self.options["data_dir"]
-)  # this is not done when using the default value
-self.html_dir = os.path.join(self.options["data_dir"], C.HTML_DIR)
-self.themes_dir = os.path.join(self.options["data_dir"], C.THEMES_DIR)
 self._cleanup = []
-self.signal_handler = SignalHandler(self)
 self.sessions = {}  # key = session value = user
 self.prof_connected = set()  # Profiles connected
 self.ns_map = {}  # map of short name to namespaces
 ## bridge ##
 """
 section = site_root_res.site_name.lower().strip()
 value = config.getConfig(self.main_conf, section, key, default=default)
 if value_type is not None:
-if value_type == u'path':
+if value_type == 'path':
 v_filter = lambda v: os.path.abspath(os.path.expanduser(v))
 else:
-raise ValueError(u"unknown value type {value_type}".format(
+raise ValueError("unknown value type {value_type}".format(
 value_type = value_type))
 if isinstance(value, list):
 value = [v_filter(v) for v in value]
 elif isinstance(value, dict):
-value = {k:v_filter(v) for k,v in value.items()}
+value = {k:v_filter(v) for k,v in list(value.items())}
 elif value is not None:
 value = v_filter(v)
 return value
 def _namespacesGetCb(self, ns_map):
 self.ns_map = ns_map
 def _namespacesGetEb(self, failure_):
-log.error(_(u"Can't get namespaces map: {msg}").format(msg=failure_))
+log.error(_("Can't get namespaces map: {msg}").format(msg=failure_))
 @template.contextfilter
 def _front_url_filter(self, ctx, relative_url):
-template_data = ctx[u'template_data']
+template_data = ctx['template_data']
-return os.path.join(u'/', C.TPL_RESOURCE, template_data.site or u'sat',
+return os.path.join('/', C.TPL_RESOURCE, template_data.site or 'sat',
 C.TEMPLATE_TPL_DIR, template_data.theme, relative_url)
 def _moveFirstLevelToDict(self, options, key, keys_to_keep):
 """Read a config option and put value at first level into u'' dict
 try:
 conf = options[key]
 except KeyError:
 return
 if not isinstance(conf, dict):
-options[key] = {u'': conf}
+options[key] = {'': conf}
 return
-default_dict = conf.get(u'', {})
+default_dict = conf.get('', {})
 to_delete = []
-for key, value in conf.iteritems():
+for key, value in conf.items():
 if key not in keys_to_keep:
 default_dict[key] = value
 to_delete.append(key)
 for key in to_delete:
 del conf[key]
 if default_dict:
-conf[u''] = default_dict
+conf[''] = default_dict
 @defer.inlineCallbacks
 def backendReady(self, __):
-if self.options[u'dev_mode']:
+if self.options['dev_mode']:
-log.info(_(u"Developer mode activated"))
+log.info(_("Developer mode activated"))
 self.media_dir = self.bridge.getConfig("", "media_dir")
 self.local_dir = self.bridge.getConfig("", "local_dir")
 self.cache_root_dir = os.path.join(self.local_dir, C.CACHE_DIR)
 self.renderer = template.Renderer(self, self._front_url_filter)
-sites_names = self.renderer.sites_paths.keys()
+sites_names = list(self.renderer.sites_paths.keys())
 self._moveFirstLevelToDict(self.options, "url_redirections_dict", sites_names)
 self._moveFirstLevelToDict(self.options, "menu_json", sites_names)
-if not u'' in self.options["menu_json"]:
+if not '' in self.options["menu_json"]:
-self.options["menu_json"][u''] = C.DEFAULT_MENU
+self.options["menu_json"][''] = C.DEFAULT_MENU
 # we create virtual hosts and import Libervia pages into them
 self.vhost_root = vhost.NameVirtualHost()
 default_site_path = os.path.abspath(os.path.dirname(libervia.__file__))
 # self.sat_root is official Libervia site
+root_path = os.path.join(default_site_path, C.TEMPLATE_STATIC_DIR)
 self.sat_root = default_root = LiberviaRootResource(
-host=self, host_name=u'', site_name=u'', site_path=default_site_path,
+host=self, host_name='', site_name='', site_path=default_site_path,
-path=self.html_dir)
+path=root_path)
 if self.options['dev_mode']:
 self.files_watcher.watchDir(
 default_site_path, auto_add=True, recursive=True,
 callback=LiberviaPage.onFileChange, site_root=self.sat_root,
 site_path=default_site_path)
 yield tasks_manager.runTasks()
 LiberviaPage.importPages(self, self.sat_root)
 # FIXME: handle _setMenu in a more generic way, taking care of external sites
 self.sat_root._setMenu(self.options["menu_json"])
 self.vhost_root.default = default_root
-existing_vhosts = {u'': default_root}
+existing_vhosts = {b'': default_root}
-for host_name, site_name in self.options["vhosts_dict"].iteritems():
+for host_name, site_name in self.options["vhosts_dict"].items():
+encoded_site_name = site_name.encode('utf-8')
 try:
 site_path = self.renderer.sites_paths[site_name]
 except KeyError:
 log.warning(_(
-u"host {host_name} link to non existing site {site_name}, ignoring "
+"host {host_name} link to non existing site {site_name}, ignoring "
-u"it").format(host_name=host_name, site_name=site_name))
+"it").format(host_name=host_name, site_name=site_name))
 continue
-if site_name in existing_vhosts:
+if encoded_site_name in existing_vhosts:
 # we have an alias host, we re-use existing resource
-res = existing_vhosts[site_name]
+res = existing_vhosts[encoded_site_name]
 else:
 # for root path we first check if there is a global static dir
 # if not, we use default template's static dic
 root_path = os.path.join(site_path, C.TEMPLATE_STATIC_DIR)
 if not os.path.isdir(root_path):
 host_name=host_name,
 site_name=site_name,
 site_path=site_path,
 path=root_path)
-existing_vhosts[site_name] = res
+existing_vhosts[encoded_site_name] = res
 if self.options['dev_mode']:
 self.files_watcher.watchDir(
 site_path, auto_add=True, recursive=True,
 callback=LiberviaPage.onFileChange, site_root=res,
 res._setMenu(self.options["menu_json"])
 self.vhost_root.addHost(host_name.encode('utf-8'), res)
 templates_res = web_resource.Resource()
-self.putChildAll(C.TPL_RESOURCE, templates_res)
+self.putChildAll(C.TPL_RESOURCE.encode('utf-8'), templates_res)
-for site_name, site_path in self.renderer.sites_paths.iteritems():
+for site_name, site_path in self.renderer.sites_paths.items():
-templates_res.putChild(site_name or u'sat', ProtectedFile(site_path))
+templates_res.putChild(site_name.encode('utf-8') or b'sat',
+ProtectedFile(site_path))
-_register = Register(self)
-_upload_radiocol = UploadManagerRadioCol(self)
-_upload_avatar = UploadManagerAvatar(self)
 d = self.bridgeCall("namespacesGet")
 d.addCallback(self._namespacesGetCb)
 d.addErrback(self._namespacesGetEb)
-self.signal_handler.plugRegister(_register)
-self.bridge.register_signal("connected", self.signal_handler.connected)
-self.bridge.register_signal("disconnected", self.signal_handler.disconnected)
-# core
-for signal_name in [
-"presenceUpdate",
-"messageNew",
-"subscribe",
-"contactDeleted",
-"newContact",
-"entityDataUpdated",
-"paramUpdate",
-]:
-self.bridge.register_signal(
-signal_name, self.signal_handler.getGenericCb(signal_name)
-)
-# XXX: actionNew is handled separately because the handler must manage
-#      security_limit
-self.bridge.register_signal("actionNew", self.signal_handler.actionNewHandler)
-# plugins
-for signal_name in [
-"psEvent",
-"mucRoomJoined",
-"tarotGameStarted",
-"tarotGameNew",
-"tarotGameChooseContrat",
-"tarotGameShowCards",
-"tarotGameInvalidCards",
-"tarotGameCardsPlayed",
-"tarotGameYourTurn",
-"tarotGameScore",
-"tarotGamePlayers",
-"radiocolStarted",
-"radiocolPreload",
-"radiocolPlay",
-"radiocolNoUpload",
-"radiocolUploadOk",
-"radiocolSongRejected",
-"radiocolPlayers",
-"mucRoomLeft",
-"mucRoomUserChangedNick",
-"chatStateReceived",
-]:
-self.bridge.register_signal(
-signal_name, self.signal_handler.getGenericCb(signal_name), "plugin"
-)
-# JSON APIs
-self.putChildSAT("json_signal_api", self.signal_handler)
-self.putChildSAT("json_api", MethodHandler(self))
-self.putChildSAT("register_api", _register)
-# files upload
-self.putChildSAT("upload_radiocol", _upload_radiocol)
-self.putChildSAT("upload_avatar", _upload_avatar)
-# static pages
-# FIXME: legacy blog must be removed entirely in 0.8
-try:
-micro_blog = MicroBlog(self)
-except Exception as e:
-log.warning(u"Can't load legacy microblog, ignoring it: {reason}".format(
-reason=e))
-else:
-self.putChildSAT("blog_legacy", micro_blog)
-self.putChildSAT(C.THEMES_URL, ProtectedFile(self.themes_dir))
 # websocket
 if self.options["connection_type"] in ("https", "both"):
 wss = websockets.LiberviaPageWSProtocol.getResource(self, secure=True)
-self.putChildAll("wss", wss)
+self.putChildAll(b'wss', wss)
 if self.options["connection_type"] in ("http", "both"):
 ws = websockets.LiberviaPageWSProtocol.getResource(self, secure=False)
-self.putChildAll("ws", ws)
+self.putChildAll(b'ws', ws)
 ## following signal is needed for cache handling in Libervia pages
 self.bridge.register_signal(
 "psEventRaw", partial(LiberviaPage.onNodeEvent, self), "plugin"
 )
 "progressError", partial(ProgressHandler._signal, "error")
 )
 # media dirs
 # FIXME: get rid of dirname and "/" in C.XXX_DIR
-self.putChildAll(os.path.dirname(C.MEDIA_DIR), ProtectedFile(self.media_dir))
+self.putChildAll(os.path.dirname(C.MEDIA_DIR).encode('utf-8'),
+ProtectedFile(self.media_dir))
 self.cache_resource = web_resource.NoResource()
-self.putChildAll(C.CACHE_DIR, self.cache_resource)
+self.putChildAll(C.CACHE_DIR.encode('utf-8'), self.cache_resource)
-# special
-self.putChildSAT(
-"radiocol",
-ProtectedFile(_upload_radiocol.getTmpDir(), defaultType="audio/ogg"),
-)  # FIXME: We cheat for PoC because we know we are on the same host, so we use
-#        directly upload dir
-# pyjamas tests, redirected only for dev versions
-if self.version[-1] == "D":
-self.putChildSAT("test", web_util.Redirect("/libervia_test.html"))
 # redirections
 for root in self.roots:
 root._initRedirections(self.options)
 )
 self.site = server.Site(wrapped)
 self.site.sessionFactory = LiberviaSession
 def initEb(self, failure):
-log.error(_(u"Init error: {msg}").format(msg=failure))
+log.error(_("Init error: {msg}").format(msg=failure))
 reactor.stop()
 return failure
 def _bridgeCb(self):
 self.bridge.getReady(
 self.initialised.addCallback(self.backendReady)
 self.initialised.addErrback(self.initEb)
 def _bridgeEb(self, failure_):
 if isinstance(failure_, BridgeExceptionNoService):
-print(u"Can't connect to SàT backend, are you sure it's launched ?")
+print("Can't connect to SàT backend, are you sure it's launched ?")
 else:
-log.error(u"Can't connect to bridge: {}".format(failure))
+log.error("Can't connect to bridge: {}".format(failure))
 sys.exit(1)
 @property
 def version(self):
 """Return the short version of Libervia"""
 if version[-1] == "D":
 # we are in debug version, we add extra data
 try:
 return self._version_cache
 except AttributeError:
-self._version_cache = u"{} ({})".format(
+self._version_cache = "{} ({})".format(
 version, utils.getRepositoryData(libervia)
 )
 return self._version_cache
 else:
 return version
 register_with_ext_jid = self.waiting_profiles.getRegisterWithExtJid(profile)
 self.waiting_profiles.purgeRequest(profile)
 session = request.getSession()
 sat_session = session_iface.ISATSession(session)
 if sat_session.profile:
-log.error(_(u"/!\\ Session has already a profile, this should NEVER happen!"))
+log.error(_("/!\\ Session has already a profile, this should NEVER happen!"))
 raise failure.Failure(exceptions.ConflictError("Already active"))
 sat_session.profile = profile
 self.prof_connected.add(profile)
 cache_dir = os.path.join(
-self.cache_root_dir, u"profiles", regex.pathEscape(profile)
+self.cache_root_dir, "profiles", regex.pathEscape(profile)
 )
 # FIXME: would be better to have a global /cache URL which redirect to
 #        profile's cache directory, without uuid
-self.cache_resource.putChild(sat_session.uuid, ProtectedFile(cache_dir))
+self.cache_resource.putChild(sat_session.uuid.encode('utf-8'),
+ProtectedFile(cache_dir))
 log.debug(
-_(u"profile cache resource added from {uuid} to {path}").format(
+_("profile cache resource added from {uuid} to {path}").format(
 uuid=sat_session.uuid, path=cache_dir
 )
 )
 def onExpire():
-log.info(u"Session expired (profile={profile})".format(profile=profile))
+log.info("Session expired (profile={profile})".format(profile=profile))
-self.cache_resource.delEntity(sat_session.uuid)
+self.cache_resource.delEntity(sat_session.uuid.encode('utf-8'))
 log.debug(
-_(u"profile cache resource {uuid} deleted").format(uuid=sat_session.uuid)
+_("profile cache resource {uuid} deleted").format(uuid=sat_session.uuid)
 )
-try:
-# We purge the queue
-del self.signal_handler.queue[profile]
-except KeyError:
-pass
 # and now we disconnect the profile
 self.bridgeCall("disconnect", profile)
 session.notifyOnExpire(onExpire)
 if (
 login_jid is not None and login_jid.user
 ):  # try to create a new sat profile using the XMPP credentials
 if not self.options["allow_registration"]:
 log.warning(
-u"Trying to register JID account while registration is not "
+"Trying to register JID account while registration is not "
-u"allowed")
+"allowed")
 raise failure.Failure(
 exceptions.DataError(
-u"JID login while registration is not allowed"
+"JID login while registration is not allowed"
 )
 )
 profile = login  # FIXME: what if there is a resource?
 connect_method = "asyncConnectWithXMPPCredentials"
 register_with_ext_jid = True
 if sat_session.profile:
 # yes, there is
 if sat_session.profile != profile:
 # it's a different profile, we need to disconnect it
 log.warning(_(
-u"{new_profile} requested login, but {old_profile} was already "
+"{new_profile} requested login, but {old_profile} was already "
-u"connected, disconnecting {old_profile}").format(
+"connected, disconnecting {old_profile}").format(
 old_profile=sat_session.profile, new_profile=profile))
 self.purgeSession(request)
 if self.waiting_profiles.getRequest(profile):
 #  FIXME: check if and when this can happen
 connected = yield self.bridgeCall(connect_method, profile, password)
 except Exception as failure_:
 fault = getattr(failure_, 'classname', None)
 self.waiting_profiles.purgeRequest(profile)
 if fault in ("PasswordError", "ProfileUnknownError"):
-log.info(u"Profile {profile} doesn't exist or the submitted password is "
+log.info("Profile {profile} doesn't exist or the submitted password is "
-u"wrong".format( profile=profile))
+"wrong".format( profile=profile))
 raise failure.Failure(ValueError(C.PROFILE_AUTH_ERROR))
 elif fault == "SASLAuthError":
-log.info(u"The XMPP password of profile {profile} is wrong"
+log.info("The XMPP password of profile {profile} is wrong"
 .format(profile=profile))
 raise failure.Failure(ValueError(C.XMPP_AUTH_ERROR))
 elif fault == "NoReply":
-log.info(_(u"Did not receive a reply (the timeout expired or the "
+log.info(_("Did not receive a reply (the timeout expired or the "
-u"connection is broken)"))
+"connection is broken)"))
 raise exceptions.TimeOutError
 elif fault is None:
-log.info(_(u"Unexepected failure: {failure_}").format(failure_=failure))
+log.info(_("Unexepected failure: {failure_}").format(failure_=failure))
 raise failure_
 else:
-log.error(u'Unmanaged fault class "{fault}" in errback for the '
+log.error('Unmanaged fault class "{fault}" in errback for the '
-u'connection of profile {profile}'.format(
+'connection of profile {profile}'.format(
 fault=fault, profile=profile))
 raise failure.Failure(exceptions.InternalError(fault))
 if connected:
 #  profile is already connected in backend
 # yes, session is active
 if sat_session.profile != profile:
 # existing session should have been ended above
 # so this line should never be reached
 log.error(_(
-u"session profile [{session_profile}] differs from login "
+"session profile [{session_profile}] differs from login "
-u"profile [{profile}], this should not happen!")
+"profile [{profile}], this should not happen!")
 .format(session_profile=sat_session.profile, profile=profile))
 raise exceptions.InternalError("profile mismatch")
 defer.returnValue(C.SESSION_ACTIVE)
 log.info(
 _(
-u"profile {profile} was already connected in backend".format(
+"profile {profile} was already connected in backend".format(
 profile=profile
 )
 )
 )
 #  no, we have to create it
 - C.INTERNAL_ERROR or any unmanaged fault string
 @raise PermissionError: registration is now allowed in server configuration
 """
 if not self.options["allow_registration"]:
 log.warning(
-_(u"Registration received while it is not allowed, hack attempt?")
+_("Registration received while it is not allowed, hack attempt?")
 )
 raise failure.Failure(
-exceptions.PermissionError(u"Registration is not allowed on this server")
+exceptions.PermissionError("Registration is not allowed on this server")
 )
 if (
 not re.match(C.REG_LOGIN_RE, login)
 or not re.match(C.REG_EMAIL_RE, email, re.IGNORECASE)
 return C.INVALID_CERTIFICATE
 elif status == "InternalError":
 return C.INTERNAL_ERROR
 else:
 log.error(
-_(u"Unknown registering error status: {status}\n{traceback}").format(
+_("Unknown registering error status: {status}\n{traceback}").format(
 status=status, traceback=failure_.value.message
 )
 )
 return status
 def startService(self):
 """Connect the profile for Libervia and start the HTTP(S) server(s)"""
 def eb(e):
-log.error(_(u"Connection failed: %s") % e)
+log.error(_("Connection failed: %s") % e)
 self.stop()
 def initOk(__):
 try:
 connected = self.bridge.isConnected(C.SERVICE_PROFILE)
 except Exception as e:
 # we don't want the traceback
-msg = [l for l in unicode(e).split("\n") if l][-1]
+msg = [l for l in str(e).split("\n") if l][-1]
 log.error(
-u"Can't check service profile ({profile}), are you sure it exists ?"
+"Can't check service profile ({profile}), are you sure it exists ?"
-u"\n{error}".format(profile=C.SERVICE_PROFILE, error=msg))
+"\n{error}".format(profile=C.SERVICE_PROFILE, error=msg))
 self.stop()
 return
 if not connected:
 self.bridge.connect(
 C.SERVICE_PROFILE,
 ## URLs ##
 def putChildSAT(self, path, resource):
 """Add a child to the sat resource"""
+if not isinstance(path, bytes):
+raise ValueError("path must be specified in bytes")
 self.sat_root.putChild(path, resource)
 def putChildAll(self, path, resource):
 """Add a child to all vhost root resources"""
+if not isinstance(path, bytes):
+raise ValueError("path must be specified in bytes")
 # we wrap before calling putChild, to avoid having useless multiple instances
 # of the resource
 # FIXME: check that no information is leaked (c.f. https://twistedmatrix.com/documents/current/web/howto/using-twistedweb.html#request-encoders)
 wrapped_res = web_resource.EncodingResourceWrapper(
 resource, [server.GzipEncoderFactory()])
 build_path_elts = [
 config.getConfig(self.main_conf, "", "local_dir"),
 C.CACHE_DIR,
 C.LIBERVIA_CACHE,
 regex.pathEscape(site_name)]
-build_path = u"/".join(build_path_elts)
+build_path = "/".join(build_path_elts)
 return os.path.abspath(os.path.expanduser(build_path))
 def getExtBaseURLData(self, request):
 """Retrieve external base URL Data
 except TypeError:
 # no x-forwarded-server found, we use proxy_host
 proxy_netloc = proxy_host
 else:
 # if the proxy host has a port, we use it with server name
-proxy_port = urlparse.urlsplit(u"//{}".format(proxy_host)).port
+proxy_port = urllib.parse.urlsplit("//{}".format(proxy_host)).port
 proxy_netloc = (
-u"{}:{}".format(proxy_server, proxy_port)
+"{}:{}".format(proxy_server, proxy_port)
 if proxy_port is not None
 else proxy_server
 )
 proxy_netloc = proxy_netloc.decode("utf-8")
 try:
 else:
 proxy_scheme, proxy_netloc = None, None
 else:
 proxy_scheme, proxy_netloc = None, None
-return urlparse.SplitResult(
+return urllib.parse.SplitResult(
 ext_data.scheme or proxy_scheme or url_path.scheme.decode("utf-8"),
 ext_data.netloc or proxy_netloc or url_path.netloc.decode("utf-8"),
-ext_data.path or u"/",
+ext_data.path or "/",
 "",
 "",
 )
 def getExtBaseURL(self, request, path="", query="", fragment="", scheme=None):
 @param fragment(unicode): same as for urlsplit.urlsplit
 @param scheme(unicode, None): if not None, will override scheme from base URL
 @return (unicode): external URL
 """
 split_result = self.getExtBaseURLData(request)
-return urlparse.urlunsplit(
+return urllib.parse.urlunsplit(
 (
-split_result.scheme.decode("utf-8") if scheme is None else scheme,
+split_result.scheme if scheme is None else scheme,
-split_result.netloc.decode("utf-8"),
+split_result.netloc,
 os.path.join(split_result.path, path),
 query,
 fragment,
 )
 )
 @param vhost_root(web_resource.Resource): root of this virtual host
 @param url(unicode): url to check
 @return (unicode): possibly redirected URL which should link to the same location
 """
 inv_redirections = vhost_root.inv_redirections
-url_parts = url.strip(u"/").split(u"/")
+url_parts = url.strip("/").split("/")
-for idx in xrange(len(url), 0, -1):
+for idx in range(len(url), 0, -1):
-test_url = u"/" + u"/".join(url_parts[:idx])
+test_url = "/" + "/".join(url_parts[:idx])
 if test_url in inv_redirections:
 rem_url = url_parts[idx:]
 return os.path.join(
-u"/", u"/".join([inv_redirections[test_url]] + rem_url)
+"/", "/".join([inv_redirections[test_url]] + rem_url)
 )
 return url
 ## Sessions ##
 def purgeSession(self, request):
 """helper method to purge a session during request handling"""
 session = request.session
 if session is not None:
-log.debug(_(u"session purge"))
+log.debug(_("session purge"))
 session.expire()
 # FIXME: not clean but it seems that it's the best way to reset
 #        session during request handling
 request._secureSession = request._insecureSession = None
 @param node(unicode): pubsub node
 @return (unicode): affiliation
 """
 sat_session = self.getSessionData(request, session_iface.ISATSession)
 if sat_session.profile is None:
-raise exceptions.InternalError(u"profile must be set to use this method")
+raise exceptions.InternalError("profile must be set to use this method")
 affiliation = sat_session.getAffiliation(service, node)
 if affiliation is not None:
 defer.returnValue(affiliation)
 else:
 try:
 log.warning(
 "Can't retrieve affiliation for {service}/{node}: {reason}".format(
 service=service, node=node, reason=e
 )
 )
-affiliation = u""
+affiliation = ""
 else:
 try:
 affiliation = affiliations[node]
 except KeyError:
-affiliation = u""
+affiliation = ""
 sat_session.setAffiliation(service, node, affiliation)
 defer.returnValue(affiliation)
 ## Websocket (dynamic pages) ##
 def getWebsocketURL(self, request):
 base_url_split = self.getExtBaseURLData(request)
 if base_url_split.scheme.endswith("s"):
-scheme = u"wss"
+scheme = "wss"
 else:
-scheme = u"ws"
+scheme = "ws"
 return self.getExtBaseURL(request, path=scheme, scheme=scheme)
 def registerWSToken(self, token, page, request):
 # we make a shallow copy of request to avoid losing request.channel when
 ## Various utils ##
 def getHTTPDate(self, timestamp=None):
 now = time.gmtime(timestamp)
-fmt_date = u"{day_name}, %d {month_name} %Y %H:%M:%S GMT".format(
+fmt_date = "{day_name}, %d {month_name} %Y %H:%M:%S GMT".format(
 day_name=C.HTTP_DAYS[now.tm_wday], month_name=C.HTTP_MONTH[now.tm_mon - 1]
 )
 return time.strftime(fmt_date, now)
 ## TLS related methods ##
 """Check options coherence if TLS is activated, and update missing values
 Must be called only if TLS is activated
 """
 if not self.options["tls_certificate"]:
-log.error(u"a TLS certificate is needed to activate HTTPS connection")
+log.error("a TLS certificate is needed to activate HTTPS connection")
 self.quit(1)
 if not self.options["tls_private_key"]:
 self.options["tls_private_key"] = self.options["tls_certificate"]
 if not self.options["tls_private_key"]:
 OpenSSL.crypto.FILETYPE_PEM, "".join(buf)
 )
 )
 buf = []
 elif not line:
-log.debug(u"{} certificate(s) found".format(len(certificates)))
+log.debug("{} certificate(s) found".format(len(certificates)))
 return certificates
 def _loadPKey(self, f):
 """Read a private key from a .pem file
 return OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM, f.read())
 def _getTLSContextFactory(self):
 """Load TLS certificate and build the context factory needed for listenSSL"""
 if ssl is None:
-raise ImportError(u"Python module pyOpenSSL is not installed!")
+raise ImportError("Python module pyOpenSSL is not installed!")
 cert_options = {}
 for name, option, method in [
 ("privateKey", "tls_private_key", self._loadPKey),
 ]:
 path = self.options[option]
 if not path:
 assert option == "tls_chain"
 continue
-log.debug(u"loading {option} from {path}".format(option=option, path=path))
+log.debug("loading {option} from {path}".format(option=option, path=path))
 try:
 with open(path) as f:
 cert_options[name] = method(f)
 except IOError as e:
 log.error(
-u"Error while reading file {path} for option {option}: {error}".format(
+"Error while reading file {path} for option {option}: {error}".format(
 path=path, option=option, error=e
 )
 )
 self.quit(2)
 except OpenSSL.crypto.Error:
 log.error(
-u"Error while parsing file {path} for option {option}, are you sure "
+"Error while parsing file {path} for option {option}, are you sure "
-u"it is a valid .pem file?".format( path=path, option=option))
+"it is a valid .pem file?".format( path=path, option=option))
 if (
 option == "tls_private_key"
 and self.options["tls_certificate"] == path
 ):
 log.error(
-u"You are using the same file for private key and public "
+"You are using the same file for private key and public "
-u"certificate, make sure that both a in {path} or use "
+"certificate, make sure that both a in {path} or use "
-u"--tls_private_key option".format(path=path))
+"--tls_private_key option".format(path=path))
 self.quit(2)
 return ssl.CertificateOptions(**cert_options)
 ## service management ##
 @raise IOError: the certificate file doesn't exist
 @raise OpenSSL.crypto.Error: the certificate file is invalid
 """
 # now that we have service profile connected, we add resource for its cache
 service_path = regex.pathEscape(C.SERVICE_PROFILE)
-cache_dir = os.path.join(self.cache_root_dir, u"profiles", service_path)
+cache_dir = os.path.join(self.cache_root_dir, "profiles", service_path)
-self.cache_resource.putChild(service_path, ProtectedFile(cache_dir))
+self.cache_resource.putChild(service_path.encode('utf-8'),
-self.service_cache_url = u"/" + os.path.join(C.CACHE_DIR, service_path)
+ProtectedFile(cache_dir))
+self.service_cache_url = "/" + os.path.join(C.CACHE_DIR, service_path)
 session_iface.SATSession.service_cache_url = self.service_cache_url
 if self.options["connection_type"] in ("https", "both"):
 self._TLSOptionsCheck()
 context_factory = self._getTLSContextFactory()
 for callback, args, kwargs in self._cleanup:
 callback(*args, **kwargs)
 try:
 yield self.bridgeCall("disconnect", C.SERVICE_PROFILE)
 except Exception:
-log.warning(u"Can't disconnect service profile")
+log.warning("Can't disconnect service profile")
 def run(self):
 reactor.run()
 def stop(self):

Mercurial > libervia-web

comparison libervia/server/server.py @ 1216:b2d067339de3