Red Hat Enterprise Linux 및 Fedora 설치 프로그램인 Anaconda 는 최신 버전에서 많은 개선 사항을 제공합니다. 이러한 개선 사항 중 하나는 향상된 사용자 지정 기능입니다. 이제 애드온을 작성하여 기본 설치 프로그램 기능을 확장하고 그래픽 사용자 인터페이스의 모양을 변경할 수 있습니다.

이 문서에서는 다음을 사용자 지정하는 방법을 설명합니다.

또한 이 문서는 Red Hat Enterprise Linux 8 및 Fedora 17 이상에만 적용됩니다.

이 섹션에서는 다음 방법에 대해 알아봅니다.

설치 프로그램을 사용자 지정하기 전에 Red Hat에서 제공하는 부팅 이미지를 다운로드하십시오. 계정 로그인 후 Red Hat 고객 포털에서 Red Hat Enterprise Linux 9 부팅 미디어를 받을 수 있습니다.

바이너리 DVD 및 부팅 ISO 다운로드에 대한 자세한 내용은 Red Hat Enterprise Linux 9 고급 RHEL 9 설치를 참조하십시오.

부팅 이미지의 콘텐츠를 추출하려면 다음 절차를 수행합니다.

부팅 메뉴는 설치 이미지를 사용하여 시스템을 부팅한 후 표시되는 메뉴입니다. 일반적으로 이 메뉴를 사용하면 Red Hat Enterprise Linux 설치,로컬 드라이브 부팅 또는 설치된 시스템 복구와 같은 옵션 중에서 선택할 수 있습니다. 부팅 메뉴를 사용자 지정하려면 다음을 수행할 수 있습니다.

설치 미디어는 ISOLINUX 및 GRUB2 부트 로더로 구성됩니다. ISOLINUX 부트 로더는 BIOS 펌웨어가 있는 시스템에서 사용되며 GRUB2 부트 로더는 UEFI 펌웨어가 있는 시스템에서 사용됩니다. 부트 로더는 AMD64 및 Intel 64 시스템의 모든 Red Hat 이미지에 있습니다.

특히 Kickstart에 부팅 메뉴 옵션을 사용자 지정할 수 있습니다. 설치가 시작되기 전에 설치 프로그램에 Kickstart 파일을 제공해야 합니다. 일반적으로 기존 부팅 옵션 중 하나를 수동으로 편집하여 inst.ks= boot 옵션을 추가하여 수행합니다. 미디어에서 부트 로더 구성 파일을 편집하는 경우 사전 구성된 항목 중 하나에 이 옵션을 추가할 수 있습니다.

ISOLINUX 부트 로더는 BIOS 펌웨어가 있는 시스템에서 사용됩니다.

그림 3.1. ISOLINUX 부팅 메뉴

부트 미디어의 isolinux/isolinux.cfg 구성 파일에는 색상 체계 및 메뉴 구조(entries 및 sub menu)를 설정하기 위한 지시문이 포함되어 있습니다.

Red Hat Enterprise Linux의 기본 메뉴 항목인 Red Hat Enterprise Linux의 기본 메뉴 항목인 Test this media & Install Red Hat Enterprise Linux 9 은 다음 블록에 정의되어 있습니다.

label check
  menu label Test this ^media & install Red Hat Enterprise Linux 9.
  menu default
  kernel vmlinuz
  append initrd=initrd.img inst.stage2=hd:LABEL=RHEL-9-BaseOS-x86_64 rd.live.check
quiet

다음과 같습니다.

메뉴 항목 정의에 포함되지 않은 다른 중요한 옵션은 다음과 같습니다.

GRUB2 부트 로더는 UEFI 펌웨어가 있는 시스템에서 사용됩니다.

부트 미디어의 EFI/BOOT/grub.cfg 구성 파일에는 모양 및 부팅 메뉴 기능을 제어하는 사전 구성된 메뉴 항목 목록과 기타 지시문이 포함되어 있습니다.

구성 파일에서 Red Hat Enterprise Linux의 기본 메뉴 항목(이 미디어 테스트 및 Red Hat Enterprise Linux 9 설치)은 다음 블록에 정의됩니다.

menuentry 'Test this media & install Red Hat Enterprise Linux 9' --class fedora --class gnu-linux --class gnu --class os {
    linuxefi /images/pxeboot/vmlinuz inst.stage2=hd:LABEL=RHEL-9-BaseOS-x86_64 rd.live.check quiet
    initrdefi /images/pxeboot/initrd.img
}

다음과 같습니다.

Red Hat Enterprise Linux 9 고급 RHEL 9 설치 수행.

+ 주목할 만한 옵션 중 하나는 inst.ks= 이므로 Kickstart 파일의 위치를 지정할 수 있습니다. Kickstart 파일을 부팅 ISO 이미지에 배치하고 inst.ks= 옵션을 사용하여 위치를 지정할 수 있습니다. 예를 들어, Kickstart.ks 파일을 이미지의 루트 디렉터리에 배치하고 inst.ks=hd:LABEL=RHEL-9-BaseOS-x86_64:/ kickstart.ks 를 사용할 수 있습니다.

+ dracut.cmdline(7) 도움말 페이지에 나열된 dracut 옵션을 사용할 수도 있습니다.

+

grub.cfg 구성 파일에 사용되는 다른 옵션은 다음과 같습니다.

그래픽 요소를 사용자 정의하려면 사용자 정의 가능한 요소를 사용자 지정 브랜드 자료로 수정하거나 교체하고 컨테이너 파일을 업데이트할 수 있습니다.

설치 프로그램의 사용자 지정 가능 그래픽 요소는 설치 프로그램 런타임 파일 시스템의 /usr/share/anaconda/pixmaps/ 디렉터리에 저장됩니다. 이 디렉터리에는 다음 사용자 지정 가능 파일이 포함되어 있습니다.

pixmaps
├─ anaconda-password-show-off.svg
├─ anaconda-password-show-on.svg
├─ right-arrow-icon.png
├─ sidebar-bg.png
├─ sidebar-logo.png
└─ topbar-bg.png

또한 /usr/share/anaconda/ 디렉터리에는 기본 UI 요소의 파일 이름 및 매개 변수 - 로고 및 상단 표시줄의 배경을 결정하는 anaconda-$k.css 라는 CSS 스타일시트가 포함되어 있습니다. 파일에는 요구 사항에 따라 사용자 지정할 수 있는 다음 내용이 있습니다.

/* theme colors/images */

@define-color product_bg_color @redhat;

/* logo and sidebar classes */

.logo-sidebar {
   background-image: url('/usr/share/anaconda/pixmaps/sidebar-bg.png');
   background-color: @product_bg_color;
   background-repeat: no-repeat;
}

/* Add a logo to the sidebar */

.logo {
   background-image: url('/usr/share/anaconda/pixmaps/sidebar-logo.png');
   background-position: 50% 20px;
   background-repeat: no-repeat;
   background-color: transparent;
}

