view sat_frontends/jp/ @ 3028:ab2696e34d29

Python 3 port: /!\ this is a huge commit /!\ starting from this commit, SàT is needs Python 3.6+ /!\ SàT maybe be instable or some feature may not work anymore, this will improve with time This patch port backend, bridge and frontends to Python 3. Roughly this has been done this way: - 2to3 tools has been applied (with python 3.7) - all references to python2 have been replaced with python3 (notably shebangs) - fixed files not handled by 2to3 (notably the shell script) - several manual fixes - fixed issues reported by Python 3 that where not handled in Python 2 - replaced "async" with "async_" when needed (it's a reserved word from Python 3.7) - replaced zope's "implements" with @implementer decorator - temporary hack to handle data pickled in database, as str or bytes may be returned, to be checked later - fixed hash comparison for password - removed some code which is not needed anymore with Python 3 - deactivated some code which needs to be checked (notably certificate validation) - tested with jp, fixed reported issues until some basic commands worked - ported Primitivus (after porting dependencies like urwid satext) - more manual fixes
author Goffi <>
date Tue, 13 Aug 2019 19:08:41 +0200
parents 003b8b4b56a7
children fee60f17ebac
line wrap: on
line source

#!/usr/bin/env python2
# -*- coding: utf-8 -*-

# jp: a SAT command line tool
# Copyright (C) 2009-2019 Jérôme Poisson (

# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# GNU Affero General Public License for more details.

# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <>.

"""This module permits to manage profiles. It can list, create, delete
and retrieve information about a profile."""

from import Const as C
from sat.core.log import getLogger
log = getLogger(__name__)
from sat.core.i18n import _
from import base
from functools import partial

__commands__ = ["Profile"]

PROFILE_HELP = _('The name of the profile')

class ProfileConnect(base.CommandBase):
    """Dummy command to use profile_session parent, i.e. to be able to connect without doing anything else"""

    def __init__(self, host):
        # it's weird to have a command named "connect" with need_connect=False, but it can be handy to be able
        # to launch just the session, so some paradoxes don't hurt
        super(ProfileConnect, self).__init__(host, 'connect', need_connect=False, help=('connect a profile'))

    def add_parser_options(self):

class ProfileDisconnect(base.CommandBase):

    def __init__(self, host):
        super(ProfileDisconnect, self).__init__(host, 'disconnect', need_connect=False, help=('disconnect a profile'))
        self.need_loop = True

    def add_parser_options(self):

    def start(self):,

class ProfileDefault(base.CommandBase):
    def __init__(self, host):
        super(ProfileDefault, self).__init__(host, 'default', use_profile=False, help=('print default profile'))

    def add_parser_options(self):

    def start(self):

class ProfileDelete(base.CommandBase):
    def __init__(self, host):
        super(ProfileDelete, self).__init__(host, 'delete', use_profile=False, help=('delete a profile'))

    def add_parser_options(self):
        self.parser.add_argument('profile', type=str, help=PROFILE_HELP)
        self.parser.add_argument('-f', '--force', action='store_true', help=_('delete profile without confirmation'))

    def start(self):
        if self.args.profile not in
            log.error("Profile %s doesn't exist." % self.args.profile)
        if not self.args.force:
            message = "Are you sure to delete profile [{}] ?".format(self.args.profile)
            res = input("{} (y/N)? ".format(message))
            if res not in ("y", "Y"):
                self.disp(_("Profile deletion cancelled"))
      , callback=lambda __: None)

