qubes-installer-qubes-os/anaconda/pyanaconda/keyboard.py

556 lines
20 KiB
Python
Raw Normal View History

#
# Copyright (C) 2012 Red Hat, Inc.
#
# This copyrighted material is made available to anyone wishing to use,
# modify, copy, or redistribute it subject to the terms and conditions of
# the GNU General Public License v.2, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY expressed or implied, including the implied warranties of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
# Public License for more details. You should have received a copy of the
# GNU General Public License along with this program; if not, write to the
# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the
# source code or documentation are not subject to the GNU General Public
# License and may only be used or replicated with the express permission of
# Red Hat, Inc.
#
# Red Hat Author(s): Martin Gracik <mgracik@redhat.com>
# Vratislav Podzimek <vpodzime@redhat.com>
#
"""
This module provides functions for dealing with keyboard layouts/keymaps in
Anaconda and the LocaledWrapper class with methods for setting, getting and
mutually converting X layouts and VConsole keymaps.
"""
import os
import re
import shutil
from pyanaconda import iutil
from pyanaconda import safe_dbus
from pyanaconda.constants import DEFAULT_VC_FONT, DEFAULT_KEYBOARD
from pyanaconda.flags import can_touch_runtime_system
from gi.repository import GLib
import logging
log = logging.getLogger("anaconda")
LOCALED_SERVICE = "org.freedesktop.locale1"
LOCALED_OBJECT_PATH = "/org/freedesktop/locale1"
LOCALED_IFACE = "org.freedesktop.locale1"
# should match and parse strings like 'cz' or 'cz (qwerty)' regardless of white
# space
LAYOUT_VARIANT_RE = re.compile(r'^\s*(\w+)\s*' # layout plus
r'(?:(?:\(\s*([-\w]+)\s*\))' # variant in parentheses
r'|(?:$))\s*') # or nothing
class KeyboardConfigError(Exception):
"""Exception class for keyboard configuration related problems"""
pass
class InvalidLayoutVariantSpec(Exception):
"""
Exception class for errors related to parsing layout and variant specification strings.
"""
pass
def parse_layout_variant(layout_variant_str):
"""
Parse layout and variant from the string that may look like 'layout' or
'layout (variant)'.
:param layout_variant_str: keyboard layout and variant string specification
:type layout_variant_str: str
:return: the (layout, variant) pair, where variant can be ""
:rtype: tuple
:raise InvalidLayoutVariantSpec: if the given string isn't a valid layout
and variant specification string
"""
match = LAYOUT_VARIANT_RE.match(layout_variant_str)
if not match:
msg = "'%s' is not a valid keyboard layout and variant specification" % layout_variant_str
raise InvalidLayoutVariantSpec(msg)
layout, variant = match.groups()
# groups may be (layout, None) if no variant was specified
return (layout, variant or "")
def join_layout_variant(layout, variant=""):
"""
Join layout and variant to form the commonly used 'layout (variant)'
or 'layout' (if variant is missing) format.
:type layout: string
:type variant: string
:return: 'layout (variant)' or 'layout' string
:rtype: string
"""
if variant:
return "%s (%s)" % (layout, variant)
else:
return layout
def normalize_layout_variant(layout_str):
"""
Normalize keyboard layout and variant specification given as a single
string. E.g. for a 'layout(variant) string missing the space between the
left parenthesis return 'layout (variant)' which is a proper layout and
variant specification we use.
:param layout_str: a string specifying keyboard layout and its variant
:type layout_str: string
"""
layout, variant = parse_layout_variant(layout_str)
return join_layout_variant(layout, variant)
def populate_missing_items(keyboard):
"""
Function that populates keyboard.vc_keymap and keyboard.x_layouts if they
are missing. By invoking LocaledWrapper's methods this function READS AND
WRITES CONFIGURATION FILES (but tries to keep their content unchanged).
:type keyboard: ksdata.keyboard object
"""
localed = LocaledWrapper()
if keyboard._keyboard and not (keyboard.vc_keymap or keyboard.x_layouts):
# we were given just a value in the old format, use it as a vc_keymap
keyboard.vc_keymap = keyboard._keyboard
if keyboard.x_layouts and not keyboard.vc_keymap:
keyboard.vc_keymap = localed.convert_layout(keyboard.x_layouts[0])
if not keyboard.vc_keymap:
keyboard.vc_keymap = DEFAULT_KEYBOARD
if not keyboard.x_layouts:
c_lay_var = localed.convert_keymap(keyboard.vc_keymap)
keyboard.x_layouts.append(c_lay_var)
def write_keyboard_config(keyboard, root, convert=True):
"""
Function that writes files with layouts configuration to
$root/etc/X11/xorg.conf.d/01-anaconda-layouts.conf and
$root/etc/vconsole.conf.
:param keyboard: ksdata.keyboard object
:param root: path to the root of the installed system
:param convert: whether to convert specified values to get the missing
ones
:param weight: weight (prefix) of the xorg.conf file written out
"""
if convert:
populate_missing_items(keyboard)
xconf_dir = "/etc/X11/xorg.conf.d"
xconf_file = "00-keyboard.conf"
xconf_file_path = os.path.normpath(xconf_dir + "/" + xconf_file)
vcconf_dir = os.path.normpath(root + "/etc")
vcconf_file = "vconsole.conf"
errors = []
try:
if not os.path.isdir(xconf_dir):
os.makedirs(xconf_dir)
except OSError:
errors.append("Cannot create directory xorg.conf.d")
if keyboard.x_layouts:
localed_wrapper = LocaledWrapper()
if root != "/":
# writing to a different root, we need to save these values, so that
# we can restore them when we have the file written out
layouts_variants = localed_wrapper.layouts_variants
options = localed_wrapper.options
# set systemd-localed's layouts, variants and switch options, which
# also generates a new conf file
localed_wrapper.set_layouts(keyboard.x_layouts,
keyboard.switch_options)
# make sure the right directory exists under the given root
rooted_xconf_dir = os.path.normpath(root + "/" + xconf_dir)
try:
if not os.path.isdir(rooted_xconf_dir):
os.makedirs(rooted_xconf_dir)
except OSError:
errors.append("Cannot create directory xorg.conf.d")
# copy the file to the chroot
try:
shutil.copy2(xconf_file_path,
os.path.normpath(root + "/" + xconf_file_path))
except IOError:
# The file may not exist (eg. text install) so don't raise
pass
# restore the original values
localed_wrapper.set_layouts(layouts_variants,
options)
else:
try:
# just let systemd-localed write out the conf file
localed_wrapper.set_layouts(keyboard.x_layouts,
keyboard.switch_options)
except InvalidLayoutVariantSpec as ilvs:
# some weird value appeared as a requested X layout
log.error("Failed to write out config file: %s", ilvs)
# try default
keyboard.x_layouts = [DEFAULT_KEYBOARD]
localed_wrapper.set_layouts(keyboard.x_layouts,
keyboard.switch_options)
if keyboard.vc_keymap:
try:
with open(os.path.join(vcconf_dir, vcconf_file), "w") as fobj:
fobj.write('KEYMAP="%s"\n' % keyboard.vc_keymap)
# systemd now defaults to a font that cannot display non-ascii
# characters, so we have to tell it to use a better one
fobj.write('FONT="%s"\n' % DEFAULT_VC_FONT)
except IOError:
errors.append("Cannot write vconsole configuration file")
if errors:
raise KeyboardConfigError("\n".join(errors))
def _try_to_load_keymap(keymap):
"""
Method that tries to load keymap and returns boolean indicating if it was
successfull or not. It can be used to test if given string is VConsole
keymap or not, but in case it is given valid keymap, IT REALLY LOADS IT!.
:type keymap: string
:raise KeyboardConfigError: if loadkeys command is not available
:return: True if given string was a valid keymap and thus was loaded,
False otherwise
"""
# BUG: systemd-localed should be able to tell us if we are trying to
# activate invalid keymap. Then we will be able to get rid of this
# fuction
ret = 0
try:
ret = iutil.execWithRedirect("loadkeys", [keymap])
except OSError as oserr:
msg = "'loadkeys' command not available (%s)" % oserr.strerror
raise KeyboardConfigError(msg)
return ret == 0
def activate_keyboard(keyboard):
"""
Try to setup VConsole keymap and X11 layouts as specified in kickstart.
:param keyboard: ksdata.keyboard object
:type keyboard: ksdata.keyboard object
"""
localed = LocaledWrapper()
c_lays_vars = []
c_keymap = ""
if keyboard._keyboard and not (keyboard.vc_keymap or keyboard.x_layouts):
# we were give only one value in old format of the keyboard command
# try to guess if we were given VConsole keymap or X11 layout
is_keymap = _try_to_load_keymap(keyboard._keyboard)
if is_keymap:
keyboard.vc_keymap = keyboard._keyboard
else:
keyboard.x_layouts.append(keyboard._keyboard)
if keyboard.vc_keymap:
valid_keymap = _try_to_load_keymap(keyboard.vc_keymap)
if not valid_keymap:
log.error("'%s' is not a valid VConsole keymap, not loading",
keyboard.vc_keymap)
keyboard.vc_keymap = None
else:
# activate VConsole keymap and get converted layout and variant
converted = localed.set_and_convert_keymap(keyboard.vc_keymap)
# localed may give us multiple comma-separated layouts+variants
c_lays_vars = converted.split(",")
if not keyboard.x_layouts:
if c_lays_vars:
# suggested by systemd-localed for a requested VConsole keymap
keyboard.x_layouts += c_lays_vars
elif keyboard.vc_keymap:
# nothing suggested by systemd-localed, but we may try to use the
# same string for both VConsole keymap and X layout (will fail
# safely if it doesn't work)
keyboard.x_layouts.append(keyboard.vc_keymap)
if keyboard.x_layouts:
c_keymap = localed.set_and_convert_layout(keyboard.x_layouts[0])
if not keyboard.vc_keymap:
keyboard.vc_keymap = c_keymap
# write out keyboard configuration for the X session
write_keyboard_config(keyboard, root="/", convert=False)
class LocaledWrapperError(KeyboardConfigError):
"""Exception class for reporting Localed-related problems"""
pass
class LocaledWrapper(object):
"""
Class wrapping systemd-localed daemon functionality. By using safe_dbus
module it tries to prevent failures related to threads and main loops.
"""
def __init__(self):
try:
self._connection = safe_dbus.get_new_system_connection()
except GLib.GError as e:
if can_touch_runtime_system("raise GLib.GError", touch_live=True):
raise
log.error("Failed to get safe_dbus connection: %s", e)
self._connection = None
@property
def keymap(self):
try:
keymap = safe_dbus.get_property_sync(LOCALED_SERVICE,
LOCALED_OBJECT_PATH,
LOCALED_IFACE,
"VConsoleKeymap",
self._connection)
except (safe_dbus.DBusPropertyError, safe_dbus.DBusCallError):
# no value for the property
log.error("Failed to get the value for the systemd-localed's "
"VConsoleKeymap property")
return ""
# returned GVariant is unpacked to a tuple with a single element
return keymap[0]
@property
def layouts_variants(self):
try:
layouts = safe_dbus.get_property_sync(LOCALED_SERVICE,
LOCALED_OBJECT_PATH,
LOCALED_IFACE,
"X11Layout",
self._connection)
except (safe_dbus.DBusPropertyError, safe_dbus.DBusCallError):
# no value for the property
log.error("Failed to get the value for the systemd-localed's "
"X11Layout property")
return [""]
try:
variants = safe_dbus.get_property_sync(LOCALED_SERVICE,
LOCALED_OBJECT_PATH,
LOCALED_IFACE,
"X11Variant",
self._connection)
except (safe_dbus.DBusPropertyError, safe_dbus.DBusCallError):
# no value for the property
log.error("Failed to get the value for the systemd-localed's "
"X11Variant property")
variants = []
# returned GVariants are unpacked to tuples with single elements
# containing comma-separated values
layouts = layouts[0].split(",")
if variants:
variants = variants[0].split(",")
# if there are more layouts than variants, empty strings should be appended
diff = len(layouts) - len(variants)
variants.extend(diff * [""])
return [join_layout_variant(layout, variant) for layout, variant in zip(layouts, variants)]
@property
def options(self):
try:
options = safe_dbus.get_property_sync(LOCALED_SERVICE,
LOCALED_OBJECT_PATH,
LOCALED_IFACE,
"X11Options",
self._connection)
except (safe_dbus.DBusPropertyError, safe_dbus.DBusCallError):
# no value for the property
log.error("Failed to get the value for the systemd-localed's "
"X11Options property")
return ""
# returned GVariant is unpacked to a tuple with a single element
return options[0]
def set_keymap(self, keymap, convert=False):
"""
Method that sets VConsole keymap via systemd-localed's DBus API.
:param keymap: VConsole keymap that should be set
:type keymap: str
:param convert: whether the keymap should be converted to a X11 layout
(see set_and_convert_keymap)
:type convert: bool
"""
# args: keymap, keymap_toggle, convert, user_interaction
# where convert indicates whether the keymap should be converted
# to X11 layout and user_interaction indicates whether PolicyKit
# should ask for credentials or not
args = GLib.Variant('(ssbb)', (keymap, "", convert, False))
try:
safe_dbus.call_sync(LOCALED_SERVICE, LOCALED_OBJECT_PATH, LOCALED_IFACE,
"SetVConsoleKeyboard", args, self._connection)
except safe_dbus.DBusCallError as e:
log.error("Failed to set keymap: %s", e)
def convert_keymap(self, keymap):
"""
Method that returns X11 layouts and variants that (systemd-localed
thinks) match given keymap best.
:param keymap: VConsole keymap
:type keymap: str
:return: X11 layouts and variants that (systemd-localed thinks) match
given keymap best
:rtype: str
"""
# hack around systemd's lack of functionality -- no function to just
# convert without changing keyboard configuration
orig_keymap = self.keymap
ret = self.set_and_convert_keymap(keymap)
self.set_keymap(orig_keymap)
return ret
def set_and_convert_keymap(self, keymap):
"""
Method that sets VConsole keymap and returns X11 layouts and
variants that (systemd-localed thinks) match given keymap best.
:return: string containing comma-separated "layout (variant)" or
"layout" layout specifications
:rtype: string
"""
self.set_keymap(keymap, convert=True)
return ",".join(self.layouts_variants)
def set_layouts(self, layouts_variants, options=None, convert=False):
"""
Method that sets X11 layouts and variants (for later X sessions) via
systemd-localed's DBus API.
:param layout_variant: list of 'layout (variant)' or 'layout'
specifications of layouts and variants
:type layout_variant: list of strings
:param options: list of X11 options that should be set
:type options: list of strings
:param convert: whether the keymap should be converted to a X11 layout
(see set_and_convert_keymap)
:type convert: bool
"""
layouts = []
variants = []
for layout_variant in (nonempty for nonempty in layouts_variants
if nonempty):
(layout, variant) = parse_layout_variant(layout_variant)
layouts.append(layout)
variants.append(variant)
layouts_str = ",".join(layouts)
variants_str = ",".join(variants)
if options:
opts_str = ",".join(options)
else:
opts_str = ""
# args: layout, model, variant, options, convert, user_interaction
# where convert indicates whether the keymap should be converted
# to X11 layout and user_interaction indicates whether PolicyKit
# should ask for credentials or not
args = GLib.Variant("(ssssbb)", (layouts_str, "", variants_str, opts_str,
convert, False))
try:
safe_dbus.call_sync(LOCALED_SERVICE, LOCALED_OBJECT_PATH, LOCALED_IFACE,
"SetX11Keyboard", args, self._connection)
except safe_dbus.DBusCallError as e:
log.error("Failed to set layouts: %s", e)
def set_and_convert_layout(self, layout_variant):
"""
Method that sets X11 layout and variant (for later X sessions)
and returns VConsole keymap that (systemd-localed thinks) matches
given layout and variant best.
:return: a keymap matching layout and variant best
:rtype: string
"""
self.set_layouts([layout_variant], convert=True)
return self.keymap
def convert_layout(self, layout_variant):
"""
Method that returns VConsole keymap that (systemd-localed thinks)
matches given layout and variant best.
:param layout_variant: 'layout (variant)' or 'layout' specification
:type layout_variant: str
:return: a keymap matching layout and variant best
:rtype: string
"""
# hack around systemd's lack of functionality -- no function to just
# convert without changing keyboard configuration
orig_layouts_variants = self.layouts_variants
ret = self.set_and_convert_layout(layout_variant)
self.set_layouts(orig_layouts_variants)
return ret