/* This is a placeholder to be filled by a product-specific logo. */

.product-logo {
   background-image: none;
   background-color: transparent;
}

AnacondaSpokeWindow #nav-box {
   background-color: @product_bg_color;
   background-image: url('/usr/share/anaconda/pixmaps/topbar-bg.png');
   background-repeat: no-repeat;
   color: white;
}

CSS 파일의 가장 중요한 부분은 해상도에 따라 스케일링을 처리하는 방법입니다. PNG 이미지 배경은 확장되지 않으며 항상 실제 크기에 표시됩니다. 대신 배경은 투명한 배경을 가지고 있으며 스타일시트는 @define 색상 라인에서 일치하는 배경 색상을 정의합니다. 따라서 배경 이미지 "케이드"를 배경색 으로, 즉 이미지 확장 없이도 모든 해상도에서 배경 이미지가 작동합니다.

background-repeat 매개변수를 배경을 타일 타일로 변경하거나 설치하려는 모든 시스템에 동일한 표시 해상도가 있다고 확신하는 경우 전체 표시줄을 채우는 배경 이미지를 사용할 수도 있습니다.

위에 나열된 모든 파일을 사용자 지정할 수 있습니다. 이렇게 하면 2.2절의 지침에 따라 "product.img File"을 생성하여 사용자 지정 그래픽을 사용하여 고유한 product.img를 만든 다음, 섹션 2.3, "사용자 지정 부팅 이미지 생성"을 클릭하여 변경 사항이 포함된 새로운 부팅 가능한 ISO 이미지를 생성합니다.

제품 이름을 사용자 지정하려면 사용자 지정 . buildstamp 파일을 생성해야 합니다. 이렇게 하려면 다음 콘텐츠를 사용하여 새 파일 .buildstamp.py 를 생성합니다.

[Main]
Product=My Distribution
Version=9
BugURL=https://bugzilla.redhat.com/
IsFinal=True
UUID=202007011344.x86_64
[Compose]
Lorax=28.14.49-1

설치 프로그램에 표시할 이름으로 내 배포를 변경합니다.

사용자 지정 .buildstamp 파일을 생성한 후 product.img 파일 생성 섹션의 단계에 따라 사용자 지정이 포함된 새 product.img 파일을 생성하고 사용자 지정 부팅 이미지 생성 섹션을 사용하여 변경 사항이 포함된 새로운 부팅 가능 ISO 파일을 생성합니다.

고유한 구성 파일을 생성하고 이를 사용하여 설치 프로그램의 구성을 사용자 지정할 수 있습니다.

[Anaconda]
# Run Anaconda in the debugging mode.
debug = False

# Enable Anaconda addons.
# This option is deprecated and will be removed in the future.
# addons_enabled = True

# List of enabled Anaconda DBus modules.
# This option is deprecated and will be removed in the future.
# kickstart_modules =

# List of Anaconda DBus modules that can be activated.
# Supported patterns: MODULE.PREFIX., MODULE.NAME activatable_modules = org.fedoraproject.Anaconda.Modules.
    org.fedoraproject.Anaconda.Addons.*

# List of Anaconda DBus modules that are not allowed to run.
# Supported patterns: MODULE.PREFIX., MODULE.NAME forbidden_modules = # List of Anaconda DBus modules that can fail to run. # The installation won't be aborted because of them. # Supported patterns: MODULE.PREFIX., MODULE.NAME
optional_modules =
    org.fedoraproject.Anaconda.Modules.Subscription
    org.fedoraproject.Anaconda.Addons.*


[Installation System]

# Should the installer show a warning about enabled SMT?
can_detect_enabled_smt = False


[Installation Target]
# Type of the installation target.
type = HARDWARE

# A path to the physical root of the target.
physical_root = /mnt/sysimage

# A path to the system root of the target.
system_root = /mnt/sysroot

# Should we install the network configuration?
can_configure_network = True


[Network]
# Network device to be activated on boot if none was configured so.
# Valid values:
#
#   NONE                   No device
#   DEFAULT_ROUTE_DEVICE   A default route device
#   FIRST_WIRED_WITH_LINK  The first wired device with link
#
default_on_boot = NONE


[Payload]
# Default package environment.
default_environment =

# List of ignored packages.
ignored_packages =

# Names of repositories that provide latest updates.
updates_repositories =

# List of .treeinfo variant types to enable.
# Valid items:
#
#   addon
#   optional
#   variant
#
enabled_repositories_from_treeinfo = addon optional variant

# Enable installation from the closest mirror.
enable_closest_mirror = True

# Default installation source.
# Valid values:
#
#    CLOSEST_MIRROR  Use closest public repository mirror.
#    CDN             Use Content Delivery Network (CDN).
#
default_source = CLOSEST_MIRROR

# Enable ssl verification for all HTTP connection
verify_ssl = True

# GPG keys to import to RPM database by default.
# Specify paths on the installed system, each on a line.
# Substitutions for $releasever and $basearch happen automatically.
default_rpm_gpg_keys =

[Security]
# Enable SELinux usage in the installed system.
# Valid values:
#
#  -1  The value is not set.
#   0  SELinux is disabled.
#   1  SELinux is enabled.
#
selinux = -1


[Bootloader]
# Type of the bootloader.
# Supported values:
#
#   DEFAULT   Choose the type by platform.
#   EXTLINUX  Use extlinux as the bootloader.
#
type = DEFAULT

# Name of the EFI directory.
efi_dir = default

# Hide the GRUB menu.
menu_auto_hide = False

# Are non-iBFT iSCSI disks allowed?
nonibft_iscsi_boot = False

# Arguments preserved from the installation system.
preserved_arguments =
    cio_ignore rd.znet rd_ZNET zfcp.allow_lun_scan
    speakup_synth apic noapic apm ide noht acpi video
    pci nodmraid nompath nomodeset noiswmd fips selinux
    biosdevname ipv6.disable net.ifnames net.ifnames.prefix
    nosmt


[Storage]
# Enable dmraid usage during the installation.
dmraid = True

# Enable iBFT usage during the installation.
ibft = True

# Do you prefer creation of GPT disk labels?
gpt = False

# Tell multipathd to use user friendly names when naming devices during the installation.
multipath_friendly_names = True

# Do you want to allow imperfect devices (for example, degraded mdraid array devices)?
allow_imperfect_devices = False

# Default file system type. Use whatever Blivet uses by default.
file_system_type =

# Default partitioning.
# Specify a mount point and its attributes on each line.
#
# Valid attributes:
#
#   size <SIZE>    The size of the mount point.
#   min <MIN_SIZE> The size will grow from MIN_SIZE to MAX_SIZE.
#   max <MAX_SIZE> The max size is unlimited by default.
#   free <SIZE>    The required available space.
#
default_partitioning =
    /     (min 1 GiB, max 70 GiB)
    /home (min 500 MiB, free 50 GiB)

