Vorige: , Nach oben: Dienste definieren   [Inhalt][Index]


12.18.5 Komplizierte Konfigurationen

Einige Programme haben vielleicht ziemlich komplizierte Konfigurationsdateien oder -formate. Sie können die Hilfsmittel, die in dem Modul (gnu services configuration) definiert sind, benutzen, um das Erstellen von Scheme-Anbindungen für diese Konfigurationsdateien leichter zu machen.

Das Werkzeug der Wahl ist das Makro define-configuration, mit dem Sie einen Scheme-Verbundstyp definieren (siehe Record Overview in Referenzhandbuch zu GNU Guile). Ein Scheme-Verbund dieses Typs wird zu einer Konfigurationsdatei serialisiert, indem Serialisierer aufgerufen werden. Das sind Prozeduren, die einen Scheme-Wert nehmen und einen G-Ausdruck zurückliefern (siehe G-Ausdrücke), der wiederum schließlich, nachdem er auf die Platte serialisiert wurde, eine Zeichenkette liefern sollte. Details folgen.

Scheme-Syntax: define-configuration Name Klausel1 Klausel2 ... Einen Verbundstyp mit dem Namen Name

erstellen, der die in den Klauseln gefundenen Felder enthalten wird.

Eine Klausel kann eine der folgenden Formen annehmen:

(Feldname
 (Typ Vorgabewert)
 Dokumentation)
 
(Feldname
 (Typ Vorgabewert)
 Dokumentation
 Serialisierer)

(Feldname
 (Typ)
 Dokumentation)

(Feldname
 (Typ)
 Dokumentation
 Serialisierer)

Feldname ist ein Bezeichner, der als Name des Feldes im erzeugten Verbund verwendet werden wird.

Mit Typ wird benannt, was als Typ des Werts für Feldname gelten soll. Weil Guile typenlos ist, muss es eine entsprechend benannte Prädikatprozedur Typ? geben, die auf dem Wert für das Feld aufgerufen werden wird und prüft, dass der Wert des Feldes den geltenden Typ hat. Wenn zum Beispiel package als Typ angegeben wird, wird eine Prozedur namens package? auf den für das Feld angegebenen Wert angewandt werden. Sie muss zurückliefern, ob es sich wirklich um ein <package>-Objekt handelt.

Vorgabewert ist der Standardwert für das Feld; wenn keiner festgelegt wird, muss der Benutzer einen Wert angeben, wenn er ein Objekt mit dem Verbundstyp erzeugt.

Dokumentation ist eine Zeichenkette, die mit Texinfo-Syntax formatiert ist. Sie sollte eine Beschreibung des Feldes enthalten.

Serialisierer ist der Name einer Prozedur, die zwei Argumente nimmt, erstens den Namen des Feldes und zweitens den Wert für das Feld, und eine Zeichenkette oder einen G-Ausdruck (siehe G-Ausdrücke) zurückliefern sollte, welcher Inhalt dafür in die Konfigurationsdatei serialisiert wird. Wenn kein Serialisierer angegeben wird, wird eine Prozedur namens serialize-Typ dafür aufgerufen.

Eine einfache Serialisiererprozedur könnte so aussehen:

