Ask feature for auto installation

[jreidinger]

Ask List Feature

The idea of this document is to document an Agama approach to dynamic autoinstallation
profiles based on user interaction via UI. It should cover
All use cases for AutoYast Ask List feature.
The example use cases for this feature is when customer has some deployment
and wants user to decide configuration on system, but on higher level than installer.
such as setting up the network according to the given office location, partitioning
based on the role of the machine in the server room, or security settings based on
required certifications for given machine.

Below is a list of different ideas/possibilities how to implement this in Agama. Nothing is decided yet
but it can be used as a basis for decision and implementation.

Part of JSON profile

This is basically similar way as ask feature in AutoYast. Having question specified directly in some format
in JSON profile and then update profile according to answer. ( Note: AutoYast ask feature also allows to set
variable or write answer to file, probably for possible use in post install script).

Pros:

• Already familiar to Autoyast users
• it is just an extension of the profile
• can be validated via JSON schema

Cons:

• It is not flexible and limits users
• Can quickly become as complex as the ask feature in AutoYaST
• Can be difficult to test all possible configurations

Example: Ask for Root password

{
  "questions": [
     {
       "text": "Specify root password",
       "type": "password",
       "path": "root.password"
     }
  ]
}

Example: Ask to specify ipv4 gateway for primary connection

note: missing type means use default text based question

{
  "questions": [
    {
      "text": "Specify ipv4 gateway",
      "path": "network.connections.0.gateway4"
    }
  ]
}

Encourage CLI usage

Agama provides CLI for asking questions with options to specify either just a button
click, text field, password field
or selection, either exclusive as radio buttons or non-exclusive as checkboxes.
And the user has freedom what to do with the result of this question. The answer can be
to edit profile, do something directly in shell or e.g. provide it as input for jsonnet.
The CLI for asking questions can also be used in pre/post scripts and base some action on user's decision.
decision. For example, some additional software installation and configuration can be done in a
post-installation script based on checkboxes where the user selects what he wants additionally.

Pros:

• very flexible
• most parts are already there
• can also be used in pre/post scripts

Cons:

• too complex for trivial issues
• not so user-friendly for users without scripting experience
• requires testing by users

Example ask to specify role of server

Note: this example shows usage of another ideas of separate question file and
also using jsonnet for processing result. But it is not limited to it.

The example expects that admin already prepare files:

1. question in json format
2. jsonnet auto installation profile that use passed value.

Question file question.json

{
  "generic": {
    "class": "Ask.Role",
    "text": "Select role which machine will serve.",
    "options": [ "ok" ],
    "defaultOption": "ok",
    "data": {}
  },
  "withSelection": {
    "items": [ "ftp", "dhcp", "vm" ],
    "preselected": "ftp",
    "exclusive": true
  }
}

snippet from profile.jsonnet

"software": [
  {
    "patterns": (
      if std.extVar('role') == "ftp" then
        [ "ftpPattern" ]
      else
        {}
    ),
  }
]

script to pass to agama.auto

agama download ftp://myserver/question.json > /root/question.json
agama download ftp://myserver/profile.jsonnet > /root/profile.jsonnet

agama questions ask < /root/question.json > /root/answer.json
# TODO: should I use more flexible but also complex jq for answer processing? or even some ruby/perl/python code?
RULE=$(grep selected: /tmp/test.json | sed 's/^[[:space:]]*selected:[[:space:]]*\(.*\)/\1/')
jsonnet --ext-str role=$ROLE /root/profile.jsonnet > /root/profile.json
agama profile import file:///root/profile.json
agama install

Jsonnet support