# Default partitioning scheme.
# Valid values:
#
#   PLAIN      Create standard partitions.
#   BTRFS      Use the Btrfs scheme.
#   LVM        Use the LVM scheme.
#   LVM_THINP  Use LVM Thin Provisioning.
#
default_scheme = LVM

# Default version of LUKS.
# Valid values:
#
#   luks1  Use version 1 by default.
#   luks2  Use version 2 by default.
#
luks_version = luks2


[Storage Constraints]

# Minimal size of the total memory.
min_ram = 320 MiB

# Minimal size of the available memory for LUKS2.
luks2_min_ram = 128 MiB

# Should we recommend to specify a swap partition?
swap_is_recommended = False

# Recommended minimal sizes of partitions.
# Specify a mount point and a size on each line.
min_partition_sizes =
    /      250 MiB
    /usr   250 MiB
    /tmp   50  MiB
    /var   384 MiB
    /home  100 MiB
    /boot  200 MiB

# Required minimal sizes of partitions.
# Specify a mount point and a size on each line.
req_partition_sizes =

# Allowed device types of the / partition if any.
# Valid values:
#
#   LVM        Allow LVM.
#   MD         Allow RAID.
#   PARTITION  Allow standard partitions.
#   BTRFS      Allow Btrfs.
#   DISK       Allow disks.
#   LVM_THINP  Allow LVM Thin Provisioning.
#
root_device_types =

# Mount points that must be on a linux file system.
# Specify a list of mount points.
must_be_on_linuxfs = / /var /tmp /usr /home /usr/share /usr/lib

# Paths that must be directories on the / file system.
# Specify a list of paths.
must_be_on_root = /bin /dev /sbin /etc /lib /root /mnt lost+found /proc

# Paths that must NOT be directories on the / file system.
# Specify a list of paths.
must_not_be_on_root =

# Mount points that are recommended to be reformatted.
#
# It will be recommended to create a new file system on a mount point
# that has an allowed prefix, but does not have a blocked one.
# Specify lists of mount points.
reformat_allowlist = /boot /var /tmp /usr
reformat_blocklist = /home /usr/local /opt /var/www


[User Interface]
# The path to a custom stylesheet.
custom_stylesheet =

# The path to a directory with help files.
help_directory = /usr/share/anaconda/help

# A list of spokes to hide in UI.
# FIXME: Use other identification then names of the spokes.
hidden_spokes =

# Should the UI allow to change the configured root account?
can_change_root = False

# Should the UI allow to change the configured user accounts?
can_change_users = False

# Define the default password policies.
# Specify a policy name and its attributes on each line.
#
# Valid attributes:
#
#   quality <NUMBER>  The minimum quality score (see libpwquality).
#   length <NUMBER>   The minimum length of the password.
#   empty             Allow an empty password.
#   strict            Require the minimum quality.
#
password_policies =
    root (quality 1, length 6)
    user (quality 1, length 6, empty)
    luks (quality 1, length 6)


[License]
# A path to EULA (if any)
#
# If the given distribution has an EULA & feels the need to
# tell the user about it fill in this variable by a path
# pointing to a file with the EULA on the installed system.
#
# This is currently used just to show the path to the file to
# the user at the end of the installation.
eula =

# Anaconda configuration file for Red Hat Enterprise Linux.

[Product]
product_name = Red Hat Enterprise Linux

[Installation System]

# Show a warning if SMT is enabled.
can_detect_enabled_smt = True

[Network]
default_on_boot = DEFAULT_ROUTE_DEVICE

[Payload]
ignored_packages =
    ntfsprogs
    btrfs-progs
    dmraid

enable_closest_mirror = False
default_source = CDN

[Bootloader]
efi_dir = redhat

[Storage]
file_system_type = xfs
default_partitioning =
    /     (min 1 GiB, max 70 GiB)
    /home (min 500 MiB, free 50 GiB)
    swap

[Storage Constraints]
swap_is_recommended = True

[User Interface]

help_directory = /usr/share/anaconda/help/rhel

[License]
eula = /usr/share/redhat-release/EULA

# Anaconda configuration file for Red Hat Virtualization.

[Product]
product_name = Red Hat Virtualization (RHVH)

[Base Product]
product_name = Red Hat Enterprise Linux

[Storage]
default_scheme = LVM_THINP
default_partitioning =
    /              (min 6 GiB)
    /home          (size 1 GiB)
    /tmp           (size 1 GiB)
    /var           (size 15 GiB)
    /var/crash     (size 10 GiB)
    /var/log       (size 8 GiB)
    /var/log/audit (size 2 GiB)
    swap

[Storage Constraints]
root_device_types = LVM_THINP
must_not_be_on_root = /var
req_partition_sizes =
	/var   10 GiB
	/boot  1  GiB

Anaconda 는 Fedora, Red Hat Enterprise Linux 및 해당 파생 제품에서 사용되는 운영 체제 설치 관리자입니다. Python 모듈과 스크립트 세트와 Gtk 위젯(C로 작성된), systemd 단위 및 dracut 라이브러리와 같은 몇 가지 추가 파일입니다. 이를 통해 사용자는 결과(대상) 시스템의 매개 변수를 설정한 다음 시스템에서 이 시스템을 설정할 수 있는 도구를 형성합니다. 설치 프로세스에는 다음과 같은 네 가지 주요 단계가 있습니다.

Anaconda를 사용하면 다음과 같은 세 가지 방법으로 Fedora, Red Hat Enterprise Linux 및 파생 제품을 설치할 수 있습니다.

GUI(그래픽 사용자 인터페이스) 사용:

가장 일반적인 설치 방법입니다. 인터페이스를 사용하면 설치를 시작하기 전에 필요한 구성이 거의 없거나 전혀 없이 대화형으로 시스템을 설치할 수 있습니다. 이 방법은 복잡한 파티션 레이아웃 설정을 포함하여 모든 일반적인 사용 사례를 다룹니다.

그래픽 카드나 연결된 모니터가 없는 시스템에서도 GUI를 사용할 수 있는 VNC 인터페이스를 통해 원격 액세스를 지원합니다.

텍스트 사용자 인터페이스(TUI) 사용:

TUI는 cursor 이동, 색상 및 기타 고급 기능을 지원하지 않는 직렬 콘솔에서 작동할 수 있는 monochrome 라인 프린터와 유사하게 작동합니다. 텍스트 모드는 제한되어 있으며 네트워크 설정, 언어 옵션 또는 설치(패키지) 소스와 같은 가장 일반적인 옵션만 사용자 지정할 수 있습니다. 수동 파티션과 같은 고급 기능은 이 인터페이스에서 사용할 수 없습니다.

Kickstart 파일 사용:

Kickstart 파일은 설치 프로세스를 구동하는 데이터를 포함할 수 있는 쉘과 유사한 구문이 있는 일반 텍스트 파일입니다. Kickstart 파일을 사용하면 설치를 부분적으로 또는 완전히 자동화할 수 있습니다. 설치를 완전히 자동화하려면 필요한 모든 영역을 구성하는 명령 세트가 필요합니다. 하나 이상의 명령이 누락된 경우 설치에 상호 작용이 필요합니다.