(define (serialize-boolean field-name value)
  (let ((value (if value "true" "false")))
    #~(string-append #$field-name #$value)))

Es kommt vor, dass in derselben Datei mehrere Arten von Konfigurationsverbund definiert werden, deren Serialisierer sich für denselben Typ unterscheiden, weil ihre Konfigurationen verschieden formatiert werden müssen. Zum Beispiel braucht es eine andere serialize-boolean-Prozedur für einen Getmail-Dienst als für einen Transmission-Dienst. Um leichter mit so einer Situation fertig zu werden, können Sie ein Serialisierer-Präfix nach dem Literal prefix in der define-configuration-Form angeben. Dann müssen Sie den eigenen Serialisierer nicht für jedes Feld angeben.

(define (foo-serialize-string field-name value)
  )

(define (bar-serialize-string field-name value)
  )
  
(define-configuration foo-configuration
  (label
   (string)
   "The name of label.")
  (prefix foo-))

(define-configuration bar-configuration
  (ip-address
   (string)
   "The IPv4 address for this device.")
  (prefix bar-))

In manchen Fällen wollen Sie vielleicht überhaupt gar keinen Wert aus dem Verbund serialisieren. Dazu geben Sie das Literal no-serialization an. Auch können Sie das Makro define-configuration/no-serialization benutzen, was eine Kurzschreibweise dafür ist.

;; Nichts wird auf die Platte serialisiert.
(define-configuration foo-configuration
  (field
   (string "test")
   "Some documentation.")
  (no-serialization))

;; Das Gleiche wie oben.
(define-configuration/no-serialization bar-configuration
  (field
   (string "test")
   "Some documentation."))
Scheme-Syntax: define-maybe Typ

Sometimes a field should not be serialized if the user doesn’t specify a value. To achieve this, you can use the define-maybe macro to define a “maybe type”; if the value of a maybe type is left unset, or is set to the *unspecified* value, then it will not be serialized.

When defining a “maybe type”, the corresponding serializer for the regular type will be used by default. For example, a field of type maybe-string will be serialized using the serialize-string procedure by default, you can of course change this by specifying a custom serializer procedure. Likewise, the type of the value would have to be a string, or left unspecified.

(define-maybe string)

(define (serialize-string field-name value)
  )

(define-configuration baz-configuration
  (name
   ;; If set to a string, the `serialize-string' procedure will be used
   ;; to serialize the string.  Otherwise this field is not serialized.
   maybe-string    ; equivalent to (maybe-string *unspecified*)
   "The name of this module."))

Wie bei define-configuration kann man ein Präfix für Serialisierernamen als Literal mit prefix angeben.

(define-maybe integer
  (prefix baz-))

(define (baz-serialize-integer field-name value)
  )

There is also the no-serialization literal, which when set means that no serializer will be defined for the “maybe type”, regardless of whether its value is set or not. define-maybe/no-serialization is a shorthand for specifying the no-serialization literal.

(define-maybe/no-serialization symbol)

(define-configuration/no-serialization test-configuration
  (mode
   maybe-symbol
   "Docstring."))
Scheme-Prozedur: serialize-configuration Konfiguration Felder Liefert einen G-Ausdruck mit den Werten zu jedem der

Felder im Verbundsobjekt Konfiguration, das mit define-configuration erzeugt wurde. Der G-Ausdruck kann mit z.B. mixed-text-file auf die Platte serialisiert werden.

Scheme-Prozedur: empty-serializer Feldname Wert

Ein Serialisierer, der nur die leere Zeichenkette zurückliefert. Die Prozedur serialize-package ist als anderer Name dafür vordefiniert.

Nachdem Sie einen Konfigurationsverbundstyp definiert haben, haben Sie bestimmt auch die Absicht, die Dokumentation dafür zu schreiben, um anderen Leuten zu erklären, wie man ihn benutzt. Dabei helfen Ihnen die folgenden zwei Prozeduren, die hier dokumentiert sind.

Scheme-Prozedur: generate-documentation Dokumentation Dokumentationsname Ein Stück Texinfo aus den Docstrings in der

Dokumentation erzeugen. Als Dokumentation geben Sie eine Liste aus (Bezeichnung Felder Unterdokumentation ...) an. Bezeichnung ist ein Symbol und gibt den Namen des Konfigurationsverbunds an. Felder ist eine Liste aller Felder des Konfigurationsverbunds.

Unterdokumentation ist ein Tupel (Feldname Konfigurationsname). Feldname ist der Name des Feldes, das einen anderen Konfigurationsverbund als Wert hat. Konfigurationsname ist der Name dessen Konfigurationsverbundstyps.

Eine Unterdokumentation müssen Sie nur angeben, wenn es verschachtelte Verbundstypen gibt. Zum Beispiel braucht ein Verbundsobjekt getmail-configuration (siehe Mail-Dienste) ein Verbundsobjekt getmail-configuration-file in seinem rcfile-Feld, daher ist die Dokumentation für getmail-configuration-file verschachtelt in der von getmail-configuration.

(generate-documentation
  `((getmail-configuration ,getmail-configuration-fields
     (rcfile getmail-configuration-file))
    )
  'getmail-configuration)

Für Dokumentationsname geben Sie ein Symbol mit dem Namen des Konfigurationsverbundstyps an.

Scheme-Prozedur: configuration->documentation

Konfigurationssymbol Für Konfigurationssymbol, ein Symbol mit dem Namen, der beim Definieren des Konfigurationsverbundstyp mittels define-configuration benutzt wurde, gibt diese Prozedur die Texinfo-Dokumentation seiner Felder aus. Wenn es keine verschachtelten Konfigurationsfelder gibt, bietet sich diese Prozedur an, mit der Sie ausschließlich die Dokumentation der obersten Ebene von Feldern ausgegeben bekommen.

Gegenwärtig gibt es kein automatisiertes Verfahren, um die Dokumentation zu Konfigurationsverbundstypen zu erzeugen und gleich ins Handbuch einzutragen. Stattdessen würden Sie jedes Mal, wenn Sie etwas an den Docstrings eines Konfigurationsverbundstyps ändern, aufs Neue generate-documentation oder configuration->documentation von Hand aufrufen und die Ausgabe in die Datei doc/guix.texi einfügen.

Nun folgt ein Beispiel, wo ein Verbundstyp mit define-configuration usw. erzeugt wird.

(use-modules (gnu services)
             (guix gexp)
             (gnu services configuration)
             (srfi srfi-26)
             (srfi srfi-1))

;; Feldnamen, in Form von Scheme-Symbolen, zu Zeichenketten machen
(define (uglify-field-name field-name)
  (let ((str (symbol->string field-name)))
    ;; field? -> is-field
    (if (string-suffix? "?" str)
        (string-append "is-" (string-drop-right str 1))
        str)))

(define (serialize-string field-name value)
  #~(string-append #$(uglify-field-name field-name) " = " #$value "\n"))

(define (serialize-integer field-name value)
  (serialize-string field-name (number->string value)))

(define (serialize-boolean field-name value)
  (serialize-string field-name (if value "true" "false")))

(define (serialize-contact-name field-name value)
  #~(string-append "\n[" #$value "]\n"))

(define (list-of-contact-configurations? lst)
  (every contact-configuration? lst))

(define (serialize-list-of-contact-configurations field-name value)
  #~(string-append #$@(map (cut serialize-configuration <>
                                contact-configuration-fields)
                           value)))

(define (serialize-contacts-list-configuration configuration)
  (mixed-text-file
   "contactrc"
   #~(string-append "[Owner]\n"
                    #$(serialize-configuration
                       configuration contacts-list-configuration-fields))))

(define-maybe integer)
(define-maybe string)

(define-configuration contact-configuration
  (name
   (string)
   "The name of the contact."
   serialize-contact-name)
  (phone-number
   maybe-integer
   "The person's phone number.")
  (email
   maybe-string
   "The person's email address.")
  (married?
   (boolean)
   "Whether the person is married."))

(define-configuration contacts-list-configuration
  (name
   (string)
   "The name of the owner of this contact list.")
  (email
   (string)
   "The owner's email address.")
  (contacts
   (list-of-contact-configurations '())
   "A list of @code{contact-configuation} records which contain
information about all your contacts."))

Eine Kontaktelistekonfiguration könnte dann wie folgt erzeugt werden:

(define my-contacts
  (contacts-list-configuration
   (name "Alice")
   (email "alice@example.org")
   (contacts
    (list (contact-configuration
           (name "Bob")
           (phone-number 1234)
           (email "bob@gnu.org")
           (married? #f))
          (contact-configuration
           (name "Charlie")
           (phone-number 0000)
           (married? #t))))))

Wenn Sie diese Konfiguration auf die Platte serialisierten, ergäbe sich so eine Datei:

[owner]
name = Alice
email = alice@example.org

[Bob]
phone-number = 1234
email = bob@gnu.org
is-married = false

[Charlie]
phone-number = 0
is-married = true

Vorige: , Nach oben: Dienste definieren   [Inhalt][Index]