class ProfileInfo(base.CommandBase):
    def __init__(self, host):
        super(ProfileInfo, self).__init__(host, 'info', need_connect=False, help=_('get information about a profile'))
        self.need_loop = True
        self.to_show = [(_("jid"), "Connection", "JabberID"),]
        self.largest = max([len(item[0]) for item in self.to_show])

    def add_parser_options(self):
        self.parser.add_argument('--show-password', action='store_true', help=_('show the XMPP password IN CLEAR TEXT'))

    def showNextValue(self, label=None, category=None, value=None):
        """Show next value from self.to_show and quit on last one"""
        if label is not None:
            print((("{label:<"+str(self.largest+2)+"}{value}").format(label=label+": ", value=value)))
            label, category, name = self.to_show.pop(0)
        except IndexError:
  , category,,
                                            callback=lambda value: self.showNextValue(label, category, value))

    def start(self):
        if self.args.show_password:
            self.to_show.append((_("XMPP password"), "Connection", "Password"))

class ProfileList(base.CommandBase):
    def __init__(self, host):
        super(ProfileList, self).__init__(host, 'list', use_profile=False, use_output='list', help=('list profiles'))

    def add_parser_options(self):
        group = self.parser.add_mutually_exclusive_group()
        group.add_argument('-c', '--clients', action='store_true', help=_('get clients profiles only'))
        group.add_argument('-C', '--components', action='store_true', help=('get components profiles only'))

    def start(self):
        if self.args.clients:
            clients, components = True, False
        elif self.args.components:
            clients, components = False, True
            clients, components = True, True
        self.output(, components))

class ProfileCreate(base.CommandBase):
    def __init__(self, host):
        super(ProfileCreate, self).__init__(host, 'create', use_profile=False, help=('create a new profile'))
        self.need_loop = True

    def add_parser_options(self):
        self.parser.add_argument('profile', type=str, help=_('the name of the profile'))
        self.parser.add_argument('-p', '--password', type=str, default='', help=_('the password of the profile'))
        self.parser.add_argument('-j', '--jid', type=str, help=_('the jid of the profile'))
        self.parser.add_argument('-x', '--xmpp-password', type=str, help=_('the password of the XMPP account (use profile password if not specified)'),
        self.parser.add_argument('-C', '--component', default='',
                                 help=_('set to component import name (entry point) if this is a component'))

    def _session_started(self, __):
        if self.args.jid:
  "JabberID", self.args.jid, "Connection", profile_key=self.args.profile)
        xmpp_pwd = self.args.password or self.args.xmpp_password
        if xmpp_pwd:
  "Password", xmpp_pwd, "Connection", profile_key=self.args.profile)

    def _profile_created(self):, self.args.profile, callback=self._session_started, errback=None)

    def start(self):
        """Create a new profile"""
        if self.args.profile in
            log.error("Profile %s already exists." % self.args.profile)
  , self.args.password, self.args.component,
                                                       msg=_("can't create profile: {}"),

class ProfileModify(base.CommandBase):
    def __init__(self, host):
        super(ProfileModify, self).__init__(host, 'modify', need_connect=False, help=_('modify an existing profile'))

    def add_parser_options(self):
        profile_pwd_group = self.parser.add_mutually_exclusive_group()
        profile_pwd_group.add_argument('-w', '--password', help=_('change the password of the profile'))
        profile_pwd_group.add_argument('--disable-password', action='store_true', help=_('disable profile password (dangerous!)'))
        self.parser.add_argument('-j', '--jid', help=_('the jid of the profile'))
        self.parser.add_argument('-x', '--xmpp-password', help=_('change the password of the XMPP account'),
        self.parser.add_argument('-D', '--default', action='store_true', help=_('set as default profile'))

    def start(self):
        if self.args.disable_password:
            self.args.password = ''
        if self.args.password is not None:
  "Password", self.args.password, "General",
        if self.args.jid is not None:
  "JabberID", self.args.jid, "Connection",
        if self.args.xmpp_password is not None:
  "Password", self.args.xmpp_password, "Connection",
        if self.args.default:

class Profile(base.CommandBase):
    subcommands = (ProfileConnect, ProfileDisconnect, ProfileCreate, ProfileDefault, ProfileDelete, ProfileInfo, ProfileList, ProfileModify)

    def __init__(self, host):
        super(Profile, self).__init__(host, 'profile', use_profile=False, help=_('profile commands'))