설치 프로그램 자체를 자동화하는 것 외에도 Kickstart 파일에는 설치 프로세스 중 특정 시점에 실행되는 사용자 지정 스크립트가 포함될 수 있습니다.

Anaconda 는 Python 모듈 및 스크립트 세트입니다. 또한 여러 외부 패키지 및 라이브러리를 사용합니다. 이 툴셋의 주요 구성 요소에는 다음 패키지가 포함됩니다.

이전에 언급된 패키지로의 분할 외에도 Anaconda 는 내부적으로 사용자 인터페이스와 별도의 프로세스로 실행되고 D-Bus 라이브러리를 사용하여 통신하는 모듈 세트로 나뉩니다. 이러한 모듈은 다음과 같습니다.

각 모듈은 처리하는 Kickstart의 일부를 선언하고 Kickstart의 구성을 설치 환경 및 설치된 시스템에 적용하는 방법이 있습니다.

Anaconda의 Python 코드 부분(pyanaconda)은 사용자 인터페이스를 소유하는 "main" 프로세스로 시작됩니다. 제공하는 Kickstart 데이터는 pykickstart 모듈을 사용하여 구문 분석하고 Boss 모듈이 시작되고 다른 모든 모듈을 검색하고 시작합니다. 그런 다음 기본 프로세스는 선언된 기능에 따라 Kickstart 데이터를 모듈에 보냅니다. 모듈은 데이터를 처리하고 설치 환경에 구성을 적용하고 UI에서 필요한 모든 선택 항목이 수행되었는지 확인합니다. 그렇지 않은 경우 데이터를 대화형 설치 모드로 제공해야 합니다. 필요한 모든 선택 사항이 완료되면 설치를 시작할 수 있습니다. 모듈은 설치된 시스템에 데이터를 작성합니다.

Anaconda 사용자 인터페이스(UI)에는 hub 및 spoke 모델라고도 하는 비선형 구조가 있습니다.

Anaconda 허브 및 스포크 모델의 장점은 다음과 같습니다.

다음 다이어그램은 설치 프로그램 레이아웃과 허브 와 스포크 (스크린) 간의 가능한 상호 작용을 보여줍니다.

그림 5.1. hub 및 spoke model

다이어그램에서 화면 2-13은 일반 대화 상자 라고 하며 화면 1과 14는 독립형 대화입니다. 독립 실행형 대화는 독립 실행형 스포크 또는 허브 이전 또는 이후에 사용할 수 있는 화면입니다. 예를 들어 설치 시작 시 시작 부분에 있는 welcome 화면에서 나머지 설치에 대한 언어를 선택하라는 메시지가 표시됩니다.

각 spoke에는 허브를 반영하는 다음과 같은 사전 정의된 속성이 있습니다.

사용자 인터페이스를 더 명확하게하기 위해 대화는 카테고리 로 그룹화됩니다. 예를 들어, Localization 카테고리 그룹은 키보드 레이아웃 선택, 언어 지원 및 표준 시간대 설정을 함께 스포팅합니다.

각 대화 상자에는 하나 이상의 모듈에서 값을 표시하고 수정할 수 있는 UI 제어가 포함되어 있습니다. 이는 애드온이 제공하는 정책에도 동일하게 적용됩니다.

설치 프로세스 중에 수행해야 하는 일부 작업은 시간이 오래 걸릴 수 있습니다. 예를 들어 기존 파티션의 디스크를 스캔하거나 패키지 메타데이터를 다운로드합니다. 대기 및 나머지 응답 시간을 방지하기 위해 Anaconda 는 이러한 작업을 별도의 스레드에서 실행합니다.

Gtk 툴킷은 여러 스레드의 요소 변경을 지원하지 않습니다. Gtk 의 주요 이벤트 루프는 Anaconda 프로세스의 기본 스레드에서 실행됩니다. 따라서 GUI와 관련된 모든 작업은 기본 스레드에서 수행해야 합니다. 이렇게 하려면 GLib.idle_add 를 사용하십시오. 이는 항상 쉽고 원하는 것은 아닙니다. pyanaconda.ui.gui.utils 모듈에 정의된 여러 도우미 함수 및 데코레이터가 챌린지에 추가할 수 있습니다.

이 함수 또는 메서드를 호출할 때 해당 함수 또는 메서드를 호출할 때 기본 스레드에서 실행되는 Gtk의 기본 루프에 자동으로 큐에 큐에 저장되면 기본 스레드에서 실행되는 Gtk _action_ wait 및 @managek_action_nowait 데코레이터가 장식된 함수 또는 메서드를 변경합니다. 반환 값은 호출자로 반환되거나 각각 삭제됩니다.

대화 상자 및 허브 통신에서 대화 상대는 준비가 되어 있고 차단되지 않을 때 발표되었습니다. hubQ 메시지 큐는 이 기능을 처리하고 주기적으로 기본 이벤트 루프를 확인합니다. 대화 상자에 액세스 할 수 있게 되면 변경 사항을 발표하는 대기열에 메시지를 보내고 더 이상 차단해서는 안 됩니다.

spoke에서 상태를 새로 고치거나 플래그를 완료해야 하는 경우에도 동일하게 적용됩니다. 구성 및 진행률 허브에 는 설치 진행 상황 업데이트를 전송하기 위한 매체 역할을 하는 progressQ 라는 다른 큐가 있습니다.

이러한 메커니즘은 텍스트 기반 인터페이스에도 사용됩니다. 텍스트 모드에서는 기본 루프가 없지만 키보드 입력은 대부분의 시간을 사용합니다.

Anaconda의 모듈은 독립적인 프로세스로 실행됩니다. D-Bus API를 통해 이러한 프로세스와 통신하려면 dasbus 라이브러리를 사용합니다.

D-Bus API를 통한 메서드 호출은 비동기식이지만 dasbus 라이브러리를 사용하면 Python에서 동기 메서드 호출로 변환할 수 있습니다. 다음 프로그램 중 하나를 작성할 수도 있습니다.

스레드 및 통신에 대한 자세한 내용은 Anaconda 스레드 간 통신을 참조하십시오.

또한 Anaconda는 모듈에서 실행되는 Task 오브젝트를 사용합니다. 작업에는 추가 스레드에서 자동으로 실행되는 D-Bus API 및 메서드가 있습니다. 작업을 성공적으로 실행하려면 sync_run_task 및 async_run_task 도우미 함수를 사용합니다.

Anaconda 개발자는 GitHub에서 사용할 수 있는 "Hello World"라는 애드온을 게시합니다. https://github.com/rhinstaller/hello-world-anaconda-addon/ 추가 섹션의 설명은 이에서 재현됩니다.