Idea is to pass result of question as jsonnet extvar, allowing to do complex modification of json profile.
The source of question can be either in jsonnet ( so it needs initial processing with empty extVars to get
(so basically using questions as part of profile idea), in external questions.json file
or passed from other sources ( e.g. CLI ).

Pros:

• Consistent with dynamic profile approach

Cons:

• not sure how users will accept json format
• needs to have default behavior for extvars if not defined
• Cannot validate jsonnet

For example, see example in Encourage CLI usage with possible combination of example for question in json profile.

Possible options

This section is just a different organization of ideas from an implementation POV. It shows options for implementation
and does not mean that only one option can be implemented or that all of them must be implemented.

Where Ask List is specified

• JSON profile for agama
• separate JSON file
• jsonnet file ( require that it can be evaluated without answers to questions )

How JSON format looks like

• improved format for existing questions (like providing defaults, more options, etc.)
• own format specific to question list

How the response is processed

• Update JSON profile
• extVar for jsonnet
• use it in script based profile
• use it in pre/post install script ( check usability of Json response from CLI )

Notes

Few notes that do not fit into ideas, but is worth mentioning.

• Question API is already there and also CLI interface, so ideally it just needs to be extended to support new types of selections.
  There was a discussion if composition is the best from user POV or if it needs another layer on top that is even more user friendly.
  The layer may also be needed to provide defaults where it makes sense. Current CLI does not support defaults.
• Question: CLI API needs JSON schema defined and accessible.
• Good documentation and test coverage is a must have

[ancorgs]

script to pass to agama.auto

So the user needs to generate such a relatively complex jsonnet and also a script with 10 lines including a regexp?

I'm really not familiar with the topic and how it is done now on AutoYaST, so I'm just commenting from a very high-level (uninformed) point of view. But if I understood correctly what the user needs to do, I find it a little bit too much.

Our users already tend to create complex and kind of hacky solutions relying on the internal technologies of AutoYaST... which is sometimes great but sometimes also a problem for us. This seems to push users a bit to continue in that direction instead of providing some more high-level abstractions.

As said, is just an uninformed perception, but it feels to me a bit in the line of "you have scripts and files, so you can do anything... you just need to build it yourself".

[jreidinger]

well, as we discuss we provide one high level that will be for trivial cases which needs to adapt single value and then we provide API for customers to do it how they need. So one is high level and second is flexible.
If customer wants, it does not need to be jsonnet, it can be anything they would like to use to generate json or even run autoyast via CLI. Also about regexp they can use jq or any scripting language they are familiar with to parse json.
Basically idea of flexible solution is to provide CLI API to customers to ask question and then do with answer whatever they want.
So trivial API has simplicity of config file. And flexible solution has power of scripting language.

[joseivanlopez]

After reading the examples, me as user would prefer to simply indicate questions (complex or not) directly in the JSON profile. Passing a separate file with questions and also a custom script could be too complex. But I like the usage of jsonnet and extVar to dinamically solve the profile. We are already offering jsonnet as solution for dynamically generating a profile, and this is yet another case of dynamic profile.

What about the following (disclaimer: I am basically thinking aloud)?

1. The user provides a jsonnet profile, which contains a questions section.
2. Agama reads the questions section and ask to the user (with agama questions ask ?).
3. Agama pass the answers (--ext-var) to the jsonnet profile.

I don't know if 2. if possible. Maybe we need to generate a JSON from a jsonnet without passing any extVar and read the questions. Of course, questions cannot use jsonnet syntax.

And for 3., I think the question definition should indicate the name of the variable in which to store the answer. Then Agama can solve the jsonnet file with that extVar data.

If all that is possible, then a user only has to provide a jsonnet file with a questions section and use extVar along the document to get the anwers.

[imobachgs]

I agree that the proposed solution is somehow complex. In AutoYaST we include the questions in the profile, it makes sense.

However, the AutoYaST case is slightly difference. In Agama we need to solve the jsonnet first (to get the questions) so we need to make sure that it solves to a valid profile even when the questions are not answered yet. Otherwise the validation may fail (or not).

If that's not posible (it should be), we could use a separate JSON file to define the questions (but the you cannot use Jsonnet to define the questions).

Or am I missing something?

[joseivanlopez]

I don't know whether we can solve a jsonnet file whithout providing the extVars. If so, Agama could do the following:

• Solve jsonnet without passing any extVar.
• Get the questions from the resulting json (and discard such a json after that).
• Ask to the user using the questions info.
• Solve the jsonnet file, now with the proper extVars containing the answers.

Anyway, soving jsonnet without extvars, only for getting the questions, sounds a bit hacky. Maybe there is another way.

[imobachgs]

That's what I meant, the Jsonnet should be "solvable" without passing any extVar (e.g., you need to have default values).