Anaconda 애드온은 __init___.py 및 기타 소스 디렉터리(subpackages)가 있는 디렉토리를 포함하는 Python 패키지입니다. Python에서는 각 패키지 이름을 한 번만 가져올 수 있으므로 패키지 최상위 디렉터리에 대한 고유 이름을 지정합니다. add-ons는 이름에 관계없이 로드되므로 임의의 이름을 사용할 수 있습니다. 즉, 유일한 요구 사항은 특정 디렉터리에 배치되어야 한다는 것입니다.

애드온에 대한 제안된 이름 지정 규칙은 Java 패키지 또는 D-Bus 서비스 이름과 유사합니다.

디렉터리 이름을 Python 패키지의 고유 식별자로 만들려면 점 대신 밑줄(_)을 사용하여 조직의 역방향 도메인 이름으로 애드온 이름을 접두사로 지정합니다. 예: com_example_hello_world.

애드온을 작성할 때 다음을 확인합니다.

다음은 모든 인터페이스 (Kickstart, GUI 및 TUI)를 지원하는 애드온의 샘플 디렉터리 구조입니다.

com_example_hello_world
├─ gui
│  ├─ init.py
│  └─ spokes
│     └─ init.py
└─ tui
   ├─ init.py
   └─ spokes
   └─ init.py

각 패키지에는 API에 정의된 하나 이상의 클래스에서 상속된 클래스를 정의하는 임의의 이름이 포함된 하나 이상의 모듈이 포함되어야 합니다.

애드온에서 새 카테고리를 정의해야 하는 경우 카테고리 하위 패키지를 포함할 수 있지만 권장되지는 않습니다.

Anaconda 서비스 및 구성 파일은 데이터/ 디렉터리에 포함되어 있습니다. 이러한 파일은 애드온 서비스를 시작하고 D-Bus를 구성하는 데 필요합니다.

다음은 Anaconda Hello World 애드온의 몇 가지 예입니다.

<!DOCTYPE busconfig PUBLIC
"-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
"http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
<busconfig>
       <policy user="root">
               <allow own="org.fedoraproject.Anaconda.Addons.HelloWorld"/>
               <allow send_destination="org.fedoraproject.Anaconda.Addons.HelloWorld"/>
       </policy>
       <policy context="default">
               <deny own="org.fedoraproject.Anaconda.Addons.HelloWorld"/>
               <allow send_destination="org.fedoraproject.Anaconda.Addons.HelloWorld"/>
       </policy>
</busconfig>

이 파일은 설치 환경의 /usr/share/anaconda/dbus/confs/ 디렉터리에 있어야 합니다. org.fedoraproject.Anaconda.Addons.Hello world는 D-Bus의 addon 서비스의 위치에 대응해야 합니다.

[D-BUS Service]
# Start the org.fedoraproject.Anaconda.Addons.HelloWorld service.
# Runs org_fedora_hello_world/service/main.py
Name=org.fedoraproject.Anaconda.Addons.HelloWorld
Exec=/usr/libexec/anaconda/start-module org_fedora_hello_world.service
User=root

이 파일은 설치 환경의 /usr/share/anaconda/dbus/services/ 디렉터리에 있어야 합니다. org.fedoraproject.Anaconda.Addons.Hello world는 D-Bus의 addon 서비스의 위치에 대응해야 합니다. Exec= 로 시작하는 행의 값은 설치 환경에서 서비스를 시작하는 유효한 명령이어야 합니다.

애드온의 Kickstart 지원과 마찬가지로, GUI 지원은 애드온의 모든 부분에 API에서 정의한 특정 클래스에서 상속된 클래스의 정의와 함께 하나 이상의 모듈을 포함해야 합니다. 그래픽 애드온 지원의 경우 추가할 유일한 클래스는 pyanaconda.ui.gui.spokes 에 정의된 NormalSpoke 클래스입니다. 자세한 내용은 Anaconda 사용자 인터페이스를 참조하십시오.

NormalSpoke 에서 상속된 새 클래스를 구현하려면 API에 필요한 다음 클래스 속성을 정의해야 합니다.

이 섹션에서는 다음과 같은 고급 단계를 수행하여 추가 기능의 GUI(그래픽 사용자 인터페이스)에 지원을 추가하는 방법에 대해 설명합니다.

# will never be translated
_ = lambda x: x
N_ = lambda x: x

# the path to addons is in sys.path so we can import things from org_fedora_hello_world
from org_fedora_hello_world.gui.categories.hello_world import HelloWorldCategory
from pyanaconda.ui.gui.spokes import NormalSpoke

# export only the spoke, no helper functions, classes or constants
all = ["HelloWorldSpoke"]

class HelloWorldSpoke(FirstbootSpokeMixIn, NormalSpoke):
    """
    Class for the Hello world spoke. This spoke will be in the Hello world
    category and thus on the Summary hub. It is a very simple example of a unit
    for the Anaconda's graphical user interface. Since it is also inherited form
    the FirstbootSpokeMixIn, it will also appear in the Initial Setup (successor
    of the Firstboot tool).

    :see: pyanaconda.ui.common.UIObject
    :see: pyanaconda.ui.common.Spoke
    :see: pyanaconda.ui.gui.GUIObject
    :see: pyanaconda.ui.common.FirstbootSpokeMixIn
    :see: pyanaconda.ui.gui.spokes.NormalSpoke

    """

    # class attributes defined by API #

    # list all top-level objects from the .glade file that should be exposed
    # to the spoke or leave empty to extract everything
    builderObjects = ["helloWorldSpokeWindow", "buttonImage"]

    # the name of the main window widget
    mainWidgetName = "helloWorldSpokeWindow"

    # name of the .glade file in the same directory as this source
    uiFile = "hello_world.glade"

    # category this spoke belongs to
    category = HelloWorldCategory

    # spoke icon (will be displayed on the hub)
    # preferred are the -symbolic icons as these are used in Anaconda's spokes
    icon = "face-cool-symbolic"

    # title of the spoke (will be displayed on the hub)
    title = N_("_HELLO WORLD")

__all__ 속성은 spoke 클래스를 내보낸 다음, GUI 애드온 기본 기능에서 이전에 언급한 속성 정의를 포함하여 첫 번째 줄로 구성됩니다. 이러한 특성 값은 com_example_hello_world/gui/spokes/hello.glade 파일에 정의된 위젯을 참조합니다. 다른 주목할 만한 두 가지 속성이 있습니다.

일반적으로 클래스 정의의 헤더와 클래스 특성 정의는 클래스의 인스턴스를 초기화하는 생성자입니다. Anaconda 그래픽 인터페이스 오브젝트의 경우 새 인스턴스를 초기화하는 방법에는 __init__ 메서드와 initialize 메서드라는 두 가지 방법이 있습니다.

이러한 기능 뒤에 있는 이유는 GUI 객체가 한 번에 메모리에 생성될 수 있고 스포크 초기화가 시간 소모될 수 있기 때문에 다른 시간에 완전히 초기화될 수 있기 때문입니다. 따라서 __init__ 메서드는 상위의 __init__ 메서드만 호출해야 하며, 예를 들어, GPU가 아닌 특성을 초기화해야 합니다. 반면 설치 프로그램의 그래픽 사용자 인터페이스가 초기화될 때 호출되는 initialize 메서드는 spoke의 전체 초기화를 완료해야 합니다.

Hello World 애드온 예에서 다음과 같이 이 두 가지 방법을 정의합니다. __init__ 메서드에 전달된 인수의 수와 설명을 기록해 둡니다.

def __init__(self, data, storage, payload):
    """
    :see: pyanaconda.ui.common.Spoke.init
    :param data: data object passed to every spoke to load/store data
    from/to it
    :type data: pykickstart.base.BaseHandler
    :param storage: object storing storage-related information
    (disks, partitioning, bootloader, etc.)
    :type storage: blivet.Blivet
    :param payload: object storing packaging-related information
    :type payload: pyanaconda.packaging.Payload

    """

    NormalSpoke.init(self, data, storage, payload)
    self._hello_world_module = HELLO_WORLD.get_proxy()

def initialize(self):
    """
    The initialize method that is called after the instance is created.
    The difference between init and this method is that this may take
    a long time and thus could be called in a separate thread.
    :see: pyanaconda.ui.common.UIObject.initialize
    """
    NormalSpoke.initialize(self)
    self._entry = self.builder.get_object("textLines")
    self._reverse = self.builder.get_object("reverseCheckButton")

__init__ 메서드에 전달된 data 매개 변수는 모든 데이터가 저장된 Kickstart 파일의 메모리 내 트리와 같습니다. RuntimeClass의 __init__ 메서드 중 하나에서 이 메서드는 해당 구조를 읽고 수정할 수 있도록 하는 self.data 특성에 저장됩니다.

HelloworldData 클래스는 Hello World 애드온 예제에 이미 정의되어 있기 때문에 이 애드온에 대한 subtree가 이미 self.data에 있습니다. 클래스의 루트는 self.data.addons.com_example_hello_world 로 사용할 수 있습니다.

RuntimeClass의 __init__ 가 수행하는 또 다른 작업은 대화 상자의 .glade 파일을 사용하여 GtkBuilder의 인스턴스를 초기화하고 self.builder 로 저장하는 것입니다. 초기화 방법은 이 방법을 사용하여 Kickstart 파일의 %addon 섹션에서 텍스트를 표시하고 수정하는 데 사용되는 GtkTextEntry 를 가져옵니다.

spoke이 생성될 때 __init__ 및 initialize 메서드는 모두 중요합니다. 그러나 스포크의 주요 역할은 대화된 값의 표시 및 집합을 변경하거나 검토하려는 사용자가 방문하는 것입니다. 이를 활성화하려면 다음 세 가지 다른 방법을 사용할 수 있습니다.

이 함수는 다음과 같은 방식으로 샘플 Hello World 애드온으로 구현됩니다.

def refresh(self):
    """
    The refresh method that is called every time the spoke is displayed.
    It should update the UI elements according to the contents of
    internal data structures.
    :see: pyanaconda.ui.common.UIObject.refresh
    """
    lines = self._hello_world_module.Lines
    self._entry.get_buffer().set_text("".join(lines))
    reverse = self._hello_world_module.Reverse
    self._reverse.set_active(reverse)

def apply(self):
    """
    The apply method that is called when user leaves the spoke. It should
    update the D-Bus service with values set in the GUI elements.
    """
    buf = self._entry.get_buffer()
    text = buf.get_text(buf.get_start_iter(),
                        buf.get_end_iter(),
                        True)
    lines = text.splitlines(True)
    self._hello_world_module.SetLines(lines)

    self._hello_world_module.SetReverse(self._reverse.get_active())

def execute(self):
  """
  The execute method that is called when the spoke is exited. It is
  supposed to do all changes to the runtime environment according to
  the values set in the GUI elements.

  """

  # nothing to do here
  pass

여러 가지 추가 방법을 사용하여 spoke의 상태를 제어할 수 있습니다.

이러한 모든 속성은 설치 프로세스의 현재 상태에 따라 동적으로 결정해야 합니다.

다음은 Hello World 애드온에서 이러한 메서드의 샘플 구현으로, Helloworld Data 클래스의 텍스트 특성에 특정 값을 설정해야 합니다.

@property
def ready(self):
    """
    The ready property reports whether the spoke is ready, that is, can be visited
    or not. The spoke is made (in)sensitive based on the returned value of the ready
    property.

    :rtype: bool

    """

    # this spoke is always ready
    return True


@property
def mandatory(self):
    """
    The mandatory property that tells whether the spoke is mandatory to be
    completed to continue in the installation process.

    :rtype: bool

    """

    # this is an optional spoke that is not mandatory to be completed
    return False

이러한 속성이 정의되면 스포크는 접근성과 완전성을 제어할 수 있지만, 내에 구성된 값의 요약을 제공할 수 없습니다. spoke를 방문하여 이 구성이 어떻게 구성되어 있는지 확인해야 합니다. 이는 바람직하지 않을 수 있습니다. 따라서 status 라는 추가 속성이 있습니다. 이 속성에는 구성된 값에 대한 간단한 요약이 포함된 한 줄의 텍스트가 포함되어 있으며, 이는 스포크 제목에 따라 허브에 표시할 수 있습니다.

status 속성은 다음과 같이 Hello World 예제 애드온에 정의되어 있습니다.

@property
def status(self):
    """
    The status property that is a brief string describing the state of the
    spoke. It should describe whether all values are set and if possible
    also the values themselves. The returned value will appear on the hub
    below the spoke's title.
    :rtype: str
    """
    lines = self._hello_world_module.Lines
    if not lines:
        return _("No text added")
    elif self._hello_world_module.Reverse:
        return _("Text set with {} lines to reverse").format(len(lines))
    else:
        return _("Text set with {} lines").format(len(lines))

예제에 설명된 모든 속성을 정의하면 애드온에서 그래픽 사용자 인터페이스(GPU)와 Kickstart를 표시하는 완전 지원이 제공됩니다.

한 가지 주목할 만한 제한 사항은 각 대화의 자체 기본 창 - SpokeWindow 위젯의 인스턴스가 있어야한다는 것입니다. 이 위젯은 Anaconda에 관련된 다른 위젯과 함께 anaconda-widgets 패키지에 있습니다. anaconda-widgets-devel 패키지에서 GUI 지원과 같은 추가 기능 개발에 필요한 다른 파일을 찾을 수 있습니다.

그래픽 인터페이스 지원 모듈에 필요한 모든 방법이 포함되어 있으면 다음 섹션을 계속 사용하여 텍스트 기반 사용자 인터페이스에 대한 지원을 추가하거나 Anaconda 애드온 배포 및 테스트를 계속 수행하고 애드온을 테스트할 수 있습니다.

pyanaconda 패키지에는 허브 및 스포크에서 사용할 수 있는 여러 도우미 및 유틸리티 기능이 포함되어 있습니다. 대부분은 pyanaconda.ui.gui.utils 패키지에 있습니다.

샘플 Hello World add-on은 Anaconda 에서 사용하는 englightbox 콘텐츠 관리자의 사용법을 보여줍니다. 이 콘텐츠 관리자는 창을 Lightbox에 추가하여 가시성을 높이고 사용자가 기본 창과 상호 작용하는 것을 방지할 수 있습니다. 이 기능을 설명하기 위해 샘플 추가 기능에는 새 대화 상자 창을 여는 버튼이 포함되어 있습니다. 대화 상자 자체는 pyanaconda.ui.gui.init 에 정의된 GUIObject 클래스에서 상속되는 특수 HelloworldDialog입니다.

dialog 클래스는 mainWidgetName class 특성을 사용하여 채운 self.window 특성을 통해 액세스할 수 있는 내부 Gtk 대화 상자를 실행하고 삭제하는 run 메서드를 정의합니다. 따라서 대화 상자를 정의하는 코드는 다음 예와 같이 매우 간단합니다.

        # every GUIObject gets ksdata in init
        dialog = HelloWorldDialog(self.data)

        # show dialog above the lightbox
        with self.main_window.enlightbox(dialog.window):
            dialog.run()

englightbox 대화 상자 예제 코드를 통해 대화 상자의 인스턴스를 만든 다음 enlightbox 컨텍스트 관리자를 사용하여 lightbox 내에서 대화 상자를 실행합니다. 컨텍스트 관리자는 대화 상자의 창에 대한 참조가 있으며 대화 상자의 Lightbox를 인스턴스화하기 위해 대화 상자만 있으면 됩니다.

Anaconda 에서 제공하는 또 다른 유용한 기능은 설치 중에 및 첫 번째 재부팅 후 표시되는 스포크를 정의하는 기능입니다. Initial Setup 유틸리티는 애드온 그래픽 사용자 인터페이스 (GUI)에 대한 지원 추가 에서 설명됩니다. Anaconda 및 Initial Setup 모두에서 대화 상자를 사용하려면 pyanaconda.ui.common 모듈에 정의된 첫 번째 상속 클래스로 라고도 하는 특수한 FirstbootSpokeMixIn 클래스를 상속해야 합니다.

Anaconda 의 대화 상자와 Initial Setup의 재구성 모드에서 사용할 수 있도록 하려면 pyanaconda.ui.common 모듈에 정의된 첫 번째 상속된 클래스로 믹싱 이라고도 하는 특수한 FirstbootSpokeMixIn 클래스를 상속해야 합니다.

Initial Setup에서만 특정 대화 상자를 사용할 수 있도록 하려면 이 대화 상자에서는 FirstbootOnlySpokeMixIn 클래스를 상속해야 합니다.

대화 상자에서 항상 Anaconda 및 Initial Setup에서 사용할 수 있도록 하려면 다음 예제와 같이 spoke에서 should_run 메서드를 재정의해야 합니다.

@classmethod
    def should_run(cls, environment, data):
    """Run this spoke for Anaconda and Initial Setup"""
    return True

pyanaconda 패키지는 @managek _action_wait 및 @Virtk_ action_nowait 데코레이터와 같은 고급 기능을 많이 제공하지만 이 가이드에서는 다루지 않습니다. 자세한 내용은 설치 프로그램의 소스를 참조하십시오.

Anaconda는 TUI(텍스트 기반 인터페이스)도 지원합니다. 이 인터페이스는 기능에서 더 제한되지만 일부 시스템에서는 대화식 설치를 위한 유일한 선택일 수 있습니다. 텍스트 기반 인터페이스와 그래픽 인터페이스 간의 차이점 및 TUI의 제한 사항에 대한 자세한 내용은 Anaconda 및 애드온 소개를 참조하십시오.

설치 프로그램에서 텍스트 모드를 지원하는 것은 간단한 줄 라이브러리를 기반으로 하며, 이는 매우 간단한 사용자 상호 작용만 허용합니다. 텍스트 모드 인터페이스:

내부적으로 simpleline 툴킷에는 세 가지 주요 클래스가 있습니다. 앱,UIoctets 및 위젯. 위젯은 화면에 출력할 정보가 포함된 단위입니다. App 클래스의 단일 인스턴스에 의해 전환되는 UIsandboxs에 배치됩니다. 기본 요소인 hubs , spoke 's 및 'dialogs 에는 그래픽 인터페이스와 유사한 방식으로 다양한 위젯이 포함되어 있습니다.

애드온에서 가장 중요한 클래스는 NormalTUISpoke 이며 pyanaconda.ui.tui.spokes 패키지에 정의된 다른 다양한 클래스입니다. 이러한 모든 클래스는 TUIObject 클래스를 기반으로 하며, 이 클래스는 Add-on GUI 고급 기능에서 설명하는 GUI Object 클래스와 동일합니다. 각 TUI spoke는 NormalTUISpoke 클래스에서 상속하고 API에서 정의한 특수 인수와 메서드를 재정의하는 Python 클래스입니다. 텍스트 인터페이스는 GUI보다 단순하기 때문에 다음과 같은 두 가지 인수만 있습니다.

각 대화 상자에서 여러 가지 방법, 즉 init, initialize,refresh ,apply,execute,input, prompt ,prompt, and properties (ready,completed,mandatory, status)를 덮어씁니다.

다음 예제에서는 Hello World 샘플 애드온에서 간단한 텍스트 사용자 인터페이스(TUI) 스포크의 구현을 보여줍니다.

def __init__(self, *args, **kwargs):
    """
    Create the representation of the spoke.

    :see: simpleline.render.screen.UIScreen
    """
    super().__init__(*args, **kwargs)
    self.title = N_("Hello World")
    self._hello_world_module = HELLO_WORLD.get_proxy()
    self._container = None
    self._reverse = False
    self._lines = ""

def initialize(self):
    """
    The initialize method that is called after the instance is created.
    The difference between __init__ and this method is that this may take
    a long time and thus could be called in a separated thread.

    :see: pyanaconda.ui.common.UIObject.initialize
    """
    # nothing to do here
    super().initialize()

def setup(self, args=None):
    """
    The setup method that is called right before the spoke is entered.
    It should update its state according to the contents of DBus modules.

    :see: simpleline.render.screen.UIScreen.setup
    """
    super().setup(args)

    self._reverse = self._hello_world_module.Reverse
    self._lines = self._hello_world_module.Lines

    return True

def refresh(self, args=None):
    """
    The refresh method that is called every time the spoke is displayed.
    It should generate the UI elements according to its state.

    :see: pyanaconda.ui.common.UIObject.refresh
    :see: simpleline.render.screen.UIScreen.refresh
    """
    super().refresh(args)

    self._container = ListColumnContainer(
        columns=1
    )
    self._container.add(
        CheckboxWidget(
            title="Reverse",
            completed=self._reverse
        ),
        callback=self._change_reverse
    )
    self._container.add(
        EntryWidget(
            title="Hello world text",
            value="".join(self._lines)
        ),
        callback=self._change_lines
    )

    self.window.add_with_separator(self._container)

def _change_reverse(self, data):
    """
    Callback when user wants to switch checkbox.
    Flip state of the "reverse" parameter which is boolean.
    """
    self._reverse = not self._reverse

def _change_lines(self, data):
    """
    Callback when user wants to input new lines.
    Show a dialog and save the provided lines.
    """
    dialog = Dialog("Lines")
    result = dialog.run()
    self._lines = result.splitlines(True)

def input(self, args, key):
    """
    The input method that is called by the main loop on user's input.

    * If the input should not be handled here, return it.
    * If the input is invalid, return InputState.DISCARDED.
    * If the input is handled and the current screen should be refreshed,
      return InputState.PROCESSED_AND_REDRAW.
    * If the input is handled and the current screen should be closed,
      return InputState.PROCESSED_AND_CLOSE.

    :see: simpleline.render.screen.UIScreen.input
    """
    if self._container.process_user_input(key):
        return InputState.PROCESSED_AND_REDRAW

    if key.lower() == Prompt.CONTINUE:
        self.apply()
        self.execute()
        return InputState.PROCESSED_AND_CLOSE

    return super().input(args, key)

def apply(self):
    """
    The apply method is not called automatically for TUI. It should be called
    in input() if required. It should update the contents of internal data
    structures with values set in the spoke.
    """
    self._hello_world_module.SetReverse(self._reverse)
    self._hello_world_module.SetLines(self._lines)

def execute(self):
    """
    The execute method is not called automatically for TUI. It should be called
    in input() if required. It is supposed to do all changes to the runtime
    environment according to the values set in the spoke.
    """
    # nothing to do here
    pass

이전 예에서 다음을 수행합니다.

다른 화면을 표시하려면 예를 들어 다른 대화 상자에 입력된 추가 정보가 필요한 경우 다른 TUIObject 를 인스턴스화하고 이를 표시하려면 ScreenHandler.push_screen_modal() 을 사용할 수 있습니다.

텍스트 기반 인터페이스의 제한으로 인해 TUI spokes는 확인란 목록 또는 선택 해제로 구성되는 매우 유사한 구조를 갖는 경향이 있습니다.

간단한 TUI Spoke 예제를 정의 하면 메서드가 사용 가능하고 제공된 데이터를 인쇄하고 처리하는 TUI spoke를 구현할 수 있었습니다. 그러나 pyanaconda.ui.tui.spokes 패키지의 Normal EditTUISpoke 클래스를 사용하여 이를 수행할 수 있는 다른 방법이 있습니다. 이 클래스를 상속하면 해당 클래스에서 설정해야 하는 필드 및 속성만 지정하여 일반적인 TUI 대화 상자를 구현할 수 있습니다.By inheriting this class, you can implement a typical TUI spoke by only specifying fields and attributes that should be set in it. 다음 예제에서는이를 보여 줍니다.The following example demonstrates this:

class HelloWorldEditSpoke(NormalTUISpoke):
    """Example class demonstrating usage of editing in TUI"""

    category = HelloWorldCategory

    def init(self, data, storage, payload):
        """
        :see: simpleline.render.screen.UIScreen
        :param data: data object passed to every spoke to load/store data
                     from/to it
        :type data: pykickstart.base.BaseHandler
        :param storage: object storing storage-related information
                        (disks, partitioning, bootloader, etc.)
        :type storage: blivet.Blivet
        :param payload: object storing packaging-related information
        :type payload: pyanaconda.packaging.Payload
        """
        NormalTUISpoke.init(self, data, storage, payload)

        self.title = N_("Hello World Edit")
        self._container = None
        # values for user to set
        self._checked = False
        self._unconditional_input = ""
        self._conditional_input = ""

    def refresh(self, args=None):
        """
        The refresh method that is called every time the spoke is displayed.
        It should update the UI elements according to the contents of
        self.data.
        :see: pyanaconda.ui.common.UIObject.refresh
        :see: simpleline.render.screen.UIScreen.refresh
        :param args: optional argument that may be used when the screen is
                     scheduled
        :type args: anything
        """
        super().refresh(args)
        self._container = ListColumnContainer(columns=1)

        # add ListColumnContainer to window (main window container)
        # this will automatically add numbering and will call callbacks when required
        self.window.add(self._container)

        self._container.add(CheckboxWidget(title="Simple checkbox", completed=self._checked),
                            callback=self._checkbox_called)
        self._container.add(EntryWidget(title="Unconditional text input",
                                        value=self._unconditional_input),
                            callback=self._get_unconditional_input)

        # show conditional input only if the checkbox is checked
        if self._checked:
            self._container.add(EntryWidget(title="Conditional password input",
                                            value="Password set" if self._conditional_input
                                            else ""),
                                callback=self._get_conditional_input)

        self._window.add_separator()


    @property
    def completed(self):
        # completed if user entered something non-empty to the Conditioned input
        return bool(self._conditional_input)
    @property
    def status(self):
        return "Hidden input %s" % ("entered" if self._conditional_input
                                    else "not entered")

    def apply(self):
        # nothing needed here, values are set in the self.args tree
        pass

설치 환경에 자신의 Anaconda 애드온을 배포하고 테스트할 수 있습니다. 이렇게 하려면 다음 단계를 수행합니다.

기존 부팅 이미지의 압축을 풀고 product.img 파일을 만들고 이미지를 다시 패키징 하는 방법에 대한 자세한 내용은 Red Hat Enterprise Linux 부팅 이미지 추출을 참조하십시오.

product.img 이미지 파일은 런타임 시 기존 설치 프로그램 파일을 대체하는 새 설치 프로그램이 포함된 아카이브입니다.

시스템 부팅 중에 Anaconda 는 부팅 미디어의 images/ 디렉터리에서 product.img 파일을 로드합니다. 그런 다음 이 디렉터리에 있는 파일을 사용하여 설치 프로그램의 파일 시스템에서 동일하게 이름이 지정된 파일을 대체합니다. 교체 시 파일은 설치 프로그램을 사용자 정의합니다(예: 기본 이미지를 사용자 지정으로 교체).

참고: product.img 이미지에는 설치 프로그램과 동일한 디렉터리 구조가 포함되어야 합니다. 설치 프로그램 디렉터리 구조에 대한 자세한 내용은 아래 표를 참조하십시오.

아래 절차에서는 product.img 파일을 만드는 방법을 설명합니다.

이제 product.img 파일이 생성되고 만들 사용자 지정이 해당 디렉터리에 배치됩니다.

부팅 이미지와 GUI 레이아웃을 사용자 지정한 후 변경한 내용이 포함된 새 이미지를 만듭니다.

사용자 지정 부팅 이미지를 생성하려면 아래 절차를 따르십시오.