Since this CMakeLists.txt writes out a C program, the formatting
is a bit weird; just start the written TU with a blank line to
make gersemi happy and keep the C-code aligned.
To avoid git complaining about duplicate worktrees, detach
the temporary trees. To avoid python modules translations
changing order (depending on how find traverses the tree),
sort the filenames before extraction.
- find the best score and match relative to a specific
set of parts; make it easy to update the country-setting
- look for a complete match, or best match, with three
country settings
Argument *text* is an addition in 3.7, while the Calamares 3.3
branch supports Python 3.6 and later. Use the 'backwards compatibility'
name of the parameter, *universal_newlines*.
Cherry-picked from 33961ff6f (in the 3.2 branch, though, Python 3.3
is supported).
- Put this in a method of its own even though it's used
only once, so we can put a good name on it.
- If there are no FS choices (e.g. the sample settings file)
then there is no combo-box, and the check was crashing.
FIXES#2029
This works around older CMakes that refuse to set arbitrary
properties on a target. Instead, use calamares::kpmcore
as the specific indicator that kpmcore was found.
Breaks build of libcalamares, since that needs **something**
regardless of whether KPMcore was found.
- wrangle the test framework so it hands the same data to
two different collections of tests; do KDE neon and FreeBSD
separately so it's clearer which lookups are being done
(and a failure in one doesn't prevent the test of the other).
- the alias libraries calapmcore and calamares::kpmcore
are always created; if there is no KPMcore, they handle
definitions to signal that.
- upstream kpmcore target is the one we should be testing
to see if KPMcore itself is there (or, use KPMcore_FOUND).
- FileSystem.h depends on KPMcore and only compiles when
KPMcore is present; it can use KPMcore identifiers.
- Global.h doesn't.
- Move the few functions introduced into Global.h that need
KPMcore, to FileSystem.h instead.
When KPMcore is present, the calamares::kpmcore wraps that
and provides suitable API detection. If KPMcore is not
present, the same interface library provides -DWITHOUT_KPMcore.
- kpmcore (when used as target "kpmcore") has an interface
include directory that does not contain the "kpmcore/"
subdirectory. But the headers it has installed, assume it
is there (e.g. kpmcore internals use #include <fs/filesystem.h>).
- add an alias at Calamares level that sticks in some more
includes, adds the relevant WITHOUT_kpmcore when it's
not there, etc.
The distinction CalamaresUtils and Calamares is old-fashioned,
since we can use nested namespaces (and already do) for a lot
of things; make libcalamares/locale/ a bit more consistent
by using namespace Calamares::Locale for everything.
Some distro's let the user change the hostname at will;
others don't, and yet others don't have systemd to change
the hostname with at all. Check if we **can** change the
hostname (as a non-root user), before setting expectations.
- remove "bogus" key when it's not needed
- check for existence of "branding" key in GS before
subscripting it (this happens in tests, where no
GS contents are loaded, but not in regular use,
where startup loads the branding data into GS)
The schema is considered invalid by **some** versions of
configvalidator (or rather, the underlying jsonschema):
```
128: '#definitions/groups' does not match '^[^#]*#?$'
128:
128: Failed validating 'pattern' in metaschema['properties']['definitions']['additionalProperties']['$dynamicRef']['allOf'][0]['properties']['$id']:
128: {'$comment': 'Non-empty fragments not allowed.',
128: '$ref': '#/$defs/uriReferenceString',
128: 'pattern': '^[^#]*#?$'}
```
Remove the `#` from the IDs.
- can't use *bogus* as a key unless that's allowed by
the schema -- and it is not.
- can't supply empty config if there is supposed to be
an object there.
This makes it a little difficult to allow a config-file
that is actually no-configuration-at-all (or only-defaults).
Put in values for *btrfsSwapSubvol* since it isn't a fragile
setting.
Looks like clang-format was applied to this JSON schema
file in 5a14c3c76f, which is
completely borked. Restore from earlier revision, now
with just `machineid` removed.
A stray "machineid" was added, without a type definition,
so the config file -- which doesn't mention machineid at all
-- was considered invalid. Drop it because the key isn't mentioned
anywhere else.
This applies to the Debian nightly builds; having to go through
external actions doubles the effort to debug these kinds of
scripts, so just slap the actual commands into the workflow.
This also makes it easier to migrate to a different hosting.
- this would be the first 3.3 release, scripts still needed
cleanup to handle all the changes in 3.3
- support "-alpha1" kinds of designation
- support more versioning information in the headers
This was removed (in favor of DBus activation) but DBus activation
does not work; re-import the latest version, now under the MIT
license. Pull in only src/ and the license file, though.
https://github.com/KDAB/KDSingleApplication
9dc8b2f61638aa1c4dbf49d38f8b97178974409f
- expand tests to include Serbian variants
- massage detection code to do better filtering based on
country-selection (so "American English" doesn't later
pick "English" with Antigua and Barbados for locale)
starting with 217e4ab4f7
the messages have expanded, no longer fitting in the used ListView model
set the text blocks to expand with text size, add a scrollbar
reduce top spacing so underlying image won't show
set the full requirements listing as default
This looks to be a remnant from moving this to the mount module
which left an undefined variable. The mount options are now part
of the globalstorage and consumed here as mount_options_list.
FIXES#1980
When the checks were done, the widget showing the countdown-timer
and results was not being informed, so it didn't update the
display of the countdown timer or hide the list of problems
(when there are none) so that the welcome image is shown.
FIXES#1974
- this uses the Qt internals to map enum values to names, making
the separate translation table unnecessary. Adjust default branding
to use the new names.
This makes code (using enum identifiers) and configuration (using
string keys) consistent in naming.
- previous commits did not fix up all the enum names; this means
you get errors -- because Branding.SidebarTextSelect is not a known
name in the enum Branding::StyleEntry -- and the colors are messed up.
- DebugWindowManager already manages not-really-Calamares windows
like the Debug window, add About-Dialog to its responsibilities.
- Make about() accessible to the QML progress panel.
- log which path is actually being used
- there are two overloads for QTranslator::load(); the intention
was to call `QTranslator::load(const QLocale&, ...)`, but the
types of the arguments were wrong, leading to the other
overload being called, and interpreting the locale-name
(e.g. "nl") as a full filename.
Improve logging, call the "other" overload with the right parameters
and drop the not-needed ones.
FIXES#1961
Adds a new option / configuration keys to `fstab.conf` to
configure how /tmp is created. The example shows how /tmp
is made *tmpfs* on an SSD, or on not-SSD, is just-a-directory.
FIXES#1818
- for QML, this is the easiest way to factor out the message
(no convenient access to free functions, unless I bung the
message into e.g. Branding where I don't think it fits
very well).
Previously, state() just returned a stored state, which changed
via updateState(). However, when updateState() started taking
visibility-of-the-widget into account, it became possible to
de-sync the *apparent* state of the encryption widget, from the
stored one:
- make an encryption widget, which is not visible
- show it.
Now the stored-state takes visibility into account that is
different (hidden, so we end up with a state of Unconfirmed)
from the apparent value (shown and unchecked).
Move the calculation to state() instead, so whenever queried,
it checks the current checks-and-visibility values. Restore
the previously-reverted bit for accepting LUKS partitions.
SEE #1935
SEE #1953
- a hidden checkbox should not be handled the same as a checkbox
that is checked; if there is a setting that can be checked or
unchecked, it can only be checked when visible.
FIXES#1953
- Improve the messages a bit
- Remove useless variable (it is checking that the switch(choice)
statement covers all the cases; let's leave that to the compiler)
esri has several bugs, not showing for all locations, zooming on Americas broken
use osm as default, set preferred, so esri can be fallback
remove Label section for mouse movement, showing coordinates not really useful,
issue with mouse grabbing is back with it
On FreeBSD, at least, `find_package(Boost COMPONENTS python)`
doesn't work well, while `find_package(boost_python)` does the job.
Be somewhat more flexible: look for boost_python first, assuming
it pulls in the rest of the Boost bits it needs.
- in 3.3, the legacy values are ignored, so all the old-style
tests behave as if nothing is set at all.
- Some tests used old-style settings, adapt to newer ones.
RC (in the 3.2 branch) and RELEASE_MODE are inverted, logically,
but the change to the CMake check wasn't properly inverted.
This only matters if you try to build Calamares in the src-dir,
which is something I never do anyway.
Some QPainter enum values were deprecated in 5.14, and since we
require 5.15 now, we hit some old code paths with now-deprecated
values; this only shows up when actually enforcing deprecations.
Because of the way Qt interprets the environment variable
LANG, using `sr@latin` or `sr@latn` or `ca@valencia` would
get you `sr` or `ca`, respectively, which isn't an exact
match. Now that Translation has special-handling for
those values of LANG, match with the ID first.
This allows starting Calamares in Serbian (Latin script)
or Catalan (Valencia) for locales that need it. (Qt doesn't
recognize ca@valencia as a variant, since that's a region-
based locale, not country- or script-based)
Setting labels (e.g. in manual partitioning) landed some time
ago, but the progress display still shows a raw device path.
Make it more expressive.
FIXES#449FIXES#540
- this makes createBootloaderComboBox obsolete, since that was
an implementation detail for creating the panel.
- add the panel also when doing an alongside install.
- credits to Anubhav, whose PR started this code.
The model was emptied-and-refilled when re-checked, which
meant we needed to have some special handling when messages
changed to avoid re-creating widgets. Since we use a model
view now, we don't need the extra machinery.
This is a rather clunky implementation of re-check requirements.
"Clunky" because the UI parts are re-created each time, rather
than fishing from a model of checked (or unchecked) requirements.
The Widgets parts should be updated to use a full model, rather
than the recreate-list-of-Widgets implementation they have now.
Unrelated changes pull in a bunch of improvements to the
waiting spinner widget.
Although this is 3rd-party code, it now diverges -- by merging the
stale PR from upstream, and from adding features of our own --
enough that we should not pretend that it is the original 3rdparty
code.
Chase a couple of include paths that called this from 3rdparty/
The setText() support was submitted upstream at
https://github.com/snowwlex/QtWaitingSpinner/pull/14
by `huxingyi <huxingyi@msn.com>`, but not merged. The
commits from that PR were merged into Calamares' copy
of the waitingspinnerwidget files. Add relevant tags
(which aren't in the PR, but Calamares does chase SPDX)
While here, make it possible for the "screen" (screen-size) check
to be mandatory; there's no reason it shouldn't follow the same
logic as all the others (although denying users an install because
they have a VGA monitor seems a bit weak).
- While this is primarily convenient for testing (e.g. checking
that a command is expanded the way we expect), it simplifies
some of the code because it's now clear that run() uses an
expanded copy of the command-list to do the actual work.
This is a step towards getting rid of CalamaresUtils and
using more structured namespaces overall, e.g. Calamares::String
for things related to string-handling.
Exactly one kind of setting-hostname is done, and that's
entirely independent of writing /etc/hosts. Don't make it
a set of flags, use an enum and a bool.
readTargetFile was not fully reading files because of an incorrect
EOF check. This could cause /etc/openswap.conf files to be
truncated and hibernation to fail on installed systems.
- _find and _each Doesn't need to be part of the class API
- Rename to *Transform() because that's more in-line with what it
does, applying an operation to the tree.
Reduce warnings by using unsigned consistently; this fights
the KPMCore API (which uses signed sizes for, e.g. sectorSize)
a little, but states more clearly that a disk cannot have a
negative size.
The widget name is used (by moc) to inform the name of the
member variable storing the widget; having a :: in the name
yields a member variable with __ in it. Two _ is reserverd
to the implementation.
This is mostly a confirmation that the subsequent changes
to #1905 were correct; the "name" key set in a partition
configuration is applied to the partition.
FIXES#1904
Extend the test to (try to) restore whatever hostname was set
before the test ran; this avoids mangling systems where tests
are run as root in a host / production environment.
FIXES#1908
Scrolling explicitly to the bottom isn't needed; leaving it
up to appendPlainText() has the following behavior:
- if the text is scrolled all the way down, follows the text
and scrolls further down (tailing)
- if it is not scrolled all the way down, keeps current position.
Existing code reinitialized the layout, losing whatever
layout was set in the config. Refactor so that you can
access the partition-layout API, and change the default
FS through that -- which is the point of the code block
here in `doAutopartition()`, to look up the currently-
selected default FS.
Inspired by Santosh's work in #1903, #1759.
By default, calamares renames the label of root partition
to "root" overriding the name specified in partiton.conf
Signed-off-by: Santosh Mahto <santosh.mahto@collabora.com>
- basename() returns the last path component, so never includes
the leading '/dev/'
- the check for mmc and nvme looked for device names starting
with '/dev/mmc' .. but '/dev/' has just been stripped away
by the call to basename, so this never matched
- stripped the trailing digits rather than trailing 'p[0-9]',
so 'nvme0n1p2' became 'nvme0n1p' which isn't a useful
device name.
FIXES#1883
Don't do the actual KPM work, but pretend that they were done.
This can be useful -- independently of the existing unsafe-
options and failing partitioning entirely -- for testing
partition layouts in modules following the *partition* one.
- the length parameter to diskDescription() is worse than
useless, because it doesn't say anything about what will
be done if there's more than one disk.
If there are no modules at all before an exec: section is
reached (e.g. right now due to a bug in module-loading)
then the last() call would crash. Instead, use a nullptr
for the last-module-loaded.
While here, apply code-formatting.
If the hostname changes while the field has focus, that means
that the user is typing in the field, and we shouldn't mess
with the cursor position.
FIXES#1884
- use clang-format12 or 13 or unversioned executable, only
- check it's actually 12 or 13
- set language standard explicitly to C++17, "Cpp11" is now
an alias for "latest" which is weird
This change does lead to some thrashing when applying styles,
so I'm not going to do that across the board right now. Changes include:
- extra spaces in lambda-captures
- nicer alignment of lambda-bodies
- if nothing is selected (index -1, which now shows the placeholder), the text is empty
- if something has been entered, return it (e.g. if the user is typing)
- if something is selected, the text gets set to that anyway
The warning about the mount point -- that it was in-use or
invalid -- had been separated from the drop-down by the
FSLabel field. Move it back, rename the variable for
clarity while we're at it.
- make the boxes expand, rather than stick to a minimum
size that doesn't align with other boxes in the dialog,
and which may be too small to contain the text they display.
Avoid logs like
23:29:57 [2]: void Config::setConfigurationMap(const QVariantMap&)
WARNING: Configuration for *initialSwapChoice* is not one of the *userSwapChoices*
WARNING: .. Choice "small" added.
where the label is duplicated.
There is a mismatch between how the configuration interprets
*initialSwapChoice* when it is not a valid choice, and how
the UI interprets it. If you e.g. do not have a *userSwapChoices*
setting at all, whatever *initialSwapChoice* is set is interpreted
by the UI as "suspend".
Avoid that by putting the choice in the configuration and
warning the user (which ought to be a warning to the distro).
FIXES#1881
- mark some TODO
- tighten up the YAML schema a little bit
- when unset, use 'quiet' rather than empty, to preserve compatibility
with existing configuration files.
SEE #1882
This is the infrastructure bit; if someone can come up with a way
of **meaningfully** detecting support, the detection function can
be given a better implementation.
FIXES#1725
- expectation derp11 was wrong, there were only 10 calls to next()
- using whole name instead of the not-the-suffix-bit was wrong
- phrase generator wrong length
It may be easiest to modify the efiBootloaderId, since that does not
normally show up in the UI. I cannot quickly come up with a way to
do the same kind of suffixing on the user-visible name.
SEE #1820
- the first time we arrive at locale, there isn't a current location
and the setCurrentLocation(...) method ends up calling setLanguage(),
usually. The second time, this call is skipped (not called from
the overloaded setCurrentLocation() which is called from onActivate),
so the language didn't update.
- now call setLanguage() unless there has been one set explicitly.
onActivate of locale updates the language only when currentLocation changed
or when onActivate of locale is called for the first time.
However, It is irrelevant solution since the language is set by the welcome.
So language should be updated always.
The language is used by keyboard module to guessing a layout of keyboard.
Once you face the locale, you can't change language in the welcome
if you don't change the timezone.
- the module is 'unpackfs', not 'unsquash'
- add a warning + specific error if there is no unpack key in the config
- the 'doing nothing' part isn't true: the module errors out instead
of doing nothing.
SEE #1870
This strips out the === from KPMCore reports so that they are
more readable when presented in the error dialog. Introduces
some code-conveniences, too, but that is all under-the-hood.
- Use the Calamares support-functions for running lsblk and mount
(these might need to have privilege support if Cala is not
running as root, so this is future-proofing)
Most *partition* module jobs run an operation and turn that into
a JobResult -- ok if it succeeds, and with the report text otherwise.
Factor it out into a separate method that can be used as shorthand.
Put the Item class in a separate header; give it functionality
to create itself from Variants (e.g. from the configuration data)
and to run itself (do whatever the item is supposed to do).
This makes the polymorphic approach unnecessary: we just have
items that are sufficiently smart.
This moves do-a-thing to the Item, while the Job now has one
job: be a loop around creating Items and running items.
The filenames don't matter, but the contents of the file are also
UTF-8, and depending on the default encoding of the Python
interpreter, this can fail on non-ASCII characters in the
file. Set the encoding explicitly while reading and writing
the NetworkManager configuration files.
FIXES#1848
- modules with no configuration should be marked 'noconfig',
but umount is special: it has no **useful** configuration
(maybe no **non-deprecated** configuration), but isn't
marked 'noconfig' **yet**.
- this module needs work to handle BTRFS special-cases *anyway*
- limited in scope, few options: port it while doing the
special-cases
So far, this is just a C++ stub.
SEE #1659#1644
The translations apply to labels and a tooltip, which depends on
the partition-table type. Move the strings together and make
the whole range of the switch explicitly.
- some switch statements handle a bunch of items explicitly,
then default the rest. Clang complains about that. Turn off
the warning for these specific switches, since there's dozens
of values that simply do not need to be handled.
We want to use the KPMCore function consistently, but Calamares
uses a qint64 most of the time. Centralize the cast to double
in one place in the code.
- these are internal classes, with no real Qt machinery; remove
the Q_OBJECT macros.
- replace the tr() calls with calls with an explicit context,
so that translations do not change.
The ordering of entries jumps around sometimes when reading from
Transifex (this might be Python unordered dictionaries, or based
on translation statistics -- I can't tell). Force an order by
sorting on language code and key-name so they all end up grouped
by language code, sorted Name Icon GenericName Comment.
Although this shuffles some more entries now, longer-term it
will reduce churn in the .desktop file.
If there is no subvolume set, skip creation of that subvolume.
This allows root to be on a bare FS, without a tag or subvolume
name. To achieve this, use
subvolume: no
(no quotes there) in the YAML.
Timezones 5.0 and 5.5 have considerable overlap; clear up most
of it. Since a pixel is about 55x55km on the ground, and the
translation of latitude and longitude is sketchy at best,
accuracy on this timezone map is not very good.
FIXES#1832
- typo (canmount vs canMount)
- the canMount property is nominally a string, but YAML is 'special'
and interprets 'on' and 'off' and 'yes' and 'no' and other strings
as booleans unless quoted.
- log device node (/dev/sdb) instead of its name
- don't log job's prettyName() because that's translated, and also
contains user-visible private names (introducing a non-translated,
nicely redacted version of prettyName() seems like too much effort
for something that can be reconstructed from bits earlier in the log)
- use hex-trailer
- while here, convert DebugRow to use a copy rather than a reference,
to avoid dangling references when applied to temporaries
- convert *partition* module to use the RedactedNames
- toml.dump() takes a file-like object
- toml.loads() takes a whole string to parse, (e.g. the TOML data),
not a pathname, so change to toml.load() which takes a file-like
object.
- If the config file doesn't exist, the dictionary is empty
- If it **does** exist, it might not have key 'default_session' in it
Either case should avoid a KeyError by using get() (or setdefault,
in this context). Subsequent use of os.path.exists() is strange,
since the value is a **group** (e.g. a dictionary) in the config
file. Just check if it exists, and then fill something in.
This gives at **least** a proof-of-concept for progress
during package-installation. It's up to the package-manager
or distro to write better progress reporting.
FIXES#1582
- the (n/m) lines are output of specific steps, not actual package-
installation. So look for "<action> <packagename> ..." lines instead.
This means we keep some state around, and need extra machinery to
report those lines rather than the generic progress reporting
that reports on groups.
- during install and remove, check for (n/m) output lines which
report progress of the pacman actions and turn those into progress
reports for the *packages* module.
- remove from GS
- remove duplication across Config and ChoicePage
- improve translations (presumably "msdos or gpt" is the most
complicated it will get)
FIXES#1735
- the partition module makes a nice descriptive widget,
which includes the text it **also** has for the summary;
(the text is intended for the QML summary).
- In general, if a module has a widget for the summary, assume
that that is the **whole** summary and use it instead of text.
This resolves duplicate summaries -- showing the text of the
partitioning-step, followed by its widget -- introduced in July.
- make the installation work,
- special case because rsync can return error 23 (which throws, from
inside the Python API) which still means "it was ok".
SEE #1740
By processing each line in turn (and just counting is) rather
than collecting all of the lines of output from the tools,
we end up with lower memory usage.
- document a bit more of the methods
- provide convenience method enableOutputProcessing() alongside
an explicit setter; adjust tests to the changed API.
- add an executable() information method.
- this was an internal class for logging commands, let's lift
it up to the Logger framework where it might be more generally
useful (or not .. everything needs special-casing for actual
redaction).
This is an experiment in Python API that will allow a callback
function in the Python module to be called for each output line.
It builds on the run-a-process extensions that are being built
simultaneously.
The background idea is that, while CalamaresUtils::System::runCommand()
is a useful general API, it is
- still missing flexibility
- lacking a way to process output from the command "as it happens"
Waiting until the process ends, and then reading all stdout, is
inconvenient for processes that produce a **lot** of output,
and also makes it impossible to report progress. One module
in calamares-extensions has its own run-a-process implementation
for reading output, and this branch aims to introduce something
similar into Calamares core.
FIXES#1564FIXES#1817
Tested by doing an LVM installation from KDE Neon, as described
in #1817. Installation was successful, and machine booted
successfully afterwards.
- when (manually) using an existing LV, it shouldn't be closed
prior to formatting, since that kills the volume and then the
path (/dev/myvg/mylv) no longer exists. Then creating the
filesysytem on that device path fails.
- Strings were being used as logical values, and then logged
(which should be in English) and also used in the UI (which
should be localized). Replace with a MessageAndPath class,
used only locally, that defers the translation until called-
upon explicitly.
- Replace some VG stuff with similar calls to apply().
Returning partition full-paths instead of only the block-device-name
simplifies later code -- which would prepend /dev/ to the block-
device-name and umount that.
- the tryX() functions weirdly return a string that is used for
debug-logging. Document that. The untranslated string is
later used for user-facing messages. Mark that as FIXME.
- factor out the loop-over-names-and-append to news, because that
makes the overall story of what is happening hard to read.
- all calls to tryCryptoClose() called tryUnmount() first, so
put that call inside tryCryptoClose(), so the interface is simpler.
- improve descriptive-strings in logging ("set?" is not very
meaningful)
- log only the unsatisfied entries, since the preceding
log-message suggests that that is what is happening.
QLabel allows scaling of the Pixmap by itself, and we have a
FixedAspectRatioLabel that scales a pixmap nicely. Use that.
(The new label type needed to be introduced to designer)
The screenshot should expand more agressively, so that it
does not get margins -- that just leave space around the
name and description -- when the window expands. Adjust some
of the stretching and layout in the UI file.
It is easier to put screenshots somewhere where
they can be searched-for, rather than requiring either
absolute paths (inconvenient to try out someone's
settings) or relative paths (because who knows where
Calamares will be run during testing).
The summary page can rely on the Config object to create
lists of relevant steps; this code was declared but not
defined / implemented for Config (but also not called, so
it was ok). This is basically shuffling bits around in
preparation for using the model directly, rather than
re-implementing the widget-creation code.
While here, split off the page-resizing into a free function
so that the code reads nicer.
- the page doesn't need to remember what step it belongs to,
if the step tells it when creating widgets.
- detach naming from the viewstep API that calls it.
Nothing beyond the example module was ever built with the
PythonQt bindings, as far as I can tell. They have been
deprecated, defaulting OFF for over two years now.
QML modules fill the gap with customizable, run-time
interpreted UI and stronger support from the C++ side
of Calamares.
The `partition.conf` file contains an EFI-size. The default is 300MiB,
but distributions might like to use a bigger (or smaller) value.
Apply the configuration consistently everywhere where we need
"the size of the EFI partition". Extend the internal method
to look at the configured size.
Apparently everyone shipping a squashfs image also has the tools
installed, because the error message reporting that the tools-are-
missing contained a reference to an undefined variable.
Fix that, and while here improve the error message so you
don't get a whole path as a title in the error message.
The slightly weird error-message construction is so that no
messages change and no translation work is needed.
All **other** modules fully specify libcalamares; only unpackfs
was importing shortcuts. Change to conventional usage (partly
because that's easier on the pylint implementation, partly because
it's then consistent with the rest).
Apparently nobody ever hit the else-branch here (because
each DM has exactly one implementation -- that's what the
check is there for!) because the logging of the error
itself would raise IndexError or ValueError.
This introduces a stub-implementation (fake) that mimics the
API offered by libcalamares (the library is actually exposed
to Python via Boost::Python, so it doesn't act like a C-extension).
Using that stub-implementation, we can check Python modules for
validity as part of the test-suite.
The stub-implementation is needed, because otherwise every
Python module already fails at `import libcalamares`.
- stub-implement the API that is actually used by the Python modules
- in globalstorage, be slightly smart about what keys are being
requested (so that e.g. all the modules that handle partitions
information get an empty list and can manipulate that, instead of
erroring out when they get a string)
- Make clear that the @ is a string-location, and how long the
pre-script is (although in practice, it will be either null
and 0, or the values set in the loadmodule executable).
Read, then write, the NM file. Add a note about how we might
handle this better. Rename live_user() function to give it
a verb (and avoid UnboundLocal when using a variable of the same name).
This class doesn't really set a pointer -- it is a scoped assignment
through a pointer, which **can** set a value on destruction (when
it leaves scope). Rename it.
While here, extend the API so that it can do an assignment to the
underlying object **now**, while also doing a scoped assignment
later when it leaves scope. This makes some code a bit easier
to read ("in this scope, X is now <v> and then it becomes <v'>")
This class was used only once, and is confusing because
the assignment happens always, but to the opposite value
as what was visible. It can be replaced with other
scoped assignment, instead.
Removes the tests for it, too.
- when an emergency strikes, log the modules that are skipped
with a Once, but if an emergency module runs, refresh that
Once so that the function header is printed again -- to
distinguish JobQueue debugging from the logging from the
emergency module.
This is in response to the issue, and cleans up a bunch of code,
but does not actually resolve the issue (because I can't quite
tell what the issue should be).
SEE #1788
- iterate over the lines of the source file, rather
than over indexes, and make clear that the hooks, modules and files
lines are replaced, rather than merged.
- this calls write() more often, but it's only a few lines
- don't chain directly from modify_mkinitcpio_conf() to the
function that writes the file write_mkinitcpio_lines();
split into "figure out what needs to be written" and calling
that writing-function, so that we can test / check / log
if needed between the two.
- put the system-information and -detection functions at top
and the "do the actual work" things below
- don't mix the boolean do-we-use-this flags with the
lists of files and modules which are the important
parts of modify_mkinitcpio_conf
The tool "gersemi" [1] formats CMake code. It is an opinionated
and slightly simplistic "just work" formatter. Let's see how
it does on Calamares CMake code.
[1] https://github.com/BlankSpruce/gersemi
- Transifex tools complain about missing Q_OBJECT (which makes
some sense -- you end up with a different context for calls
to tr(), of the base class).
Move some of the texts to the new TranslationFix, from ViewManager,
and use them. Keep them in ViewManager, too, so that the translations
with context ViewManager are not removed just now.
This is intended to apply translations to some common Qt UI components.
Example: a QMessageBox with standard buttons OK and Cancel; the text
for that is determined at startup using the system locale, and later
changes to the current locale or the current translation catalog,
do not affect OK and Cancel. It might be possible to load a catalog
with the right translation strings, except that there is no way to
know what the context or catalog **is** for the strings that are
used to label standard buttons: they can come from Qt base, or
the platform, or the theme. Merely loading the Qt Base translations
for the correct language does not help, because those translations
do not contain an "OK" string with the context used for standard
buttons.
Do the translation by hand; then we have all of the Calamares
languages covered, too, which is more than the Qt translations do.
Move the CMake code responsible for building the translations from
the src/calamares directory (yeah, yeah, the translations need to
link into the executable) into lang/ (which is where the source
and other infrastructure lives).
Prompted by Linlinger, I've reconsidered the names of languages
in the drop-down in the welcome page. We already have the
infrastructure for assigning specific names / locales to
"Calamares locale names" (which match Transifex names, not
necessarily Qt names). Use that to put exactly two Chinese-
language translations in the drop-down:
- Simplified Chinese (code zh_CN)
- Traditional Chinese (code zh_TW)
Drop zh (which is a peculiar locale name anyway) and zh_HK
(which is Traditional Chinese, but using the geographic
boundary is a bit weird; we're going to ignore the
minor orthographic differences with Traditional Chinese
written elsewhere for now).
Note that this makes the drop-down show "Chinese"
in the English column, twice; the difference is visible
only in the native-language representation.
SEE #1741
rewrite of keyboardq.qml, reduce stackview to 2, use a combobox for
keyboard models list
colors set to configurable
.xml files used for keyboard layouts, about a dozen added now
builds, runs, actions record as intended, GS filled correctly
With old Qt, Calamares could only run one check on a thread,
because the NAM would be switched to NotAccessible --
subsequent checks would fail because the NAM is already
hard-set to NotAccessible, so it could never be turned back
on by Calamares code.
Reset the accessible flag for the NAM while checking if
the internet is there.
- India (when in English) should use the English variant, not Hindi
- While here, fix up minor items in code:
- Typo in comment
- Asturian doesn't need a special case (which didn't match, anyway)
- Don't debug-log a country-name that might be entirely wrong
(the layout is English, variant "in" but "in" interpreted as
a country is Indonesia, and the actually-desired name is eng_in
which isn't a QLocale name at all -- just like the Hausa and Igbo
special cases)
The test was loading the config file (for testing) either from the
build directory or possibly the source directory; if the config
in the build-dir was edited (for other testing purposes) then
the test would fail. Load only the source-dir version of the file.
- improve logging
- fix failing tests -- the observed and expected behavior is
to fill in a fallback check-URL, not change to an empty list,
- **except** if there's no requirements key in the config
at all; this is a bit weird, but let's make the tests
document existing behavior so we can notice if it changes.
- Setting 'id' (which changes the Global Storage key that
gets used) is a kludge when the existing module-instance
name can be used instead -- and **was** already used, as
a fallback when 'id' is not set. There's no point in having
two places to set a particular name.
- Rip out the docs for 'id' as well.
- Add documentation on the difference between single-selection
(the QML implementation) and model-selection (what the Widgets
version does).
- use updateGlobalStorage() for both single-selection and
model-based approaches, although the model-based one
needs extra parameters.
- complain about inconsistent settings and API calls (e.g.
setting a model and single-selection at the same time)
- pkgc -> packageChoice and similar for methods, variables
- document that this is the convenience value for one-selection
QML modules, not a full model
- use std::optional to keep track of which one is being used.
The Config object can hold all of the configuration information,
including also the requirements-checking parts. Move requirements-
checking configuration there, so it is shared and consistent
across welcome and welcomeq, regardless.
This repairs the test that expects the Config object to handle
**all** of the configuration, too.
- was filtering out the wrong URLs
- was not actually removing the invalid URLs
- extend API to make it possible to count / confirm the settings
- extend tests to demonstrate that API and the issues
- Branding, Settings, and ModuleManager may all be nullptr,
in which case the corresponding code shouldn't call methods
of those instances -- this is demonstrated by just creating
a Config object
- previously, updateSwapChoicesTr() wanted to be a static free function,
but it needs QObject::tr() ; drop the unnecessary parameter (since it
is a member function).
QString -> Id for translations in the external API, to avoid
accidentally converting a QLocale name (e.g. ca_ES) into a
Calamares translation name. This preserves special-cases
like ca@valencia and sr@latin.
- enforce consistent [PYTHON JOB]
- use CDebug() constructor, because the convenience macro's
introduce the function name -- that's the C++ function, so
it isn't useful for logging.
- when activating the page, the "guess" functions do their
work and afterwards the config is left in a "guessable"
state, but if the user makes a specific choice, then
the config leaves the "guessable" state and the user's
explicit choice is preserved.
FIXES#1744
- expose only intended API, guessLayout() becomes internal and static
- rename onActivate() since it was *called* for activation, but does
something totally different.
- Long and complicated, nested, lambdas are not convenient for reasoning.
- The debug messages from the innermost lambda have a totally useless
function name, which makes debugging harder.
- do not link (explicitly) to Calamares libraries, the CMake
functions do that automatically.
- while here, tidy and remove commented-out-bits
- while here, remove unneeded includes
- Modules and plugins don't need to mention libcalamares themselves
for linking -- we can do that automatically. Use the IMPORTED names
so that it works in Calamares main repo and external repositories.
- Complain about unknown module types.
- the message had been arbitrarily changed; change it back
- update (warning) message when there is progress in checking the
model, so it doesn't stay at "unchecked" until you change language
- minor clean-ups
Just have **one** Retranslator object, and install it as event-filter
(this needs to be done manually on a top-level widget) and use
signals / slots to do the actual work, rather than filtering
in multiple places and doing our own mediocre version of binding-
signal-to-lambda.
- The Config object owns the requirements model, and has messages /
strings describing the state of the model. Use that message,
dropping the duplicate message from the requirements widget.
- Re-jig to pass the Config object around rather than the model
that it owns.
- This does not work, because translation events do not arrive
(and the slot isn't called automatically either).
Rather than Config asking its (owning) ViewStep what the title
is -- all existing implementations have a prettyName() for that --
move the title into Config and re-do-the ViewSteps to use it.
Rename init() to something meaningful.
- the Page displays a simple message describing what the
summary is all about; Config has the same message,
use that. Needed some re-jigging to get the signals
and slots right.
- Create Config object, even if it's not used just yet
- Introduce onLeave() for the Page, better name than
(re-)creating the content (!?) when leaving
Repair the colors, since the basic Kirigami theme does not
look nice at all. While at it, refactor to put the colors
of the usersq module all in one place, so easy to changes
consistently (e.g. to Kirigami colors if you know your theme
is a good one).
The list suggests things are not-so-good because of recently-pushed
changes to the translations and teams haven't had time to react.
There are also some new duplicate languages.
Config classes, which intend to be shared between widgets-
and QML-based view-steps, should not tie closely to internals.
None of the ParserStatus methods are used in a meaningful
way (init() can be called by the view step).
(This assertion may be dialed back if the Config object is used
in the summary ViewStep, which will want to get at the widget
pointers, but that's for later)
- filter() returns the items for which the predicate is True;
we want to keep the subvolumes that do not have an explicit
partition already associated.
- need list() to hammer it back into a list for appending swap subvol.
function added to store selections from packagechooserq
line 103 in Config.cpp needs adjusting to restore working regular widget based packagechooser
prettyStatus added, made visible in packagechooserq only, ViewStep not altered in packagechooser for this yet
initial work done by Nitrux/Camilo Higuita in 2020, reflected in license headers
C++ adjusted to make it build & work
as noted in the inline comments e80618ef1c
there are quite a few errors in the C++, but it builds, runs and shows the correct output
will be used in summaryq, reading from widgets not an option
section probably better suited for Config.cpp/h, since quite a bit of duplicated code from
createSummaryWidget
In 942221c764 the fixed-setup
(with /@ and /@home) was replaced by the configurable btrfs
layout, but the default went away. Restore the two-subvolume
layout if nothing is configured.
Re-use the existing message about partition type and size,
since I don't want to introduce another message with all the
specifics; give a works-always message instead.
The check itself is also straightforward, avoiding all of the
nuances and technically-this-might-work cases: FAT32, 300MiB+.
FIXES#607
kirigami inlinemessages adjusted for password fields
coding style, break lines in variables
add closing button for root password inline message, needed bc of
re-use root password option does not remove all messages
bug introduced with Qt 5.15 KDE patches makes near impossible to set location
adding - 5 seems to fix, otherwise the coordinates label will have to be removed
Modules nearly always have a Config and either a Job or ViewStep
as their "top level" components. Everything else is implementation-
detail. The *partition* module was unusual in that those two
"top level" components were tucked away in subdirectories.
Shuffle them to the top: this makes it more clear that these
two files are there to coordinate the module.
The test-application injects a script into Python code
to render harmless functions in the subprocess module
(eg to avoid Python code from running the package manager
for real). There are cases, though, where that injection
should be skipped (eg because the whole point of test-
loading some Python is to check commands that are run).
Add a -P option to the test-application to do that.
warning messages implemented for user & host names
move root password option box inline with password section
adjust background color according to text.length
hardcode color instead of kirigami colors
usersq is now usable, sets user, hostname & password correctly on install
warning messages & color changes not fully done yet
The existing API required calling the one constructor with
specific pointers (nullptr for a partition-from-free-space)
followed by calling one of the initFrom*() functions. This
is fragile design.
Use tag-classes to distinguish create-from-free-space and
edit-another-freshly-created-partition cases, refactor
to merge the initFrom*() methods into the constructors
and factor out the shared UI creation.
Callers can now use the tag-class to distinguish. While
here, adjust both callers to use QPointer, avoiding some
very specific dialog-on-the-stack crash possibilities.
When a partition is set as "freshly created", the dialog was
passing in newFlags() as the **already-active** flags on the
partition; then the caller was setting those same flags as
"set these in the future", so that afterwards, no flags would
actually be set (because they're already active -- see the
first sentence).
Now, fresh partitions have no flags.
This is intended for consumption by QML; the ViewManager object
acts as a proxy for a handful of global Settings values already,
so throw in global Logger values as well. A QML module that would
like to read the log file (e.g. for tailing it as part of a
slide-show) can get the path via this property.
Sending a Once to a logger that isn't enabled should not "consume"
that Once; it's still available for a subsequent logger that **is**
enabled (useful if you're using more than one log-level in a function).
- fsName was a QString (a copy) so it could be modified;
- the modification isn't really necessary.
- While here, pick up new PointerSetter convenience class.
Avoids a broken btrfs installation in the face of missing
configurations, and makes testing a little more safe by
neutering parts of the subprocess module in Python job-tests.
This allows injecting arbitrary Python code before
the script of a module is even run. For testing
purposes, that gives us a chance to modify existing
(internal) modules before the script (e.g. to test
subprocess calls).
This is related to https://invent.kde.org/neon/neon/calamares-settings/-/merge_requests/1
which adds .. the default things from the example configuration to the
configuration file KDE neon ships. The default layout doesn't add
any subvolumes at all, which seems to be non-functional.
If nothing is configured, complain and use /@ as the lone subvolume.
PARTITION_UNSAFE is a debug mode. It is not used in
production, because it allows you to pick an install
device that would be dangerous (e.g. the current / device).
Existing code kept two copies of a list of pointers,
and deleted pointers from one of the lists and returned
the other -- which now contains dangling pointers.
Refactor by applying suitable lambdas to a single
copy of the list; this avoids copying the list so
there is no danger of dangling pointers.
The only acceptable versions of clang-format are 8 and 9 for now
(until another round of big-churn-from-formatting, at which point
we'll update the required version).
clang-format-9 says:
SpacesInSquareBrackets (bool)
If true, spaces will be inserted after [ and before ]. Lambdas
or unspecified size array declarations will not be affected.
clang-format-10 changes part of that to:
Lambdas without arguments or unspecified size array
declarations will not be affected.
This means that 9 will only allow `[name]` for captures, and 10
will only allow `[ name ]` for captures, so they ping-pong all
the lambda's in the codebase back and forth. Just don't.
Various clang-format versions have different defaults and
don't understand the same options, so adjust to having
files per-formatting-version to patch things up.
- duplicate the file to .base
- drop 10-and-later setting that was commented out
- specific setting for lambda-formatting (this seems to be the default)
- The log **file** got every QDebug object, while stdout only
got the ones of sufficient logging level. A CDebug object checks the
logging level before writing anything -- so those already were
consistent, but any qDebug() in the program (not cDebug()!) would
reach the writing-function anyway, and so log to the file.
Fix this weird inconsistency by checking log-level just once,
for both writes.
- Map QtMsgType -- used by qDebug() and qWarning() -- to levels used
by Calamares in a consistent fashion.
- Drop unused log levels (INFO, EXTRA unused in any Calamares code).
The generic-build step runs an install to the host system; for artifact-
generation, we need it all centralized in a stage/ directory. Do that
separately for the KDE neon builds that produce the artifact.
The bootloader model knows about both rows and
devices, so we can look up both at once. The
existing implementation as a non-member was rather
sketchy and wasn't used except as support for
restoreSelectedBootLoader().
If the pakcage manager fails in some way, convert to a readable
error message instead of leaking the exception to the caller
(which produces a traceback, which is harder to read and less
informative)
Widgets are easier to style if they have a name, and easier to spot
in the widget tree as well. Give the requirements-checker
parts meaningful names.
SEE #1685
- in legacy mode, *id* can have an effect and leads to
"packagechooser_<id>"; if unset, uses the the module
instance id instead, still as "packagechooser_<instanceid>".
- in packages mode, *id* is not used and only the whole
module Id (generally, "packagechooser@<instanceid>")
is used, but in packages mode there's no need for other
packages to mess with GS settings for this packagechooser.
When the module is loaded and the viewstep created, it doesn't have a
module Id **yet**. That is set after reading more of the configuration
file. It **is** set by the time setConfigurationMap() is called,
so pass it on to the Config object then. This means that packagechooser
modules can skip the *id* config key and use the module Id.
The model needs to be attached to the widget; because of changes
in the order that widget() and setConfigurationMap() are called,
the model is created earlier, but needs to be connected later.
- convenience method to install a (string) list of packages
(doesn't do the installation, but adds to GS the list, so
that the packages module can handle it).
- the %4 is left-over from the feature-summary string,
- replace it with ""; don't change the source string
because that will break translations right now.
- turn the translations-QRC phase into a function, just in
case other tests need translations as well.
- This CMake code might work as the base of translation-wrangling for
plugins (externally).
- don't pass the item IDs to packages module, use the
packages lists for each item
- document the item list in more detail (including the packages member
and new install-method item)
- convenience method to install a (string) list of packages
(doesn't do the installation, but adds to GS the list, so
that the packages module can handle it).
Rip out most of the ViewStep that deals with configuration,
move it to a Config object (not one that supports QML yet,
though), and massage the model a little.
The single-values *package* member in a PackageItem was not used,
so remove it -- to show that it really isn't used. This is prep-
work for putting the package name *back*, as multi-valued,
and using the *packages* module.
- if the queue is emptied, there was no usable data; set
failure to NoData rather than BadData.
- FetchNextUnless::done() is done only if the parameter is true (that
is, it's done!); otherwise should continue.
- drop the debugging line because that has already been
logged by the call to `runCommand()` that backs
`target_env_call()`.
- use the same (top-level) function rather than having a
function and elsewhere a very-similar method.
The code path for setting the locale / language automatically
emits currentLanguageStatusChanged(), but the code that updates
GS connects to currentLanguageCodeChaged(). This was altered in
the 3.2.28 release cycle. Since then, automcatic locale selection
wasn't setting *locale* in GS, so that a click-through kind of
locale selection would not set it; then the packages module
has no *locale* setting for localization packages.
The combination of status and code signals (machine- and human-
readable) is ok. Introduce a setter to the language that does
the necessary signalling, so that setting the language automatically
also DTRT.
FIXES#1671
The code path for setting the locale / language automatically
emits currentLanguageStatusChanged(), but the code that updates
GS connects to currentLanguageCodeChaged(). This was altered in
the 3.2.28 release cycle. Since then, automcatic locale selection
wasn't setting *locale* in GS, so that a click-through kind of
locale selection would not set it; then the packages module
has no *locale* setting for localization packages.
The combination of status and code signals (machine- and human-
readable) is ok. Introduce a setter to the language that does
the necessary signalling, so that setting the language automatically
also DTRT.
FIXES#1671
- Move variables closer to where they are needed
- Do the winnowing / selection always, but in unsafe mode return
the un-winnowed list of devices
- Massage build documentation a little
When loading the lists, no initial string-value was being
set for the model, layout and variant; the configuration
could pass right through and pick up empty strings instead.
If the user does not change the model, the UI would show
"pc105" but the internal setting would still be empty.
FIXES#1668
The machinery in `setConfigurationMap()` was just duplicating
checks already in place in the `getString()` and `getBool()`
methods, and there's no special need for efficiency here,
so prefer the more readable and short code.
("efficiency" here means "we're saving one method call in
case the configuration is not set")
- Get a signature on CHANGES at the start, so that the key
is cached by gpg; that way the tag-signing has the key, and
will not time-out (which breaks tarball generation, and
means that I need to **watch** the release script, rather
than fire-and-forget).
In 4ffa79d4cf, the spelling
was changed to consistently be "autoLoginUser" in the *users*
module, but that changed the Global Storage key as well,
and the *displaymanager* module wasn't changed to follow.
You'll need a VM with 2 disks to demonstrate:
- Configure Calamares to pick "none" as initial action on
the partition page (this is a safe choice),
- Enter partition page,
- No action is selected, and the next> button is greyed out.
- Click erase; notice next> is now available.
- Change devices, notice no action is selected, but next>
is still available. Clicking on it, though, does nothing.
When changing to "no action", update the next-button's
availability.
Avoid the extra indirection through the otherwise-unused
prettyGptType(const QString&), construct table of names
only on first call to avoid static-initialization order
(though that's not important here).
- There's still 49 enumeration values not handled, leading to
an annoying Clang warning, but there's just no **point**
in listing them all: that's what 'default' is for.
In 4ffa79d4cf, the spelling
was changed to consistently be "autoLoginUser" in the *users*
module, but that changed the Global Storage key as well,
and the *displaymanager* module wasn't changed to follow.
- Keep the project() version as literal, drop the script-mode changes,
to keep existing (weird?) build-and-packaging hacks working.
- Do switch to unified versioning-git-annotations CMake module,
do drop the "rc" from version numbers.
In particular, we need a separate Job class to set the label; this
is invoked after we formatted a partition, and when no other changes
to the partition have been requested in the Edit dialog.
The partition- and filesystem-label setting code was already there,
but not in the call to createNewPartition(); now we set the
FS label twice (once in the call, once afterwards)
When creating or editing a new formatted partition, allow
to set a filesystem label (16 chars maximum). Modify
the KPMHelpers to accept it as a new parameter. Partitions
created by default may get a meaningful label too.
The partitioning header 'FileSystem.h' is for KPMCore support;
it is already included by Global.h and guarded by ifdefs for
KPMCore. Do not unconditionally include it from the implementation.
- merge the (not-installed) date-stamp and git-version
files into ExtendedVersion, turn things into functions
- drop support for CVS (wut?)
- don't mention the branch, in git-versioning, because the
hash is enough to find whatever
- don't need external program to find date, use `string(TIMESTAMP...)`
- separate out the version into a variable (again -- this was moved **into**
project() long ago, but now there's a desire to have the value before
reaching the project() command)
- rename CALAMARES_VERSION_RC to something more sensible.
In current development, RC is effectively 0 (for a release)
or 1 (during development). It doesn't add anything to suffix
'rc1' to the version number. While here, remove the BUILD_RELEASE
check (because nothing ever sets it) and instead rely on
the RC setting instead to decide for long-calamares-version
The check for skipping a subdirectory was applied to Python subdirs,
not to C++ subdirs. This meant that a skipped module would notice
only in calamares_add_plugin() that it should be skipped. The **rest**
of the CMakeLists.txt in the to-be-skipped modules' subdirectory
was not skipped, and so a test might be added for a module that
was skipped. Depending on how the test consumes the code/module
under test, that might fail to link.
Example module is *initramfs*. Reported by yonggan.
- make the functies that take a GS* first-class
- use the convenience functions from JobQueue for the others
- inline so only the explicit-GS* functions are in the library
The skip-checking is now in the functions for adding plugins and
subdirectories, so that third-party building should get it
as well, for free. Since AddModuleSubdirectory and AddPlugin
use the newly split-out module, handling SKIP_MODULES and USE_*
consistently across module repositories is now easier.
While here, make accumulating-the-skipped-modules explicit.
There are two ways to skip building a module:
- SKIP_MODULES (individually listed)
- USE_* (pick one from a collection)
Move the handling for those ways to a separate function, so that it
can be re-used in the calamares-extensions module too, or other
external module repositories.
This change is relevant only if you build Calamares and some out-of-tree
modules (e.g. calamares-extensions) on the same machine where CMake
caches files in the developer's ~/.cmake/packages . If the user
packages registry kicks in the include files won't be found, and
the targets are not defined.
- offer a convenience method for showing a popup and
URL information and copying the URL to the clipboard
- use that from ViewManager (on failure) and DebugWindow (on demand)
- make the tools tab buttons along the bottom row
- show the global storage tab by default
This costs little screen real-estate, makes the tools much more
visible and useful.
- use load() to start loading
- the FetchNextUnless class is useful in more spots in
the loading process
- set status explicitly on success (otherwise, a failure in a
previous URL would leave a failure message lying around even
when the module shows something useful)
- m_queue was not initialized to nullptr, crashes
- split queue-is-done to a separate slot rather than a lambda
- prefer queueing calls to fetchNext(), for responsiveness
Require a ; after RETRANSLATE macros. They are statement-like;
this makes it easier for some of them to be recognized by
clang-format and resolves some existing weird formatting.
Now all the business logic is in Config, the door is open to
building a QML-ified netinstall module. I'm not sure that
would be worth it: packagechooser offers more space for a
nice UI and should be QML'ed first.
- do some additions and check they work
- drop the ";add" annotation on the source, this is not
needed in the current situation with only adds available.
For methods that log a bunch of things, and which want to
consistently use SubEntry, but don't know when the **first**
log entry is within the method, Logger::Once can be used
to log one regular message (with function info) and the
rest are subentries.
- If the module knows about a preset, then it should be registered
even if there is not a value set for it specifically; this avoids
complaints from isEditable() for fields that are known, but
do not have a preset. (Reported by Anke)
There was a mix of autologin and autoLogin, leading to confusion
in the code. QML is sensitive to this, so go to one consistent name.
(Although the names of the settings in the `.conf` file are
different again)
- this test would fail if the logfile already exists for
any reason (including "I just ran the test")
- remove the file before expecting an empty logfile
- improve messages; a missing logfile is not a "things cannot
work" situation, it's a warning
Although the example configurations shouldn't really be used
as a sample of how to configure **your** Calamares for your
distro, many distro's do just copy the examples. So leave
traces of the OEM-configuration settings in the example,
and give the standard configuration a 'nothing changed'
set of presets.
- you can still call set*(), eg. from the UI, when the field is
not editable. Although the code previously ignored the change,
this would lead to a mismatch between what the UI is showing
(the changed value) and what the Config has (old value).
Emit a changed-signal (notify) with the old value so that the
UI is changed *back* as soon as possible.
- warn about fields applied twice (program error)
- warn about fields not used (configuration error)
- add operator<< for "clean" looking preset application
Build up the list of known presets by what the Config-object
expects, not by what the Config file provides. This allows
early detection of mis-matched configurations.
Presets can only apply to Q_PROPERTY properties, and the
preset must match the property name.
This adds support for checking whether a field is editable;
Config objects should reject changes if the field is not
editable. There is an "unlock" setting to override the
check, although this is currently always locked.
This tests only the termbin ("fiche") paste by sending it
a derpy fixed string. Prints the resulting URL, doesn't
verify in particular.
It'd be rude to run this test too often.
- mark functions with STATICTEST so they can be compiled into a test
- move logfile-reading so we can call the pastebin-upload functions
with an arbitrary payload.
- The Paste API promises just a (string) URL back, not
a whole message, so return just the URL from the
abstract API and the concrete (fiche) implementation.
- Set clipboard contents from the UI
- Build (translated) message in the UI code
- have a namespace Paste with just one entry point, which will handle
untangling type &c.
This doesn't compile, but indicates the direction to take the API
- Use just type and url, since port can be specified in
a URL. Note that we only use host and port, not the
scheme (or the path, for that matter).
- Factor out understanding the *uploadServer* key to a function.
- get a QByteArray rather than going through a char[] buffer
- bytes-read is not important since the RE can only match if
there **are** that many characters.
- it might not be very current, and it's *probably* better to
use dbus-activation / kf5dbus, but let's not call it
deprecated until very sure that the dbus version does the
right thing.
- Add a toggle() to the debug-window manager, for convenience
- Make the manager available to QML
- Use the debug-window manager (code imported from KaOS)
Move the management of the (a?) DebugWindow to a separate
class, and hang on to that manager in CalamaresWindow.
This is prep-work towards making it available from QML as well.
The Quit button can have its own logic at a QML level for
show/hide. It **ought** to follow the *quitVisible* property,
but can do additional work. Here, document how a distro might
choose to hide the Quit button on the last page (generally,
that's the "finished" page).
It's possible to ignore the "user setting" for restart-now
and call doRestart(true) directly. This is intended for
use with specific UIs that make that choice clear for the user.
Hook up both [finished] and [finishedq] to the "traditional"
restart-if-the-box-is-ticked logic although the example
QML doesn't expose that box.
- Add function for mapping panel sides to an orientation (H/V)
- Pass that into the creation functions
This is prep-work for handling vertical navigation and horizontal
progress reporting cleanly.
- using the QML sidebar would not highlight the first step on startup,
only after next / prev would the highlight show up. Now, notify
when all the modules are loaded (and number 0 is active).
module builds & runs, config connections are not registering
no errors
finishedq.qml is offering a different option though, running commands directly in qml
plasma-framework executer is used for that
- move most of the business logic to Config
- make retranslate of the page more robust (e.g. changing language
after failure would restore the un-failed message)
There's still some bits left.
*If* the distro has GeoIP enabled and auto-selects the language for
Calamares, then Belarus now selects Russian, rather the Belarusian.
This is based on some personal input, mostly, and Wikipedia census data.
FIXES#1634
- the configuration is still duplicated in the widget, and
functionality still needs to move to the Config object
- the ViewStep is cut down to almost nothing
- the host system's /etc/group is being read, and that varies between
host OS versions; since I was doing today's release on KaOS, the
test was failing because of arbitrary differences between the
default groups on each Linux flavor.
FIXES#1604
(Admittedly, this fixes the problem only when there's Plasma Solid automount
present, and not any of the other kinds; but none of those have been reported
yet, and adding them into AutoMount.cpp is opaque to the rest of the
system)
- It shouldn't be necessary to explicitly .get() pointers for
logging, and it's convenient to know when a pointer is smart.
* no annotation means raw (e.g. @0x0)
* S means shared
* U means unique
- switch logging in job to VERBOSE because we don't want to be printing
pointers to the regular session log
- switch logging in test to VERBOSE to actually see the messages from the Job
- hook the test into the build
The popup now cuts down messages to a manageable length.
Hopefully the part that is preserved, will still show
something meaningful for the user (8 lines of text should
be sufficient for the kind of things we do).
FIXES#1613
- Although unique_ptr is only used when ICU is enabled, include it
always because it is likely that we'll use more unique_ptr
in the implementation at some point.
Ever since signed shim binaries for multiple architectures became
available, the shim binaries installed in Linux distributions have
been renamed to include the EFI architecture in the binary names.
This started in Fedora, but is now used in openSUSE and Ubuntu too.
Reference for shim binary names comes from shim spec in Fedora:
d8c3c8e392/f/shim.spec (_23-32)
- Some minor bits snuck in with the string-truncation code
- While here, make UPDATE_BUTTON_PROPERTY more statement-like
so it doesn't confuse code-formatters.
Writing `Logger::NoQuote{}`` has annoyed me for a while, so
switch it to a constant, like SubEntry, so it looks more
like a regular manipulator object.
The value inside a unique_ptr can't be opaque, it needs to be known
at any site where the pointer may be deleted. shared_ptr does not
have that (deletion is part of the shared_ptr object, which is larger
than the unique_ptr) and so can be used for opaque deletions.
The QLatin1String() might be replaced by char[], that trades one
initialization for two but with a simpler data section; this
probably is not worth profiling.
With Qt 5.15.2 (and clang), `k->first` works, but this breaks
with Qt 5.11 (and gcc), this is not available and the dereference
must be written differently, `(*k).first`.
- This kind of runs around the selection model on the view,
but we're drawing radio buttons ourselves **anyway**
and the list of themes knows which is selected / current
independent of the view.
- make ThemeInfo and ThemeInfoList internal, expose only
ThemesModel to the rest of the PlasmaLnF module
- don't build the widget anymore (needs to be replaced by
a delegate)
- also individual changes need to be signalled
- use QSignalBlocker to avoid spamming changes when calling
aggregate change methods
- refactor findById() so that also a row number can be
obtained, which is needed for the change signals.
- put a filter model in place, so only the themes with "show" set
are displayed
- rip out the messing about with widgets, soon to introduce a model-
based UI
This is the bugfix part (rather than the "clean up this widgets mess")
of issue-1573, ensuring that the LookAndFeelPackage setting is
saved to the target system config file.
- Need to update the variant that is in use, **and**
explicitly update it in the widget, in order to re-load
the keyboard image for the newly-selected layout+variant.
- Make explicit which one runs in the host, which one is selectable.
- Document *location* parameter in the selectable version.
- Tidy up alignment of apidox.
The lookandfeeltool does not (always?) write the LookAndFeelPackage
key that the KCM does -- and which this module reads on startup
to find the default LnF. This seems to be a regression in recent
lookandfeeltool versions (or in the KCM code that backs it).
Workaround supplied by jghodd.
Fixes#1573
The module preserves the extended attributes at rsync and the overlay
filesystem stores extended attributes by inodes.
The overlay filesystem keeps traces of the lower directory by encoding
and storing its UUID to the attribute trusted.overlay.origin. If the
index feature is on, that attribute is compared to the UUID of the lower
directory at every subsequent mounts and causes mount to fail with
ESTATE if it does not match.
This filters the namespace trusted.overlay.* by using the rsync option
--filter='-x trusted.overlay.*' to make sure the overlays extended
attributes are not preserved.
Fixes:
# mount -t overlay -o lowerdir=...,upperdir,...,workdir= overlay /mnt/etc
mount: /var/mnt/etc: mount(2) system call failed: Stale file handle.
# dmesg
(...)
overlayfs: "xino" feature enabled using 32 upper inode bits.
overlayfs: failed to verify origin (/etc, ino=524292, err=-116)
overlayfs: failed to verify upper root origin
Previously, the auxerror information was never stored, and
the messages were all un-numbered or un-explained.
Now, consume that information and store it when check()
is called, ready to be used when (possibly much later,
or after a translation change) explanation() is called.
Mount guesses the filesystem if it is unset or if it is set to auto,
thanks to blkid. That is the case for the bind mountpoints like /dev or
/run/udev in mount.conf. See `mount(8)` for more details.
The drop-down of zones was initially unfiltered, so you could start
in Europe/Amsterdam and the zones drop-down would also show Australian
zones; picking Perth would have weird effects, since Europe/Perth
doesn't exist and so you'd end up in New York instead.
- set the filtering region immediately, rather than only when the
region changes.
Various file writes were not being checked, and the code
was a bit tangled; specifically keyboardq did **not**
configure properly on KaOS and now seems ok.
The root mount-point can end with a / while the mount-point read from
the file /etc/mtab does not end with a /.
This leads to skip the unmounting of the root mount-point and causes the
removal of the root mountpoint directory to fail with EBUSY because it
is still mounted.
This uses the python functions os.path.normpath() to normalize the root
mount-point (i.e. to drop the trailing /) and os.path.commonprefix() to
determine the longest common prefix between the two mount-points. If the
returned prefix is identical to the normalized root mount-point then the
mount-point must be added to the list of the mount-points to unmount.
More generally, the python modules should rely on the os.path functions
to compare for paths instead of using strings. It covers this way lots
of corner cases (path with "//", "/../", "/./", ...).
- put the writing of each kind of file in its own block -- this should
become separate functions -- so that variables become more local
and debugging can be improved.
- while here, fix the error message for /etc/default/keyboard:
it would complain and name the vconsole file path if it ever failed.
- factor out the flags-we-want from the flags-we-already-have
- the use of ->activeFlags() meant that the state on *disk* was
being compared with the flags-we-want; if a partition was re-edited,
then you couldn't change the flags back to the state-on-disk
(eg. enable a flag, then change your mind and disable it).
- set the flags before refreshing the partition, because the
refresh checks for EFI bootability and that needs the new flags,
not the old ones.
- remove the m_defaultFSType from PartitionLayout, because it is
set on construction -- which is too early, before the configuration
has been read.
- make the default FS explicit in the init() calls which pass in
a configuration; this needs support in the intermediate
PartitionCoreModule.
- the "simple" constructor for PartitionEntry left the FS type
set as the constructor left it -- which is Unknown by default.
This leads to install failures in systems that don't set a
special layout but just want a single / -- because the FS is
set to Unknown.
- massage the constructor and consumer of the code, push
Ext4 FS in the tests and use the configured default in production.
The return of the call to libcalamares.utils.mount is never tested and
it may fail silently; this causes some mounpoints to be missing.
This adds a warning if mountpoint cannot be mounted.
chcon: failed to get security context of '/tmp/verity': Operation not supported
06:44:23 [6]: static CalamaresUtils::ProcessResult CalamaresUtils::System::runCommand(CalamaresUtils::System::RunLocation, const QStringList&, const QString&, const QString&, std::chrono::seconds)
Running "env" ("mount", "-t", "unformatted", "/dev/sdb2", "/tmp/calamares-root-kv8dqgb5/tmp/verity")
.. Finished. Exit code: 32
.. Target cmd: ("mount", "-t", "unformatted", "/dev/sdb7", "/tmp/calamares-root-kv8dqgb5/tmp/verity") output:
mount: /tmp/calamares-root-kv8dqgb5/tmp/verity: unknown filesystem type 'unformatted'.
Some compile flags changed recently, triggering assert()
in the jobqueue when there is more than one. There's no
real reason for JobQueue to be a singleton, but it wants
to be. So clean up pointers a little more enthusiastically.
- Use classes to prompt lupdate to extract with a better
context (e.g. the class name, rather than plain "QObject")
so that the translation-lookup can use the named context.
- Add hard-coded "default" variant
- Add totally bogus Tajik translations, for testing purposes
This is the Wrong Thing To Do, but we'll do it for now: build the
keyboard translations into the executable. In the medium term
they should move to the modules that use them, with the re-vamp
of how translation changes are signalled.
Now that Calamares is compiled as C++17, we get this:
src/modules/locale/timezonewidget/TimeZoneImage.cpp:28:55: warning: out-of-line definition of constexpr static data member is redundant in C++17 and is deprecated [-Wdeprecated]
/* static constexpr */ const QSize TimeZoneImageList::imageSize;
The code doesn't match the comment: there are no by-ref captures
in the code, and the shadowing of parameters and local variables
is confusing. Remove one variable that is passed in as an argument
(and just pass the value as argument) and copy-capture the other
rather than doing weird argument passing.
- remove unused this captures from lambda
- rename variables that are short, cryptic, and shadowed
- remove documentation for parameters that don't exist
This commit adds the new configuration `swapPartitionName` to the file
partition.conf.
This option sets the partition name to the swap partition that is
created. If this option is unset, the partition is left unnamed.
- only widgets get language change events, so we need to
hook that up to the ViewSteps and inform the Config
object so that it can (re)load translations for the
keyboard data.
- Rename the "size" locals using "sectors" in their name. Size may be
confusing or not enough specific as it can be interpreted a size in
Byte.
partSizeMap -> partSectorsMap,
totalSize -> totalSectors,
availablesize -> availableSectors,
size -> sectors,
minSize -> minSectors
maxSize -> maxSectors
- Create a the new local currentSector to iterate over the sectors;
instead of using the parameter firstSector.
- Remove the variable end that does not help much; too many variable
already. Expand its expression instead.
- Introduces new constructors for PartitionEntry: copy constructory and
constructor with all attributes.
- Use the new constructor in method addEntry().
- The variant helper toString() takes a default value since commit
c9f942ad6 ([libcalamares] Add default value to variant helpers).
- Set the default value to 0 and simplify the retreival of size values
by calling the helper toString() and removing the temporary variables.
- The logic of the method initLayout belongs to the object
PartitionLayout. Move logic to that object.
- Use a single method initLayout in object PartitionCoreModule.
- Member m_partLayout in object PartitionCoreModule is no longer
allocated.
The translation happens whenever this code is run, which may
not match the language the user subsequently selects.
It also causes general problems with the translation,
since we end up with a possibly-partly-translated name.
This lands Artem's work on supporting non-ASCII layouts better,
which currently only applies to Russian layouts -- it works with
a table, so it is easy to extend for other layouts.
The QML and Widget steps now completely share the Config backend,
which is why there's so many commits here: the Widget page needed
to have most of its code ripped out, and the models for
keyboard data were broken in various ways and needed fixing.
FIXES#1211
- With debugging and untangling done, the lambdas are simple
and short, so return to using them. One point of improvement
might be to give the models suitable slots themselves,
to avoid even this indirection.
- Use the just-refactored XKBListModel to store the xkb key-value
pairs for variants, drop most of the complicated implementation,
store just a single list of values.
- Remove code that is duplicated in Config.
- Hook up UI for physical keyboard model, and back.
- For now, introduce some named slots with debugging output.
This makes debugging a lot easier since we have function names
to work with rather than anonymous lambdas
- Config already *has* everythind, but drop the useless copies
and duplicated code from the Page
- Plug the models model into the Page
- While here, document the model / layout / variant distinctions
The code doesn't fill the UI properly, and the drop-down
for the models combobox is not right, but at least the data
is shared.
- gcc (up to at least version 10) is worse at recognizing that all
cases have been handled, so it complains about all the switches
that cover enum values.
- both clang and g++ support __builtin_unreachable(); (as Kevin
Kofler pointed out) so we don't need the macro to do different things;
- the compilers have gotten better at detecting unreachable code,
so instead of inserting macros or fiddly bits, just drop them
and the unreachable code they comment.
- reduce the difference between clang and g++ builds, factor
common flags out of the CMake-if
- drop special boost-warning-suppression, we do that differently
most of the time in the affected source files
- if the partition size is invalid, then warn about it but do
not print the (uninitialized) size of the partition.
- shuffle code to continue earlier, allowing the "good path"
code to be out-dented.
The special setup for nicely-named groups which have a single
hidden subgroup containing the actual packages, has the problem
that there is a non-empty subgroups item, but this results
in zero actual children: then the number of selected and partly
selected children is also zero in updateSelected() and therefore
the item ends up unselected.
Special-case this to avoid unnecessarily unselecting the item.
Reported by Vitor L.
The status for an empty login name is '' (empty), for ok -- this is
so that there is no complaint about it. But it's not ok to
continue with an empty name.
The status for an empty login name is '' (empty), for ok -- this is
so that there is no complaint about it. But it's not ok to
continue with an empty name.
- The EXPECT_FAIL value "Abort" stops the test (I wanted 'if this
unexpectedly passes, raise an error' -- should have read the
documentation more closely).
- Set the shell in the config object, not just in GS.
- add a status member so the different steps can show progress
as the user is created and configured. The progress values
are hard-coded guesses as to how much work is done for each step.
- while here, reduce the scope of the global storage variable
This is somewhat experimental and weird; the idea is that bool
arguments are a lot easier to understand if there are proper
names attached, rather than "true" and "false".
- don't blank out the text in the progress bar if the job provides no
message -- just leave the last message shown. FIXES#1527
(There's no point in having more than one copy of those initcpio*
modules, so just use the prettyName()).
- when a job starts, look for status, then description, then name so
that **something** is shown as text in the progress bar.
- give *shellprocess* the possibility to change its own labels
through translations in the config file. #FIXES #1528
This improves the situation for jobs that do not provide
a status: their blank status does not overwrite the status
bar, and since (previous commit) the description or name
is used to start the job if the status is empty, at least
**something** is displayed.
SEE #1528
- os-proper may return an extra file after the device:
/dev/sda1:Ubuntu 19.10 (19.10):Ubuntu:linux
/dev/sdb1@/EFI/Microsoft/Boot/bootmgfw.efi:Windows Boot Manager:Windows:efi
- The API definitions are just the symbols to define; these
are variously added through add_definitions() (needs -D)
or target_add_definitions() (doesn't).
I think we had this (kind of) module a long time ago and it was
removed for over-complicating things; re-introduce one now that
KPMcore is used in 3 different places and all would benefit
from consistent API handling / defines.
- handle swapfiles when writing /etc/fstab in the target system
- special-case mountpoint
- since swapfiles are not a partition, take the setting out
of partitionChoices
- create the physical swapfile as well (there's no other place
where it would make sense)
This still won't help if there's one really huge file that takes
several seconds to write, but if there's a bunch of files together
that is less than a file_chunk_count but take more than a half-
second to write, update anyway
If there's thousands of files in a squashfs (e.g. 400000 like on
some ArcoLinux ISOs) then progress would be reported every
4000 files, which can take quite some time to write. Reduce
file_chunk_count to at most 500, so that progress is reported
more often even if that wouldn't lead to a visible change
in the percentage progress: instead we **do** get a change
in files-transferred numbers.
- The total weight is only needed by the UnpackOperation,
not by each entry.
- Use a chunk size of 107 so that the number-complete seems busy:
the whole larger-or-smaller chunk size doesn't really matter.
- The progress-report was missing the weight of the current
module, so would report way too low if weight > 1. This affects
ArcoLinux configurations where one entry is huge and one is a
single file, so weights 50 and 1 are appropriate.
When there are multiple entries, the overall weight of the
module is divided between the entries: currently each entry
takes an equal amount of space in the overall progress.
When there are multiple entries which take wildly different
amounts of time (e.g. a squash-fs and a single file) then
the progress overall looks weird: the squash-fs gets half
of this module's weight, and the single file does too.
With the new *weight* key for entries, that division can
be tweaked so that progress looks more "even".
- parameter instanceKey was left over from previous work that
special-cased the weight of Python modules.
- while here, consistently do `~T() override`
With 1 CPU, Calamares still spawns 9 threads or so: eventloop,
dbus loop, QML loop, ... many of those are invisible to the
application. Contention occurs on startup when the UI is constructed,
and we end up with the module manager creating widgets alongside,
or ahead of, the main window UI. This can result in deadlock:
- in CalamaresApplication::initViewSteps
- in QML imports
This is partly because the signal-slots connections get "deep":
from loadModules() we emit *modulesLoaded* which ends up showing
the main window in initViewSteps(). Avoid this with a QTimer:
drop back to the event loop and release whatever locks are held,
so the QML thread can get on with it already. Then the timer
goes off and the view steps are created.
- Give LVM jobs a dummy argument Device* so that they
fit the functionality of makeJob for partitioning.
For those jobs that already take an LVMDevice*, this should
be the self-same device, but that isn't checked.
* Use the minSize when the target storage is smaller than the sum of sizes
* Percentage-defined partitions should be computed after setting hard-defined ones
This fixes issues when 0 byte partitions were created when the disk is too small.
Also fixes an issue with percent-defined partitions being forced to be defined at the end of the disk.
- create dirs as needed (this will normally be done by
unsquash, but for tests with paths it needs to be done
by hand)
- log what file is being checked
- filePath() doesn't like the absolute paths we have
(they're absolute in the chroot, and existing code
just sticks rootMountPoint in front)
Document keyboard change for Turkish F layout, and document
the keyboard configuration value better, with alternate
path used in e.g. openSUSE
FIXES#1397
Some tests -- notably the keyboard module -- need to have the
QRC for the module loaded as well (e.g. because of data in the
QRC). Add a RESOURCES parameter to calamares_add_test()
like calamares_add_plugin() already has, to build the
resources into the test.
Keyboard test now passes, since it was missing the data for
lookups before.
- both changing the autologin and changing the user (login) name
affect global storage, and both may need to change the autologin
username; split it into a free function.
- the fullname change was bypassing the login in changing the
login name, **but** then it needs a back-workaround to keep
the "custom" setting off (when custom is off, auto-fill username
and hostname is active).
- after loading the config, fill GS already.
- when finalizing GS, get the autologin settings again.
- setup the visibility and initial checked-state of the reuse-user-
password-for-root near where it gets connected; do similar
for the require-strong-password
- squash the lambda slot into the regular slot: no sense in
connecting twice to the same signal with the same receiver.
- only connect config->ui once
- only connect at all if the setting is visible (e.g. when weak
passwords are allowed for the require-strong checkbox, or
when root's password will be written for the reuse-password)
- switch to QStringList as parameter, since consumers (that is,
the debug dialog, which is what this is for) are interested
just in the **names** of the jobs.
- to allow mutex locking in const methods, mark them mutable.
- *secretly* this is already done in the KF5 i18n modules,
so the resizefs was already requiring FindGettext.
- we don't actually use the gettext modules' CMake macros,
so explain why in the module.
- there's no need for a macro that is going to be used once,
especially if there's only one place it can be called.
- expand it in place and remove it from the installed CMake
module
once completed, this can be a fully functional (offline) locale selection option
worldmap.png no longer needed/in use
working is the stackview of the region & zones models
Timezone text bar shows correct timezone
currentIndex see comments on lines 65 & 139, not working
update of timezone text bar can't be tested if working as long no index is connected (see lines 93 & 168)
Still, already committing, since it does more then old Offline.qml, which had no function for timezone
Apply REUSE.software licensing tool across the codebase,
add complete(*) licensing information. Since we're touching
every file in the repo **anyway**, apply coding style too.
(* there are four files not licensed, but they will be
removed soon)
- point to main Calamares site in the 'part of' headers instead
of to github (this is the "this file is part of Calamares"
opening line for most files).
- remove boilerplate from all source files, CMake modules and completions,
this is the 3-paragraph summary of the GPL-3.0-or-later, which has
a meaning entirely covered by the SPDX tag.
For some dozens of files, adding license information in or
next to the file is unwanted:
- the translations are variable, and licensing information
embedded in them is removed on update; since the translations
are derived from the sources, blanket-license them as GPL-3.0-or-later
- FreeBSD packaging (ports) directories have a specific structure
.. and more cases like that. See the dep5 file for details.
- Mostly CC0 because they're not interesting
- formatting, git, travis, transifex
- Some BSD-2-Clause because of habit
- CMake and shell-script-like files
In spite of there being considerable documentation sometimes in the
config file, we go with CC0 because we don't want the notion of
'derived work' of a config file.
The example `settings.conf` is also CC0. Add some docs to
it while we're at it.
- the translations generated from public-domain files are CC0-1.0
- the files derived from Unicode tables are close to CC0-1.0,
possibly except that there is a FileCopyrightText line
- *AppImage example config*: this is old AppImage configuration,
basically unmaintained, but copied from the **other** example
config files which are CC0-1.0 as well.
- *Sample Linux distro*: The example Linux distro has a handful
of trivial files, a bogus `/etc/issue`, that kind of thing.
- The bash completions are GPL-3.0-or-later
- FreeBSD packaging information is BSD-2-Clause
- CC0-1.0 for the uninteresting version-headers
- GPL-3.0-or-later for the services
- add SPDX identifiers to Calamares C++ libraries and application sources
- add SPDX identifiers to Calamares QML (panels and slideshow)
- the `qmldir` is a list of names of things in the directory,
so CC0-1.0 it as "uninteresting"
- QRC files are lists of names of things in the directory,
so CC0-1.0 them as well
Some Calamares source files incorporate material from
3rd parties (unlike the 3rdparty/ dir, which is basically-
unchanged 3rd party source). Tidy up the FileCopyrightText
lines for those sources.
This is not an exhaustive effort.
There's lots of (YAML) test data that is just trivial configurations
for modules. Since the configurations themselves are **also** CC0-1.0,
and the tests are less interesting, license them equally liberally.
The build instructions are not that interesting, it's a toss-up
between CC0 and BSD-2, but because other CMake bits are BSD-2-Clause,
apply that to more CMakeLists. The copyright date isn't all that
accurate, but these are just inconsequential files.
While here, tidy up and get rid of some useless intermediates.
The .ui files are all GPL-3.0-or-later style, but it's
slightly difficult to keep licensing information in them:
it's XML, so an XML comment might work, but there's no
guarantee that safe/load will preserve them.
Put the SPDX tags in the <author> tag, so that it's visible
in Qt Designer.
- remove empty useless HACKING
- remove unused cppcheck.sh
- migrate the AppImage docs to the wiki (which doesn't moan about licensing)
- try a HTML-style comment in the RELEASE docs
The intended license for the CMake modules is BSD-2-Clause;
there's no desire to restrict what can be done with these,
and CMake modules are generally 2-clause licensed.
For proper REUSE compliance, untangle the lists of licenses
and place a single copy of each license in LICENSES/ .
The License-Identifier in each source file refers to
these licenses, and FileCopyrightText provides the context,
"above notices" and similar attribution data.
This was causing CI builds to fail, since WEBVIEW_WITH_WEBKIT
is defined only in the Config file, not on the command-line.
This crept in accidentally while trying to get rid of that
config file entirely.
Re-jig the module-weight calculations.
- modules can have a weight
- module instances can have a weight
- jobs, from the module, can have a weight
This is now configurable on a case-by-case basis, rather than having
C++ only as an option and a weird hack for unpackfs.
This is more a test-inspired hack than anything else: since signals
are delivered asynchronously, we can end up delivering progress
signals out-of-order, and then the signal spy lists them wrong:
progress goes backwards.
Insert a tiny delay between jobs to allow signals to be delivered
in-order.
- compute weights and accumulations beforehand
- mutex-lock structures so you can enqueue while running jobs
- simplify progress reporting calculations
- doesn't actually run any jobs
reflect changes from users/Config.cpp
corrected id missing capital
mirror UsersQmlViewStep.cpp/h with the users versions
connections are still not made
In advance of PR #1491, test loading and stringlist extraction.
- from code, extraction works "normally"
- for YAML data, the stringlist isn't actually a stringlist
- if the user password is reused (or not) then check the
status of the passwords against the new reuse-setting
- if the allow-weak-passwords setting is changed, then
check the status of passwords (both of them) against
the new weakness setting
As explained by Kevin Kofler and abucodonosor, the
implementer line can carry a bunch of different values,
but none of them are actually interesting. Simplify
the code.
- the way isPasswordAcceptable was being used was buggy, leading
to test failures (now fixed)
- don't expose the function, anyway: it's an implementation
detail for passwordStatus() which in itself is an implementation
detail for status notifications.
- avoid update loops by checking values before emitting *Changed()
- check validity of user and root passwords when asked
- if root isn't going to be written, or re-uses the user password,
defer to those status checks.
- The weight is the module (instance) weight, which can be
- the default weight of 1
- the weight specified for the module (in module.desc / the module
descriptor; this defaults to 1, above)
- the weight specified for the instance (in settings.conf)
The last of these "wins"; weights are constrained to 1..100
The weight isn't actually used in progress computation yet.
- a handful of modules had an unused *requires* key in module.desc;
this is probably from previous intentions around
prerequisites-testing. Since the settings were empty anyway,
they have been removed.
- [unpackfs] Compacted the way *requiredModules* list is written
- loads emergency, noconfig, requiredModules keys
- warns (and marks descriptor invalid) if there are unused / unknown
keys left over in the descriptor data.
- add fields -- all const, all bogus -- to the descriptor,
introduce a stub method to load the descriptor from
YAML data (e.g. read from module.desc)
- lighten the type-naming in Module a little, with usings
- In most cases, you **know** the table covers all the enum
values, and the extra parameter *ok* is just annoying.
Provide a convenience that doesn't distinguish empty
from empty-but-valid.
- move the enums
- expose the named-enum functions for them
- **start** replacing Descriptor with something stronger; this fails
zero tests so it obviously wasn't tested at all
This module allows the generation of the initramfs in Alpine Linux based
systems (excluding postmarketOS). Very bare bones, but then again it
doesn't need much. It uses the Alpine Linux tool "mkinitfs" to do the
job.
- setting the weight in *instances* should be different from letting
the default weight (of 1) stand; explicitly saying 1 should
carry some weight (ha!)
- any invalid instance key will cause a complaint
- "new" custom instances in sequence get a complaint, but
the instance description added to the list is valid
- there's no reason to ignore custom instances that are **not**
mentioned in the *instances* section: it may be useful to
name more that one even without distinct config files.
- no more weights in constructors; do that in fromSettings() only.
- simplify test to drop those constructors
- set config file also for "normal" descriptors; fix test
module builds, installs and runs, connections are not working yet.
UserQmlViewstep.cpp/h are from PR https://github.com/calamares/calamares/pull/1356
sections are commented out to make the module build, but help is needed to get those 2 files corrected.
config names used in usersq.qml are guessed from users/Config.cpp
debug window shows correct entries in GS, and under the module tab, usersq.conf is read
as should too. Running shows most config used in users.qml are not registered/wrong,
many entries like: qrc:/usersq.qml:228:13: Unable to assign [undefined] to bool
It is understood not all needed from the users module has moved to Config.cpp yet,
but doing the PR now, since it runs, doesn't crash cala and help is needed to further implement.
- expose, for testing purposes, the load-from-YAML-data part
alongside the public constructor that reads a YAML file
- add test for building the list of instances
- looks funny
- is hard to get clang-format to respect this; it's intended as an
access-modifier, but those are baked into the code rather than
being configurable.
- is probably rare enough that #ifdef is acceptable
- was getting multiple definitions of moc-related code due to automoc
combined with KDSAG having its own #include moc, comment-out the include.
- while here, simplify the CMake bits for building KDSAG
- was getting multiple definitions of moc-related code due to automoc
combined with KDSAG having its own #include moc, comment-out the include.
- while here, simplify the CMake bits for building KDSAG
- Requirement.cpp was there "just in case" the header grew
functions that need an implementation, but that seems
unlikely (the header is just a struct of POD).
- the scripts are BSD-2-clause,
- the generated files are CC0 (I'm not *100%* sure about the
derived file CountryData_p.cpp, which lists countries and
country codes -- it **is** extracted from CLDR data which
is not CC0)
- QStringList doesn't round-trip correctly; add a test to
demonstrate that.
- Fix existing test to **not** use QStringList, but QVariantList
(of strings), which is how other code would use it.
The above is **kind** of moot because nothing uses the YAML-save
function, but it might.
While here, fix another test: YAML-loading can load JSON just fine.
- add apidox to all the untranslatedFS() methods
- add the most-basic of untranslatedFS(), which works on a given
FileSystem::Type; this one can handle special cases where
Cala needs a different untranslated name than what KPMCore provides.
Resolve a long-standing annoyance. With the new model for TimeZones
and nicer data structures, along with consistent find-methods,
we can spot-patch TZ data to handle special cases of bad timezones
being assigned to obviously-otherwise locations.
- for the purposes of Calamares's nearest-location selection algorithm
for timezone selection, introduce spot patches: alternate markers
on the map to indicate "things close to here belong in this timezone".
- hide the implementation detail in the find() methods.
- Cape Town is in South Africa, so one might expect it to get South
Africa's timezone -- which is Africa/Johannesburg -- but Windhoek
is closer, so it gets that.
- Port Elisabeth is similar: Maseru lies between it an Johannesburg,
so it gets the wrong timezone, too.
These both illustrate how the limited resolution of the map, together
with the "closest location" lookup, can give poor results. For most
of South Africa, the "wrong" timezone is closer than the right one.
- The TZ widget uses a different coordinate system (mapping lat and lon
to pixel locations, and then calculating Manhattan distance from
that), so needs a different distance function.
- Simplify code: there's just one "closest TZ" function.
- introduce a distance function and use that, rather than coding it
inside the find() function. This is prep-work for unifying the
find() calls, based on various coordinate systems.
Support /etc/default/grub.d/ -- keep in mind that the **rest** of the
logic in writing a grub configuration file is unchanged, so 00calamares
may roughly override "global" or top-level grub variables like
GRUB_TIMEOUT.
FIXES#1457
- create directories for new tests ahead of the tests themselves;
this **can** still cause problems if a test is run standalone.
- if creating the grub-dir at runtime is necessary, be informative
if it fails.
- the default_dir was only stored in modify_grub_default() to
create the directory if needed; move that functionality to
the get_grub_config_paths() function (and drop the "s",
since it now returns just one).
Go over the locale module again:
- new models that avoid weird casts and inconvenient iteration
- shared timezone data
- simple sorting and filtering
- simplify the map / QML version
FIXES#1476FIXES#1426
- test insert, remove, emitted signals
- test loading and saving of YAML and JSON
This shows up a big bug in the YAML saving code (which was never
used, it seems, anyway)
- the loadJson behavior did too many notifications, and was likely to
deadlock; write directly to the map instead and emit only once.
- the loadYaml method did something very different from its
documentation or intent.
- refactor into some free functions (out of the lambda's for connecting)
- introduce new method to call from onLeave(), matching previous
widget behavior
- we can do GeoIP and GeoNames lookups, **or**
- use Calamares's internal GeoIP lookup and country / city hints.
The online version is much more accurate, but costs more lookups;
in these examples, set it all to "offline" and document what needs
to change (code edit) to use the online version.
It's probably a good beginner job to introduce a bool in localeq.qml
to switch the behaviors.
- Config has suitable strings for displaying TZ information.
Use them and automatic bindings. Don't update the strings manually.
- Suggest online or offline TZ lookups based on what the distro wants.
Edit the QML to pick online lookups (needs access to the geonames
service, though).
- Drop the variables that point at config and geoip: the Config
object has a currentLocation, which is filled in by both the
configuration and any GeoIP lookup -- it doesn't have city
or country information though.
- status is a longer phrase
- name is a short human-readable name
- code is the internal code
Code that writes its own "Timezone set to" messages can use
the name, rather than the status.
- when no location has been set at all, there's no sensible TZ
to report; just leave it blank. In *practice* you won't hit this
code from the Calamares UI before a location has been set, because
the Config object is instantiated and then immediately configured,
but from tests or unusual UIs it could be.
- needs some massaging because Config otherwise depends on
ModuleManager which is a UI class (for the Reasons),
but we already have a BUILD_AS_TEST define for that purpose.
- demonstrate a nullptr deref.
- The Config object now uses the re-done models and timezone data
- most of the properties of the locale Config are unchanged
- much less complication in extracting data from the zones model
It's convenient when e.g. QComboBox::currentData() gets the key
"automatically", and the default role for that method is UserRole,
so let the value of KeyRole overlap.
The (renamed) class TranslatableString keeps a key value
(e.g. New_York) and a human-readable version around; the
human-readable one is passed through QObject::tr() for translation
on-the-fly.
- The models are overly complicated: **overall** there is just one
list of timezones, and we need various views on that list.
Start over with an empty model of regions.
- there **is** another source of information about the CPU,
so in the test use that to cross-check what hostCPU() says.
NB: it's probably a good idea to fall back on the same file
in hostCPU() for better accuracy.
- get username, password etc. from the config object, not the page
- jobs now depend entirely on config
- handle logic of "what's the root password" in Config
- The configuration for writing the hostname (to /etc/hostname,
to /etc/hosts and possibly to systemd-hostname) is read-only,
because it comes from the config file and won't change after.
When CMake runs, configure_file() will clobber the config files in
the build/ directory, which is annoying during testing: you need
to keep making the same edits, or edit the source.
- Introduce new behavior: the config file is **not** overwritten unless
the source file is newer. This means that edits to config files
in the build directory are preserved.
- If INSTALL_CONFIG is **on** then the files are clobbered anyway (the
source is considered new regardless).
When CMake runs, configure_file() will clobber the config files in
the build/ directory, which is annoying during testing: you need
to keep making the same edits, or edit the source.
- Introduce new behavior: the config file is **not** overwritten unless
the source file is newer. This means that edits to config files
in the build directory are preserved.
- If INSTALL_CONFIG is **on** then the files are clobbered anyway (the
source is considered new regardless).
- add the "reuse user password for root" setting to Config,
make the UI page follow that setting.
- add the require-strong-password default and toggle settings to
Config; this is not well-checked yet.
On the widget / UI side, connect checkboxes only if they are
visible; refactor reuse-user-password-for-root settings.
- The language code "ie" is not recognized,
- "ia" is, and it seems to be the post-war variant of
Interlingue, so we may want to rename / relabel.
The testEsperanto test -- now split into scripts and
esperanto -- would have picked "ie" out of the list
because it does map to C locale.
- like Esperanto before Qt 5.12, Interlingue does not
seem to be supported by QLocale, so it gets turned into
"C" locale, which then messes up the default language
selection in the welcome page.
Move it to _incomplete until QLocale does support it.
FIXES#1475
The TODO said it was unused: it **is** used, but only in
a very limited scope. Drop it from jobs where it wasn't
useful (e.g. those that just return prettyName(), outside
of the partition module).
This builds some machinery so that we can create
a detector for member-functions (methods) named <whatever>.
Use the macro to build the machinery:
DECLARE_HAS_METHOD(myFunction)
then after that,
has_myFunction<T>
is either std::true_type or std::false_type
depending on whether T has a method myFunction.
- no need for the definition to be in public header, move to implementation
- while here, sort the members and private methods
- add a makeJob() to add jobs to the queue
- having a struct with an obtuse API for adding jobs-that-need-to-happen-
to-this-device is just not good for maintainability.
- break the build by making things private.
- The enum for install choice was copied into PartitionActions and
used in the Config object; its definition does not belong in the UI.
- Chase the renamings required.
- add an option to select what button should be selected when the
partitioning module is started; TODO: the actual functionality is
**not** implemented.
- drop the previously suggested name, which didn't get beyond the
comments-in-the-config-file stage (but which intended to do the
same things as this one)
- add option to schema already, even if it's not implemented.
See #1297
FIXUP conf
The encryption widget (passphrase for disk encryption) should show
ok / warning / error whenever the state changes; this avoids
it showing up first with **no** icon (it should show a warning
when both passphrases are empty).
Both the KPMCore and the ChoicePage -- asynchronously -- were connected
to the nextStatusChanged() signal. So if the core said next was true,
that could end up communicated to the ViewManager, enabling the *next*
button in the UI.
Changing to the *erase* page generally triggers a KPMCore reload,
which later emits a `hasRootMountPointChanged()` signal, once the
layout is applied and the disk gets a root mount point. So we'd
get a `true` from KPMCore, which -- because it was connected directly
to the signal to the VM -- would override any other considerations.
Hook up both signals to an intermediate slot that just recalculates
whether the next button should be enabled, based on the state
both of the Choice page and whatever else.
- drop groups from the viewstep
- note that the Config object should also be in charge of creating
Jobs (but then the de-tangling needs to be completed)
- add tests of default groups loading
Doesn't compile because QRegExpValidator is a gui thing.
The configvalidator has some extra Python dependencies. Cache
the restults of checking the dependencies (convenient for developers),
and also explain what's going on if the feature is switched off.
This is a developers quality-of-life fix: reduce the amount
of recompilation that is done after running cmake. Since KDevelop
runs cmake in the background regularly, this was causing 4 files
to be rebuilt every run that don't *really* need to be rebuilt.
Previously, we check for RCC support every single time CMake runs.
This is slightly wasteful, and it wasn't being done right anyway.
But it's moot because:
- Calamares supports back to Qt 5.9
- Qt 5.9's version of rcc (at least, 5.9.7) **does** support the
command-line argument `--format-version 1`
- Everything newer does too.
Simplify translations a little, too: just use autorcc rather than
building things by hand.
- The sources were in src/calamares but processed and generated
in libcalamares, which is weird at best.
- Generate an "extended" version header.
- Use the extended version in the logger and nowhere else.
- While here, minor coding style cleanups
The overall change here means that after running CMake, only
Logger.cpp needs to be rebuilt (if the extended version has
changed) and not a handful of other files that don't need the
full version number, but do happen to include CalamaresVersion.h
- Very rarely do we need the full-git-version of Calamares,
so split that into a separate header with a little trickery.
- In the "normal" version header, drop the full-git-version values.
This does about half of the move-settings-from-Widget-internals to Config.
By having the configuration **and** the business logic in a Config object,
we can hook up other UIs more easily while preserving the business logic.
(e.g. this is a prerequisite for QML uis, but also for scripting and
quickstart logic).
SEE #1462
- This is a half-step: the ViewStep shouldn't do job creation either,
eventually it needs to be the Config object, but this is better
than asking the widget (UI) to create some jobs.
- When updating login- or host-name, or the autologin setting,
set it in GS as well. This is a minor improvement over doing
it only when leaving the page.
- Since the Config object isn't complete, there are leftovers in
the widget, which has a fillGlobalStorage() for the not-jobs-related
bits previously in createJobs().
- since the configuration is in the UI parts, we need the widget still
to load the whole configuration (until the config object is complete).
Create the widget before doing configuration; this is wrong. But now
we don't hit nullptr derefs all over.
- make the HostName textbox just a view on the Config's HostName
- make the username and login textboxes view onto Config
- query the Config rather than the UI for job data
- delay construction of the Page (widget) until it's needed
- hand the Config object to the Page on construction
This is prep-work for putting the configuration information into the
Config object, rather than in the UI elements.
- most of the things in utils/ are in the CalamaresUtils namespace,
let Permissions follow suit. Chase the name change in the
*preservefiles* module.
- add an `apply()` function for doing the most basic of chmod.
Note that we don't use `QFile::setPermissions()` because the
**values** used are different (0755 for chmod is 0x755 in the
enum value passed to `setPermissions()`).
On the "Users" tab, the user can choose a username. It was possible to
use 'root' as username, which led to an installation error, because
'root' exists already.
Added a new check to the username validation.
Fixes#1462.
With PR calamares/calamares#1357 the label of the "Manual partitioning" option
was changed, which introduced several downsides:
* The label is shown for UEFI and for BIOS installations.
* The mountpoint of the ESP is and should be distro specific.
* The label always mentioned GPT, which is irrelevant.
* The label should explain, what the option does, and not, what
problems can occur under certain circumstances.
set index in i18n.qml to -1, old settings were just for reading from the bogus model
current model uses strings, so index fails to read from it. This fixes cala crashing on loading i18n.qml
- Expand the documentation, emphasize octal-vs-decimal
- east-const consistently in this file (most of Calamares is west-const)
- shuffle the is-valid bool to the end of the data members,
so sorting by size.
- already had methods for various kinds of broken-up data, but
not one for plain "region/zone" strings; having this makes
it easier for QML to report a zone.
- use the region/zone method from QML, so that clicking on the
world map updates the actual TZ in Config.
- get network status from the global Network object; document that
- get the strings describing the language and LC settings from
the config-object instead of roll-our-own
- use the model of supported locales from Config to populate listboxes
- connect selection of language or LC to the Config object
- remove stray and useless TODOs
- remove unnecessary empty overrides
- clean up includes
- drop all the code that is now in Config
Since the business logic (setting locations, maintaining GS, ...)
is all in the Config object, the ViewStep is remarkably simple:
hook up a UI to the Config, which in the case of QML is done
automatically.
- since the Page hooked up a model and changed the region-selection
**after** connecting to signals, it would reset the location
to Africa/Abijan (alphabetically the first timezone) during
construction. Don't do that.
- this doesn't do the lookup **yet**
- while here, refactor setConfigurationMap so it reads like a story,
with chunks bitten out into a handful of static inline void methods.
- read the *region* and *zone* settings; this duplicates what
the ViewStep does and is currently unused, but ..
- add new support for using the system's TZ (rather than
the fixed values from *region* and *zone*). This complements
GeoIP lookup.
This is the actual feature that started the long rewrite of
the Config object (so that all the business logic would be in
one place, usable for both widgets and QML).
FIXES#1381
- writing *localeConf* settings to GS can be done always when the
formats are set, rather than special-cased. The code
that handles the "special case" of no widget existing for the ViewStep
overlooks the other crashes that happen then.
- Since Config knows what jobs to create, just ask it rather than
keeping a copy.
- allow finer-grained control over whether-or-not to adjust the
timezone in the live system.
- handle some special cases at the point of loading-configuration.
- document the setting in locale.conf
- correct some documentation bugs
- adjust the YAML schema for locale.conf so it's legal YAML syntax
**and** validates the current file.
- since all locale changes need to be entered into GS anyway, this
is something the Config object can do because it is the source
of truth for locale settings.
- drop all the GS settings from the Page.
- remove the weirdly-structured prettyStatus and similar:
the Config object has human-readable status strings (three,
for location, language, and LC-formats) which can be
normal properties with signals.
- Implement prettyStatus in the view step by querying the Config.
- the language and LC settings migrate from page to config
- add API for explicitly setting language (which is then preserved
when clicking new locations)
- since Config knows what settings there are, it should create the
jobs to run later -- not the Page.
- this doesn't work yet, because the Config does **not** know what
the selected timezone is yet.
The Config object wasn't being used at all in the locale module;
reset it to empty and start using it in locale, so that
configuration functionality can be added to it as-needed,
and with the necessary refactoring built-in.
In 022045ae05 a regression was introduced: if no *slideshowAPI*
is specified in the branding file, Calamares refuses to start, with
a YAML failure.
Before the refactoring, we had `YAML::Node doc` and looked up
the *slideshowAPI* in it with `doc["slideshowAPI"]`. After the
refactoring, we had `const YAML::Node& doc`. The `const` makes
all the difference:
- subscripting a non-existent key in a mutable Node silently
returns a Null node (and possibly inserts the key);
- subscripting a non-existent key in a const Node returns an
invalid or undefined node.
Calling IsNull() or IsScalar() on a Null node works: the functions
return a bool. Calling them on an invalid node throws an exception.
So in the **const** case, this code can throws an exception that it
doesn't in the non-const case:
`doc[ "slideshowAPI" ].IsScalar()`
- Massage the code to check for validity before checking for scalar
- Add a `get()` that produces more useful exception types when
looking up an invalid key
- Use `get()` to lookup the slideshow node just once.
- previously, the first column (name) was sized to show the
names **that were visible at startup**, which fails when
there are long names hidden in groups that are not expanded
immediately.
- change the columns to resize according to the contents; this makes
the descriptions jump to the right as the name column gets wider.
FIXES#1448
- there are no consumers for checking-the-capacity-of-the-drive
This parameter was introduced in 3cd18fd285 as "preparatory work"
but never completed. The architecture of the PartitionCoreModule
makes it very difficult to get the necessary parameters to
the right place, and it would probably be better to put
a SortFilterProxyModel in front of a partitioning model anyway.
Since the display code can already filter on size, just drop this one.
- make the rectangles slightly larger
- align text to center of the rectangle
- make the rectangle fill out the column; without this, the
width would collapse back to 0 after a change in the model,
which would draw 0-width rectangles.
FIXES#1453
- continuations, for the console, no longer print the date + level,
which makes things easier to visually group and read.
- the file log is mostly unchanged, except it contains more spaces now.
- Only copy over branding files if they are newer
Typically I have KDevelop open while working on Calamares; if I
am editing settings in `branding.desc` in the build directory,
then every time KDevelop runs CMake in the background, my
changes (for testing branding things!) would be overwritten.
Don't do that.
For normal builds with a clean build directory, this doesn't change
anything since the target is missing; changing a file in the
source directory **will** copy it over the build directory version.
- fix the schema so the schema is valid json-schema
- the schema doesn't actually validate the *operations* yet
- sort the named backends (needs a double-check that the
list covers all the ones we currently support)
SEE #1441
- Don't do in code what is already done in the designer (.ui) file
- setFrameStyle() is difficult because it mixes different enums
into an int, which causes the warning from clang.
Improve margin handling.
There's a margin around the "central widget" in Calamares, which serves
to keep the contents away from window edges. This works for widgets,
which all have a content widget with a layout, but is a little weird for
QML components: the QML component probably has its own internal margins,
and the margin around it serves little purpose.
If there's panels (navigation, progress) around the central widget, the
margins also serve to keep the content away from those navigation
elements.
**But** if there are no panels, then a QML component still gets a margin
around it. Pretty much the only reason for a no-panel setup is that you
have a full-screen QML version of Calamares where the navigation is
"inside" each QML component. This could be the case in a customised OEM
tool built from Cala, for instance.
For this special case, improve overall margin handling by giving the
view steps some control over their own margins.
FIXES#1446
- Add access to the panel-sides membe of the view manager, and
calculate which sides are populated by panels (if any).
- Pass the calculated panel-sides to the view manager before it
starts adding viewpages, so they get consistent margins.
The signing key expired some time ago, and while I made a
new signing key, there's no indication that a different
key is being used. Update the ID for future signatures.
- Give classes a virtual destructor that need them
- Remove spurious ;
- Refactor addJobs() because that doesn't need to be in a class
- Remove redundant intermediate base-classes
- The USE_* infrastructure is only **inside** the Calamares build
tree (see `src/modules/CMakeLists.txt`) so there is no point
in referring to external repositories.
- Some variant helpers take a default parameter if the map does not
contains the given key or if the type mismatches. Make all helpers
behave the same.
- Initialize the attribute partAttributes to 0; it is a primitive type
and it is not initialized in some constructors.
Fixes commit c1b5426c6 ([partition] Add support for partition attributes).
- Move implementation of default constructor to cpp.
added missing components listed as ResponsiveBase, ListItemDelegate & ListViewTemplate
parts of which were on nitrux
keyboard.qml no longer uses buttons within ListView, can't work as buttons and have them visible
see https://doc.qt.io/qt-5/qml-qtquick-listview.html#footerPositioning-prop
set ListView as actually visible within a normal calamares window size
- If the 'no tracking' box is checked, then the way to uncheck
it is to tick some **other** box.
- It doesn't make sense to unselect 'none' and then have .. none
selected.
In clang-format 10, SpaceInEmptyBlock is introduced, and defaults to
true .. which is different from the earlier formatting versions did.
For now, refuse clang-format 10, and search specifically also for
clang-format-9.0.1 because that's what I have on my laptop.
At some point, switch in the config option and then require
clang-format 10 or later (because earlier versions refuse to
run with an unknown config option)
KDE neon does not do this kind of tracking -- although it was originally
requested by KDE neon, no server roll-out was done once the
privacy policy was thought out.
- give the on-some-checkbox-state-changed slots better names
- while here, refactor is-any-actual-tracking-option-checked
- improve other debug messages, to be a whole sentence
- QString to-integer members detect if an integer string begins with
"0x" (base 16) or "0", base 8; but QVariant members do not.
- QString: the C language convention is used is base is set to 0.
- Convert to QString and use its member toLongLong() and set base to 0
to detect integer strings begin with a prefix.
- These have **not** been fixed for validation, so the schema's themselves
will fail to load. This is a consequence of variations in JSON-Schema
representations through various drafts. Fixing the schemata is
fairly straightforward.
This gives us 19 new tests, all of which fail.
- Note that this is missing *languageIcon* so if that gets uncommented,
it will fail validation.
- While here decide that should be
right up front in object (mappings) declaration.
The config files have fairly extensive documentation but no
formal description; adding JSON-Schema into the mix makes it
possible to write a machine-checkable description.
- The size of a 2GiB partition (in bytes) is larger than the largest
32-bit signed integer; we hit signed overflow while calculating
2^11 * 2^10 * 2^10 and the test fails.
- Switch the whole table of sizes to qint64 instead.
- For testing purposes only, introduce a _qi suffix for qint64.
FIXES#1430
- The variables that are set for out-of-tree builds are prefixed
with to avoid name clashes; make the module-infrastructure
respect those instead of the in-tree variable names.
- .. and then duplicate the in-tree variables to the out-of-tree
variables, so we only need one set of module instructions.
Install all the relevant CMake, libcalamares and libcalamaresui
files -- config and headers -- so that external modules can be
created (again). This support had severely bitrotted, so
that the only effective way to add modules was to do so inside
the Calamares build tree. Now it's independent again.
FIXES#1428
- Calamares complains if this isn't set, so the example should
probably be 'safe' from that complaint. With 3.3 plans including
'fatal error instead of warning' this should be fixed on-time.
- All the headers go to relevant subdirs, but we don't keep
libcalamares and libcalamaresui apart.
- While here, remove unused variable from libcalamares CMake
- link the library privately -- the public API uses QVariantMap
- install FindYAMLCPP just in case
- add yamlcpp explicitly in the few places that really need it
(e.g. netinstall testing the parsing of netinstall.yaml)
- Add the Calamares CMake-modules to the search path automatically
- Export to CalamaresTargets.cmake and use namespace Calamares::
- Document imported targets
- Find Qt, because the translations machinery will need macros from that
- The installed lib links to IMPORTED libraries from KF5, so we need
to find them (again) as well.
Show failed requirements in one component, with a filter applied,
and with satisfied and mandatory (the latter has an effect on
can-we-continue, not on whether something is satisfied) colors applied.
FIXES#1427
- Do all the status indication in one component, but vary
the top-level message based on whether the mandatory
requirements are satisfied.
- Vary color and icon based on each requirement's *mandatory* setting.
When entering the page, en_CA maps to us keyboard, not ca_eng --
this will annoy those people who have that specifically set,
so it needs separation of "setting from GeoIP" and "setting
because system is already like that".
Not touched in the Config class because that's not used yet.
FIXES#1419
- Value is configurable (through the "selector" which is passed
to GeoIP lookups). This is convenient for tests so you can "fix"
the value that the lookup will return.
- The Radio's are replaced by CheckBoxes and some logic, so
that different tracking styles can be enabled independently.
None of the settings end up in the Config yet, though.
- Uses global storage to steer the jobs that are created, in case
the slideshow needs to be tweaked by percentages or whatever.
- While here, add some code docs and apply coding style.
- When loading QML V2, both loadQmlV2Complete() and changeSlideShowState()
lock the same mutex, introduced in e7f4479df1.
- Explicitly unlock when loading is done and we need to change the state
immediately.
- For testing purposes, it's useful to load a module externally
and then register it to the ModuleManager (this hands off ownership).
- Refactor overall module loading to use the exposed single-module method.
- QML files need to be searched in specific places; this was initialized
by Calamares, but not for the text application. Move initialization
into the library.
- fixes:
12:44:25 [6]: Python Error:
<class 'TypeError'>
'builtin_function_or_method' object is not subscriptable
File "/usr/lib/calamares/modules/rawfs/main.py", line 188, in run
item.copy(filesystems.index(item), len(filesystems))
File "/usr/lib/calamares/modules/rawfs/main.py", line 99, in copy
if libcalamares.job.configuration["bogus"]:
- The -s will run the slideshow with a bogus job-queue, allowing easier
testing of the slideshow. This is more convenient than having a Calamares
with an empty show and a bogus exec section.
- The -s option for running the slideshow / execution phase of
Calamares needs to create a bogus Module for the ExecutionViewStep.
- Previously, unless setDefaultFontSize() was called explicitly,
the default size would be 0, leading to unexpected and weird
displays (and a warning on stderr).
- If setDefaultFontSize() is not called, get a sensible size instead
(like defaultFontHeight() was already trying to do).
- When loading *view* modules, we always need a QApplication for GUI
bits, because the widget for a module is created is very early.
- If it's a view module, replace the application object with one
that supports GUIs; without the --ui flag, though, it will just
run the jobs.
- All the configuration lives in the Config object (or the
tracking objects that it exposes).
- Get data from the config object for the jobs; TODO: give the
jobs a less-clunky interface.
The UI isn't hooked up to the Config object yet, though.
- a single tracking type can be enabled for configuration in the
config file; each must have a policy URL. Class TrackingStyleConfig
is a base class for that kind of configuration.
- root_mount_point was used initially for logging c1a139995 (adding new
bootloader job options are to use grub for BIOS, gummiboot for efi set
extra mountpoint when efi is found)
- the trace was removed since 533031b3c ([bootloader] print() does not
log)
- The Python configuration tests sometimes need extra setup, so
do that through a CMakeTests.txt file in the test directory.
- Patch up existing tests:
- grubcfg needs /tmp/calamares/etc/default to exist
- rawfs won't work on FreeBSD because of differences in /proc
- drop the *discard* from filesystems-on-SSD in the standard example
configuration.
- keep the table **with** *discard* around for referece and explanation.
Remember that the example configurations are intended as **examples**,
to document available settings, and do not reflect a sensible
production configuration.
FIXES#1395
clean up obsolete lines in welcomeq.qml
add requirement section from welcome.conf to welcomeq.conf
data shows correctly in Recommended.qml, fails to show any in Requirements.qml if run without admin rights
This makes it possible to remove QML from Calamares, possibly yielding
a smaller, lighter installer; it takes with it the nice slideshow,
modern configurable navigation and the QML UIs built for various modules.
By default, WITH_QML is on and the "normal" feature set is retained.
- look for Qml modules only when WITH_QML is on (the default)
- look for Network, since that's pulled in only implicitly
- disable the QML Calamares models (modules/*q) if no QML is
enabled; longer-term plan is to merge the **pages** back to
the "upstream" modules, and have things be run-time switchable,
but that's not here yet. Also disable the notesqml module when
QML is off.
- reminder to make all the ABI-relevant WITH_* settings available as #defines
- move the compilation of KDSAG to the calamares executable, not the library
- when DBus activation is on, drop all of kdsingleapplicationguard
- It is the requirements model (checking) that reports progress, and now
the model is accessible (ask for it with requirementsModel(), make the
messages come from there.
The requirements-checker in the Welcome module was not connected
to the module-manager's idea of what the requirements are, but
the *next* button was. So you could get in a situation where the
welcome modules' requirements were met, but **other** modules failed:
no display of the problem, and a disabled *next* button.
Rip out the welcome module's requirements-checking model, move it
to the module-manager, re-do the signals between the lot.
- The architecture of letting someone build up a list of requirements
from data emitted by the ModuleManager is broken: if it gets loaded
later, it will miss data; passing around complicated objects is
no fun anyway. Get rid of it, on the way to "ModuleManager has
its own model of requirements".
- Give the ModuleManager a RequirementsModel -- that is the source
of truth about the module-requirements of the modules managed
by that particular ModuleManager.
- Let the RequirementsChecker operate on a given RequirementsModel.
- The requirements are collected by ModuleManager, checked
by an internal RequirementsChecker and changes to the
requirements state are all signalled from ModuleManager.
By connecting the requirements in the welcome modules' Config
only to their own configs -- and immediately checking them,
which is bad on its own -- we end up with a disconnect between
what the ModuleManager says about requirements, and what
the welcome modules report on.
Doesn't compile (but I need to get it off this machine)
- Prepare to implement a picture-based slideshow alongside QML
- Split QML loading into the slideshow component
This might be good prep-work for moving QML loading out of the QMLViewStep as well.
fully implemented:
* loading of a live map, ESRI based, zooming & dragging possible
* IP address is translated to map coordinates
* loading of the map centers to the obtained coordinates, with a marker set
* coordinates are translated to a timezone, label visible at bottom of the map
* mouse movement will show changing coordinates
* clicking on new location will center map there, marker moved too, timezone label adjusted
* hasInternet switch set to either load Map.qml or Offline.qml
not done:
* get hasInternet status
* fill the fine-tune 181n.qml with proper locale & language data
* connect the obtained timezone to globalstorage
comments are left in the various files for what needs attention/changes
Improve testing framework while adding tests to rawfs to double-
check that the conversion (for Python 3.3 compatibility) of
capture_output is correct.
- If a module has tests/#.global or tests/#.job, these are used
as arguments to a test-run of loadmodule (which reads them
and runs the module with that configuration).
- This makes the old python-loading test and test-runner entirely
obsolete, so remove them too.
- By default, try to use DBus service to keep Calamares unique
- The older implementation via KDSingleApplicationGuard is still
available, just not used by default.
- Calamares doesn't like to run multiple instances, since they would
interfere with each other (stealing disks from each other, for instance).
The single-application code tries to prevent that.
- For -d runs, for developers where presumably they know what they are
doing, the single-application restriction is annoying: especially if
you need two instances at once for some kind of visual comparison.
Drop the single-app requirement if -d is given.
- If the QML navigation panel sets a height, use that
- If it doesn't, use 48px (which *may* make sense, but like many
screen dimensions in Calamares doesn't take HiDPI into account)
- Give the demo QML an explicit height of 48
- This code has existed for a long time but never stored anything
to the Branding object, and the most literal slideshow (just some
images) was not implemented.
Region "Africa" zones # 52
14:25:19 [6]: .. Zone "Asmara" QPoint(445,183)
14:25:19 [6]: .. First zone found 2 "2.0"
14:25:19 [6]: .. Also in zone 3 "3.0"
- All failures were being reported as Timeout, which is confusing
when they are not. Introduce HttpError for the not-timeout
other kinds of errors.
- Add operator<< for RequestStatus for nicer error logging.
- The Config object can handle GeoIP loading on its own. Both
View steps that used this had a derpy view->setCountry() that
didn't really do anything with the view anymore.
- This forces the EFI firmware to boot the loader that was just
created, whatever the boot order set in the firmware setup (USB,
CD/DVD, HD...).
- It is safe to use the first Boot Entry listed in BootOrder as the
previous command creates the new entry and adds it to the first place
of the BootOrder.
- This is a good example of being overly clever in C++
- the whole API with an enum requesting a specific string is a bit weird,
although it makes sense from the 'might need more strings specified'
point of view.
- sometimes if you use external OEM modules you might have those lines already present
- by skipping them you won't have double lines when rerun the module in a later step
Merge in the documentation from Bill Auger and then implement
what it documents (this had been missing; productWallpaper was
an orphan setting).
FIXES#1380
- If we have a wallpaper, bung in an extra QWidget between the main
window and the panels (sidebar, nav and main) where we set a
stylesheet that displays the chosen image.
- things that can be done in the designer file should be there,
not weirdly repeated in code elsewhere
- drop the insertion of an extra spacer (why not include it in the
designer file?)
- shuffle all the connect() calls down to the end of the constructor
This commit adds the new configuration `efiSystemPartitionName` to the
file partition.conf.
This option sets the partition name to the EFI System Partition that is
created. If this option is unset, the partition is left unnamed.
- Use << Logger::NoQuote{} to turn off quoting **and** the space
- In practice, in Calamares we use this only around other processes'
output, where we want neither quotes nor spaces.
- the test checks that the default locale is C or en_US .. let's just
make it so instead of relying on the environment. This fixes tests
on my dev-laptop, which happens to be set to en_NL (with volapuk
date format).
- Although we long ago replaced the getPartitions implementation, the
test is still there, and on a machine with no /dev/sda (e.g. because
root is on nvme) the echo-awk-shell-pipeline can give an empty string;
this is turned into a QStringList{""} which has one element, while
the new version has 0 elements.
- Special-case the test that empty strings should be empty lists, rather
than 1-element lists with an empty element.
reads data from languagesModel correctly, debug added to see index changes
code cleanup
button layout improved
install info text added, better spacing of text
about button no longer commented out, 3 reasons:
- info provided by any about is standard, will be odd if it can't be found
- about.qml is a seperate file, can be completely adjusted
- not showing it takes away the options for new QML cala users to see what is possible with Loader, thus stopping new possible contributors
- This is a follow-up to d0c205c1cc6a2ae49935c92bfd52911b9a0d43f7;
I really don't know why static constexpr const elements that are
not referenced by address need to be defined separately.
The introduction of navigation panels made them taller, leaving less
space for the locale page's timezonewidget -- which then got
comboboxes overlapping it. That's weird from a QVBoxLayout point of
view, but the issue remains that the locale page is actually a
*smidgen* (2px) too tall.
- Massage a bunch of layout code to make the default navigation panel
30 pixels again, like it was. This is obviously fragile in the face
of HiDPI, but Calamares is weak there anyway.
- Rework the enlarge signals to make it possible to claim space, so
that if a page needs more space it's easy to get; because the locale
page is just a smidgen too tall, it won't trigger resizes right now.
- rename enlarge to ensureSize() and change the meaning from
"make this much bigger" to "make sure this is displayed",
which is easier on the caller to calculate.
- the navigation bar was set "too tall", leave it at the natural
layout height for this widget
- margins needed some massaging to give contents some more space
(contents has a margin, so it doesn't need more space above
the navigation bar)
FIXES#1369
- Rich package descriptions were easy to do; added some tests
as well; also make it viable to copy a once-tested "local"
file to the downloadable YAML format.
- This isn't something that Calamares can acutally fix,
so the test will be disabled later. After all, if
Brazzaville and Kinshasa are close enough that on the
map they are the same pixel, we can't move the cities.
- Merge all the format documentation into netinstall.conf,
where the example is given in full as an embedded
*groups* entry.
- Get README.md to point to the example.
- Fix up headers in netinstall.yaml, pointing to the
embedded example in netinstall.conf.
Timezones updated for these countries found on pixel detection tool
Dublin is in 0 (-1 needs editing)
Gibraltar should be 1.0 (0 needs editing)
Guernsey and Jersey are in 0 (1.0 needs editing)
Lisbon is in 0 (-1 needs editing)
Vilnius should be in 2 (1 needs editing)
- QImage needs Qt5::Gui, so this isn't a guiless-test; it can use
the offscreen QPA, though.
- Check that the images are all the same size
- Debugging / check code removed from timezonewidget
- The idea is to check all the TZ images for consistency, like
TimeZoneWidget::setCurrentLocation() does when DEBUG_TIMEZONES is
on; a zone-pixel should be set in only **one** image.
The test so far is just a stub.
- Make all four DEBUG_ flags actual CMake options, rather than
stuffing some of them in the rather-peculiar _enable_debug_flags.
Each debug option turns on suitable compile flags in the module(s)
that are affected.
- When writing YAML, given a float **always** write
some decimal digits (e.g. "1.0" rather than "1")
so that the type of the written-out thing stays
float.
- Avoids test failure with the sample `welcome.conf`
file which reads 1.0 and would write out 1, which then
led to type differences.
- Handle qlonglong explicitly
- Add a fallbackfor things that convert to qulonglong, to
avoid these remaining integer types from hitting the
very end of the if-chain, and being written out as
the **string** "<typename>"
When one of these common names for the netinstall page is used,
it gets pulled out of the standard translations, so that it
doesn't have to be translated in the per-distro config file.
These labels are common enough that they make sense for
everyone to have lying around.
FIXES#1367
(I say "fixed" but of course it's going to depend on the translation
workflow to make these available)
- In production, cDebug() might not show up, so the log will not
contain the lines saying what program is being run;
- Errors should at least mention the program name, but "env" or
"chroot" is not useful, so pull that from *args*, which is
the command we actually want to run.
- an empty command isn't going to work (although it might successfully
run chroot or env in the target system, that's not useful)
- while here, move variable declarations closer to their use.
- Slice overall progress into chunks, with each chunk of equal size
(as long as we have no overall count information) and place
the progress of the current chunk into its own slice.
- The entry knows where it should be mounted, and can remember that
- mount_entry() didn't use self, so made no sense as a method
of the Operation class
probably due to dynamically loading items
regionModel now lists, zonesModel only lists one delegate, but
working on QML modules can now continue without crashing cala
This doesn't actually **work** though, the QML uses older Calamares-internal
APIs and uses a ResponsiveBase that we don't have. Merge it mostly for
the Config and model changes.
FIXES#1355
- Add some extra checks for validity of m_currentStep (an index)
- Start off with explicitly invalid index, and keep it so until
loading is complete; this prevents the situation where quit-at-end
gets triggered after loading the very first module.
- io.calamares.modules doesn't exist
- ResponsiveBase doesn't exist
The module is now non-functional, but at least it loads and renders
a list of regions and zones.
- name default / example QML conventionally
- copy QRC from keyboard -- the QML needs to be included in the QRC --
since we don't want to have the QML in the keyboard module.
- follow branding settings, taking the panel-sides into account
- drop fixed width and height for QML parts
- give panels a minimum appropriate-dimension if they don't have one
This allows, for instance, putting both Widget sidebar and QML navigation
on the left-hand side of the window.
- Introduce an enum for panel-side
- Expose this to QML -- I can imagine that QML panels need to know
which side of the Calamares window they're on.
- Refactor loading the setting into a method that handles both
flavor and side
- There's no real reason to force the sidebar left and nav at the bottom,
certainly with QML supporting more layouts and being more flexible,
so document a mechanism to place the sidebar and navigation along
"edges" of the Calamares window.
- With an empty list, the question is meaningless
- .. and we called this with an empty list while constructing the
ViewManager; if quit-at-end is true, then this would terminate
Calamares immediately because the list was at the end.
- put signals in conventional place
- remove const int& parameter, that can just be int
- drop oddly-guarded code (that leaks memory); if the index (row)
being passed in, it's probably best to just crash
- remove unused signal warningMessageChanged
- Now the back button should be done by clients as well
- Refactor in CalamaresWindow to avoid leaking local button pointers
to surrounding code.
- Add macro UPDATE_BUTTON_PROPERTY for convenience in ViewManager
(ugh, macro) to change a value and emit corresponding update signal.
- add properties for the next button (enabled, label, icon...)
- update those properties as normal
- connect to the properties in the UI implementation
using Loader, can be reused for other widgets conversion
leave onClick example with full path, commneted out
title text for About is hardcoded, discuss option to make this configurable in welcome.conf
background color hardcoded, tested to work well in dark themes too
- since we've got two blocks of code copy-pasted, which both
decide to call one or the other of two member functions based
on a flavor value, turn that into a templated function.
- passing member functions looks a bit weird, and calling them
is syntactically surprising, but it cuts down the code a lot.
- the checker only collects and calls requirements; it has no
UI component, and only manages data (and a thread to do the
checking). Move it out of the UI library.
- this function lives in Module -- and is the only thing typing
Module to the ViewSteps and JobTypes. Split it out into its
own funciton. Nothing else in Module needs to befriend the
ViewSteps, so we move the friend declaration around a bit
as well.
- while here, apply coding style.
This is prep-work for moving module to libcalamares.
- drop the current and completed roles, and expose only
the currentIndex. QML can use the QObject property on
the model, while QWidgets can call internally through
the model's data() function.
- we don't need to provide role names for this, so drop that bit.
- simplify the delegate code while here.
- Groups inherit slightly differently: if a subgroup **explicitly**
configures criticalness, use that. It would be weird, but possibly,
to have a non-critical subgroup of a critical group.
- An unselected group with (some) selected subgroups was not
displayed as (semi)checked -- it was unchecked, because
its checked-ness was not updated based on the children.
- the `parent` when installing a translator was not used, so drop it
from the API. Chase some uses of the API, but leave welcome-modules
broken: there's a merge of those coming.
- isEfi only used meaningfully once
- if (isEfi) followed by if (!isEfi) can be simpler
- create bios-but-not-GPT strings in one go
- mark TODO that this should warn only if needed
- use weird * notation for branding-strings
- In some cases, it makes sense to close Calamares automatically
when it is done. Set *quit-at-end* to do so -- although this
probably also means you should remove the *finished* page.
- It's annoying to have 100% progress reported (from the processing
of list items) and then have another 3 seconds delay.
Unrelated to the issue-at-hand, but spotted in testing.
- while the queue is executing (the thread is running jobs) the
isRunning() method returns true.
- re-work some internals to reset isRunning() before emitting
finished() signal.
- Instead of loading all in the constructor, provide a public
setupModelData().
- This allows creating the model and setting it for UI, before
the load completes.
- Add initial definition of Config object, which will extract the model-
setting and loading code from the page, and which is also prep-work
for a QML version of this module.
- While here, remove superfluous code
- For a static list of selectable packages (e.g. what you might otherwise
use file:/// for with a static file on the ISO) you can now stick the
list in the config file itself, simplifying some setups.
- Also saves faffing about with network.
SEE #1319
- `local` is supposed to read from the config-file, rather than
externally; this simplifies examples, makes it easier to have
multiple netinstalls, and condenses the documentation.
- Check groups
- Check whole treemodels recursively (this is not in PackageTreeItem,
because that explicitly ignores the tree structure).
- Also a stub of checking example files (from the src dir)
- Just some simple tests for the Items
- Test creation of package group from variant
- This needs Qt5::Gui to link because QStandardItem is a GUI class,
although we can run the tests without a GUI.
- This doesn't compile right now.
- The nested class ItemData doesn't do anything useful or
meaningful that having model items with the right data wouldn't.
- If we're converting a YAML map to a QVariant (Map), may as well
express that in the types. This makes the return from, say,
`yamlMapToVariant()` cheaper, but incurs conversion in
`yamlToVariant()` .. previously the place for costs was
swapped around.
- For those cases that want-and-expect a Map, or List, this makes
the calls slightly cheaper. For the generic case, the costs move
around internally.
Pull in the instance-weight changes and type-improvements,
but not the part where special-casing of unsquash is dropped:
weights are still per-job, not per-module.
- can't convert lambda-with-captures to a function pointer (Clang 9)
- instead, use a context property .. QmlViewStep already sets a
"config" property with the Config object, but WelcomeQ wants it
as another name as well.
- this avoids registering the Welcome object across all QML pages,
as well.
NOTE: needs to have the QML adjusted for this change.
- Replace a map-of-strings with a class type.
- For now, doesn't compile.
- Intention is to construct from a YAML / QVariant from the
*instances* list in `settings.conf`.
- Refactor into a support method and two API points
- Use std::transform for doing-things-to-a-list
- Add searchQmlFile that only takes a name, for
non-modules to use.
- Registration of QML modules may need to be done
for more parts of Calamares. Move into the library,
out of the model.
- Register for QML when using the QML sidebar.
- This is utility code, so it can be in the QML "service"
from Calamares, rather than in the QmlViewStep itself.
That makes it usable for other QML bits as well.
- The name is just the module identifier, and now we
search for *m@i* and also *m* from that identifier,
the name becomes much less important -- and it
can be set from the config key *qmlFilename* as well.
- To avoid name-collisions in otherwise well-behaved
modules and configurations, make the QML settings
more specific:
search -> qmlSearch
filename -> qmlFilename
- Having a ProgressTreeModel that does nothing but
proxy to ViewManager methods is kind of useless.
- Move the relevant code from ProgressTreeModel to
ViewManager.
- Remove now-unused ProgressTreeModel.
- The model is a simple list, not a tree (it may have been in the
distant past).
- All the information needed comes from the ViewSteps held by the
ViewManager.
- The delegate and fake-step handling was never used.
- Introduce convenience methods getString(), getBool() to pick
out an entry from item definitions in YAML format.
- Apply coding style.
- Pick up the "expanded" property as well.
- Use normal translation framework. The EncryptWidget was the one place
not using the "usual" translation framework, but rolled its own.
- Emphasize that the checkbox-state (checked-ness) is the parameter,
not a state of the EncryptWidget.
- All other instances of UI classes from Designer use a pointer-to-UI,
not multiple inheritance.
- Convenience method for setting the pixmap in response to
changes in the passphrase
- Tighten up types: enum -> enum class
- Reduce the scope for int-confusion by using an enum-class for
the encryption state of the widget
- Include UI implementation header only in .cpp
- Apply coding style
- Update copyright
- When Python modules emit progress, update their status message
by calling an optional pretty_status_message() in the Python code.
This is polled (later) by the execution progress bar to display
the message.
FIXES#1330
- the strange construction of Helper and treating it as a singleton
can be factored out into a separate singleton-handling instance()
function. The Helper should never be destroyed.
- when a single function does more logging, it generally marks
those as subsequent debug-messages (with Continuation, or SubEntry)
and we don't need to print funcinfo for those, since it was already
printed the first time.
- there's no string representation for a QVariantMap, so it
won't be converted; in *debug* output it looks like there's a
string there.
- off-by-one when diving into compound selectors, spotted by
test, now fixed.
In order to test some of the internals, split them into Binding.h.
This makes the interface visible for tests. The implementation
still lives in the same place.
While here, adjust the test to the changed **example** which
now lists an additional variable.
- When a Python module calls utils.debug(), there's no point
in logging the C++ funcinfo that passes the parameters on;
don't use cDebug() with its attendant magic.
- Warnings, errors, don't get funcinfo, but regular cDebug()
calls do. Other special-cases, like calling Logger::CDebug()
constructor explicitly, don't get funcinfo either.
FIXES#1328
- Allow logging any QList type (needs explicit call in usage).
- Add a DebugList inheriting from DebugListT to keep existing
code that logs QStringLists.
- For Calamares 3.3, consider using C++17 and class template deduction.
- This bug has been here since f233cac7a1,
where a check for isSet() (of the -D option) was dropped. So since then,
Calamares has always been running with full logging (-D8) on.
- The recently-added "easter egg" of showing the debug-button when
log-level is 8 (to allow debugging-in-production) trips over the
default-log-level of 8, so the debug-button is always visible.
So, minor bugs in the debugging-setup, combine to show a debug-button
when there shouldn't be one.
FIXES#1329
- The manpage for umount says that -R can only be used with
a mount point (e.g. /usr/local) and not a device name;
this makes sense because a device might be mounted in multiple
locations, but the mountpoint (and things mounted under it) lives
in the filesystem tree.
- Existing code tried to unmount -R the device, not the mount point,
and so always failed; leaving things mounted that shouldn't.
Unset GRUB_SAVEDEFAULT if / or /boot is in btrfs or f2fs partition. This avoids the error "sparse file not allowed" at boot time. Btrfs and f2fs do not support saving default entry in grub.
- because mount() returns an exit code, and 0 is "success",
the if (!code) was backwards: when mounting succeeded, the
TemporaryMount object thought it failed.
- This leads to temp-mounts being left *all over* the place
from os-prober and fstab-handling.
- See editorial in the code-comment. Still need to test that
chroot(8) doesn't need a full path, otherwise this will
go to /usr/bin/env udevadm to force lookup (redundantly
if not in a chroot)
- !failed() also means "didn't write the file because it already
exists", which is sometimes acceptable -- but not here.
Use the more-strict bool() conversion, which is only when
the file was actually written.
- Unconditionally **not** overwriting the target file isn't an option:
writing hostname, for instance, expects that to be done even
if `/etc/hostname` already exists on the target filesystem.
- Make tests more resilient: do them in a temp-dir, and clean it
up after successful tests. This was prompted by tests failing
because of things hanging around in /tmp.
- Follow original patch from Gabriel Craciunescu: just drop
the *bufsize* parameter and stick to binary reads.
Text mode was associated in my testing with multiple hangs,
which didn't show up during binary-reads.
- By the time the GS is actually written, new (for partition state)
is always false. So "new" is the wrong thing to track. It should
have had a better name anyway,
- We store custom properties on the partition objects to indicate
what happens to them; use those properties (instead of state,
as done originally), call it "claimed" to indicate that the partition
is part of this installation.
For now, only new (as in, formatted, created-by-us) partitions are
claimed.
- The effect here is that only "new" swap will be added to the system,
so in erase-disk installations, or manual partitioning.
- Install-alongside and replace will now **not** claim the swap already
on the disk; I think we'll need another UI knob for that one.
FIXES#1316
- `createPartitionList()` is called for the summary widget (via
`prettyDescription()`), and from `exec()`. Only the latter
actually *writes* to Global Storage, so it's misleading to
think that the pretty-printed version ends up in GS.
- This makes the "new" key useless, since by the time `exec()` is called
the partitoons are no longer new.
- These tests don't actually test anything in this specific module,
they do test CalamaresUtils::System.
- Wrangling System and JobQueue and GlobalStorage instances is fraught
Use regular translation machinery to support and help out translations
from the config files. This reduces the need to do all the translation
in those files -- some of it can be shared with the regular TX workflow.
- Allow TranslatedString to get a context parameter; if it has
one, it will try to use the regular tr()-infrastructure
**as fallback** for the translations from the config file itself.
- This makes it possible to offer -- and translate -- some "standard"
phrases in the module, while allowing the config file the knob
to change strings. Using one of the standard strings gets translations
for "free", while introducing something entirely new means sourcing
translations for it as well.
- The model always has two columns, and the column names are always
the same. We don't need to specially set headers for that.
- Use QCoreApplication::translation() to re-use the existing
translations and avoid creating "new" strings (in a new context).
- Now that multiple netinstall pages may be supported, it's annoying
that they all have the same name. Copy the approach from other
modules (e.g. notesQML) of having the sidebar and other labels
configured in the config file.
- Since operations are added each time you leave this page,
the existing operations (from a previous visit) need to be
cleaned up. With the old setup of only **one** possible
set of operations, this wasn't a problem. Now, merging
in operations is necessary. Implement that by looking for
the *source* property in an operation.
FIXES#1303
- Different libraries should have different EXPORTs, so that
you can IMPORT one while building the other. Reported (and
kindly explained) by Kevin Kofler.
- Stick to one header file, though.
While here, update copyright on file.
- Having the widget do creation ties the step heavily to that UI;
start moving towards a state where we have a Config object (not
here yet; it still queries the UI part) that moves data around
between UI and ViewStep.
- This makes linking easier,
- Adds the right includes (needed on FreeBSD),
- Lets us drop silly GUI setting for non-GUI tests (I think this was
a side-effect of compiling on FreeBSD, where UI would pull in
/usr/local/include).
- Let's just have one header definining export- and visibility-
macros for Calamares. They are still selected based on the
export flags (*_PRO), just defined in one header instead of two.
- The scattering of DLL export macro's is kind of useless;
there are several headers, and then the export macro isn't
even applied consistently. Just drop the one for UI exports,
which was only used in libcalamaresui.
- If the test failed, you'd get a cryptic message like
FAIL! : NetworkTests::testPing() 'r' returned FALSE. ()
So rename the variable so the failure mode is more obvious.
(Could have used QVERIFY2() instead, this is simpler)
- Use the createTargetFile() convenience functions to do the
actual work.
- This probably involves more copying around of buffers, since it's
creating one big QString and sending that off, rather than writing
little chunks to a file, but I feel this is worth the code simplification.
- Drops all the error checking for creation, though, because the API for
createTargetFile() lousy.
Introduces a "partitioning service" into libcalamares,
shuffles a bunch of things into it, tries to help out
with settling the system between partitioning actions.
- explicit use of user-visible names in EditExistingPartitionDialog
- consistent conversion of config-values to FS names (user-visible).
The GS value comes from the ViewStep, and should always match
something -- it's already converted to the canonical un-translated
so the type should be good.
Because getting the untranslated name of a FileSystem is something
that needs doing consistently, add some functions for that;
it makes it easier to spot places where that isn't done.
Probably doesn't compile, and needs extra documentation.
- The config context object should be set earlier, otherwise
QML code will try binding to a non-existent config already
- Document that QMLViewStep::setConfigurationMap() parent implementation
should be called **last**, at the end of the subclass implementation.
- Using Branding::ImageEntry, when ImageEntry is an enum class
defined *in* Branding, is superfluous, and it also confuses
moc; the enum type isn't recognized from QML.
- Take the Python wrapper for GlobalStorage out of the GlobalStorage.h
header and add it to PythonHelper instead, saving some work in
all the cases that only GS is interesting, not the Python bits.
- Physical memory can't be negative, so it is reported as
an unsigned long, but the bytes-to-MiB functions do accept
negative amounts. As long as no machine has more than 2**62
bytes of memory, we're good though.
- don't have a NOTIFY CONSTANT property
- the data is constant, so drop NOTIFY
- remove redundant signals
- remove setLabels() now it's only needed from one constructor
- Create a job and ask it to create dbus files -- either directly,
or as a symlink. Since the target chroot isn't viable, this will
fail but we can at least see that directories are created, etc.
- Since these tests all want a system object, and a GS
with a sensible setup, give them one with its own initTestCase().
This could have been done with one executable, running tests from
multiple classes, but there's not much overall benefit there.
- Used to ensure that the directories leading up to a given path
exist. Implementation is incomplete and broken for now.
- While here, avoid removing an empty pathname in removeTargetFile()
(the empty pathname indicates a broken configuration).
- Add SPDX headers
- Indent consistently (tabs, not a mix of 2-space, 4-space, and tabs)
The scripts were originally added without a license header.
Since they are simple, and re-usable, and not particularly
interesting, I've made the license explicitly 2-clause BSD.
This is unlike the rest of Calamares, which is GPLv3+; the
build system and support scripts are not the software itself.
- add a Settings::init() to do actual work
- remove the same kind of code from CalamaresApplication
- make constructor of Settings private
- initialize settings before the application
- There's a multi-stage setup for debug-mode, where the application
object also knows that debugging is set. Remove it.
- Break debug mode (because now the settings don't get debug-mode set).
- Refactor so that parameter handing is only done if this Calamares
is the unique (first) Calamares.
- To support translation testing, without needing to recompile
Calamares, load files from the local directory when debugging,
or from /usr/share/calamares/lang/ in general.
- This allows updating translations and testing them with just
lrelease (a translation build tool) installed, without rebuilding
Calamares.
- This allows distro's to ship updated or modified translations without
rebuilding Calamares.
- Most of the code was error-checking, just replace the open-read
with a call to the service instead.
- It's not an error if /dev/urandom doesn't exist in the source system
(there may be other good random sources, and otherwise we have the
low-quality random fallback).
- the list is already filtered for UTF-8, so this is redundant
- this *incidentally* fixes the problem with Assamese and Asturian,
since Assamese (as_IN) was having its only entry removed,
after which it would match Asturian (ast_ES)
- these were empty, so the widgets were hidden in the details
dialog of the requirements check; which looks really strange
if the reason the check fails is because root is required,
and you can't see that in the details.
This commit is on a branch because it changes strings, and I want
to do a release Real Soon and not annoy the translators.
- instead of counting and needing to keep track of the predicate
applied while creating the widgets, push nullptrs to the widget
list instead reflecting "this entry did not satisfy the predicate
for widget creation".
- for the list, the code can be the same as for the dialog,
only the predicate is different.
- while here, implement retranslate() since there's no text on
the list widgets otherwise.
- Create the label once, and it's ok for it to respond to links
even if there's none in the code.
- Turn into a member variable in preparation for retranslation-refactor.
- lift it out of the loop that creates the widgets
- some lambda-wankery, but the compiler hammers this down to
simple loops and you can read the resulting code as
none_of [the list] isUnSatisfied
none_of [the list] isMandatoryAndUnSatisfied
- no point in having init() called immediately after the constructor,
if it only makes sense to have one call to init() ever to create
the widget.
- while here, give it the same kind of structure as the dialog,
holding on to a reference to the list.
- Add Assamese (as) in the *ok* group.
- Although languages move around a bit in the groupings,
that doesn't change their availability; just says something
about the current translation status.
- This script is used to figure out which languages are included in a
Calamares release; it fetches translation statistics from Transifex.
- Document Esperanto better.
- Add a -v option to see the actual translation numbers.
- look for the more-specific lupdate-qt5 first, then the generic one
- in practice this is moot, though, since the only person running
this script is me, on one of my development VMs
Reported by Kevin Kofler (who rightly points out that lupdate *might*
be a Qt4 or even Qt3-era executable).
- need to force-push the translation tag (since there's only one,
and it moves through history whenever TX is pushed)
- xmllint canonicalization removes the DOCTYPE, so hack in
a pipeline stage that re-inserts it.
- txpush
- don't try to push TX for the timezone list
- xmllint --format the .ts files to avoid inconsistency between
TX tool versions
- txcheck
- xmllint --format
- hard-code the list of files, it's not worth the hassle
- don't apply XML cleanups to POT files
- strip linenumbers from POT files for diffing
- This is about 600 place-names, and the vast majority is not
translatable and would only pollute the Transifex DB.
- Instead, rely on git and PRs to update these specific translations.
This is an ugly hack, using Bill Auger's support for Job weights.
The unpackfs job is arbitrarily awarded a weight of 12. That makes it
(in a Netrunner install) use progress from 12% to 40% or so, overall,
as all the files are unpacked.
Also fixes bug reported by Kevin Kofler that unpackfs was only reporting
progress when it hit an exact multiple of 100 (instead of over 100).
SEE #1176
- this is currently just an alias for QVariantMap, which is
the type already in use.
- future plan is to tighten this up and have an actual
Descriptor class that carries only the information
actually needed for the module descriptor.
- Replace stringlist with a stronger-typed list of InstanceKey objects
- Move smashing-that-to-stringlist into consumers of the list
(just one, the debug window)
sidebar entry can be configured and translated
adding a more elaborate qml example
keeping this in dummyqml for now, another commit will follow with
continuation of dummyqml in a more aptly named module
- introduce NamedEnum lookup tables for interface and type
- drop "final" and "virtual" from methods that don't make
sense as virtual
- shuffle declaration order so the virtual API for modules
sits together
- Trying to get away from untyped strings with special meaning.
- The "split identifier" branch tried the same thing, but
was duplicating the existing InstanceKey.h work.
- need a configuration before we can start loading (to support
the variable search paths)
- refactor showing a failure in the spinner widget. On failure,
the spinner will never go away, so a message for the user is good.
- stop clang-format from messing up the table of names.
- Add Ukranian translations of zone names. Since I don't write
Ukranian, add only a translation (er .. in this case, the
proper original spelling) of Kyiv.
- Fix spelling in English following UN resolution.
- Dutch remains unchanged, since as far as I can tell the Dutch
Government still sticks to the Soviet-era spelling.
FIXES#1298
- start of a class to hold configuration information; this can
later be substituted into the WelcomeViewStep and filled from
setConfigurationMap()
In the example application:
- register the Config type
- test application to display the QML (this will be extended
with adding the locale model to it)
- sample QML that does nothing useful yet (will display the locale
model once it's there)
This branch is an experiment in doing more QML UI things in Calamares
TODO list:
- Make Label (in libcalamares/locale) a QObject
- .. and add properties to it corresponding to the data fields
- Go over LabelModel to make sure it's usable
- Add a QObject for configuration of the Welcome module,
collecting all the settings and making them accessible as
properties (this might not need to be a separate object;
the WelcomeViewStep could be the object)
- Add a QObject / property access to branding data
- Add a QML test app that loads a QML file and the objects
and models listed above and displays the QML. This allows
experimenting with the welcome-page UI through QML (without
GeoIP support or requirements-checking though)
- all the TZ location information now lives in the Calamares
locale service and the TZ list
- replace the Location class that was local to the timezone
widget by the TZZone class
- chase a bunch of small API changes that this needs
- Split the actual loading of translations into classes
to encapsulate the loading logic,
- Build a collection of classes to do the different kinds
of translation loading,
- Build a generic function to load something and update a
static pointer to the translation.
This makes installTranslator() much easier to read, and encapsulates
the type-specific loading somewhere else. While here, add a timezone-
translations loader so that the split-out TZ translations also work.
- Hide the one file from lupdate by giving it a weird suffix
- Call lupdate a second time for the timezone translations
- While here, adjust so that the options precede the directories
they are supposed to affect
I don't want to give the translation teams 444 new strings all
at once (about 90% of which don't need translation).
- Used in only one place, move to .cpp
- Drop useless scaling all the images *are* that size already
- Add debugging check that the images match expected size
- search for a key and return a type-cast pointer to the result
- while here, simplify some other code
- the find() function could be done with std::find_if but doesn't
get any shorter or more elegant
- By using QList< CStringPair* > consistently, we can save
a bunch of model code at the cost of an occasional dynamic_cast;
it's fairly rare for there to be a need for the derived pointer.
- read the file and create the regions on-the-fly, then sort the
resulting list (instead of building a string list and then
building the regions afterwards)
- needs a qwidget to put the top-items (license name, button) in
- fixes issue where the gap between the button and the hrule would
change depending on what is expanded
- Move layouting code into the .ui file
- Reduce margins hugely -- atop the title block, around the
scroll area, etc -- so that more license is visible at once.
- split shared <h1> message off
- do some string-concatenation, but only of whole sentences
- shave off some vertical space by dropping the mainsubtext item
- In code, add the necessary bool
- document meaning in the config file
- actually expand the full text if the entry is local and set to expanding-
by-default. This implementation is a bit lazy since it just pretends
to click on the toggle button.
- While here, reduce scope for UB by initializing POD members
- The arrows Up, Down, Right are used on toolbuttons, but
in the context of this module, those are directions with
meaning; give them better names.
- Because of #1268, the meaning of up- and down- may be swapped;
I'm not sure of which look makes the most sense. This is prep-
work for easily swapping the looks by using the meaningful names
instead.
SEE #1268
- we loop over all the entries anyway, so calculate allLicensesOptional
along the way (debatable whether std::none_of is clearer)
- always un-check the accept-box when resetting entries.
- Toggling the checkbox could disable the next button
because only the checked-state was used, instead of
the next-is-enabled-if-everything-is-optional member variable.
FIXES#1271
- Move retranslation to a separate slot to allow it to be
formatted nicely.
- Use calculated m_allLicensesOptional in retranslation.
- Untangle determining if all licenses are optional; std::none_of
returns true on an empty list.
- this isn't really a Calamares thing to decide, and anyway centering
on the desktop is kind of weird in multi-monitor setups and the
DesktopWidget is deprecated as well.
- Scenario: *keepDistribution* is true, and the existing file contains
a GRUB_DISTRIBUTION line **followed** by a commented-out GRUB_DISTRIBUTION
line.
- In that case, the commented-out line would change the flag back to
False, and we'd end up writing a second GRUB_DISTRIBUTION line at the end.
Prevent that: the flag can only go to "True" and then stays there.
Editorial: If your grub configuration would have tripped this up, then
you're doing something wrong. Clean up the configuration file first.
- If we update the line, then GRUB_DISTRIBUTION has been set
- If we don't update the line (e.g. because of *keepDistribution*)
then a comment doesn't count as "have seen that line".
This means that if we get to the end of the file, with only commented-
out GRUB_DISTRIBUTION lines, and *keepDistribution* is set, then we'll
still write a distribution line -- because otherwise it's not set at all.
- Previous fix would erase the distribution information (using an
empty string to flag 'preserve existing GRUB_DISTRIBUTION lines'),
but that is fragile. A distro might set that, and yet **not**
set a GRUB_DISTRIBUTION line, in which case it would end up with
a setup without any GRUB_DISTRIBUTION set.
- When a GRUB_DISTRIBUTION line is found, **then** check if it should
update the line or not. This way, we have a suitable distribution
to write if no GRUB_DISTRIBUTION is found at all.
- move the explicit checking for non-empty into a specific
(normal) password check
- leave only the-two-fields-are-equal outside of the password-
requirements framework
- having non-empty is the same as minLength 1, but gives a different
error message
- the two explicit checks are the ones that handle *two*
strings as special cases; all the other checks from
the password-requirements system only handle the one string.
- the explanations under and around the boxes is noisy,
hard to size correctly (viz. issue #1202)
- use tooltips in almost-all fields instead
- add placeholder text to be more suggestive
- since the wording of the checkbox itself (and the functionality)
is to enforce strong passwords, need to switch out some
logic and fix the wording of the documentation.
- The "convenience" method was no longer convenient, since
we now place strings on the buttons by default.
- While here, **name** the buttons so they can be themed.
- if the welcome module wasn't loaded (or loading otherwise failed)
then no text was set, leading to confusing screens with
buttons with icons but no label.
- If a module exists, and has unmet dependencies, then
that is only a problem if the module itself is *used*.
Merely existing is ok.
This triggers on FreeBSD, where partition isn't built, but
bootloader depends on partition -- so you can never start
Calamares on FreeBSD, because bootloader depends on something
non-existent.
Relax the check: just warn, and only fail if a non-existent
module is used (all those with unmet dependencies are considered
non-existent).
- Calamares scans **all** subdirs of the module-directory
for a module.desc and complains about those that don't have
a module.desc.
- For ./calamares -d runs from the build-directory, this
leads to a few complaints when some plugins have been
ignored (and so no module.desc is generated for them).
- Give the whole entry to file_copy, not just the
destination. This will allow file_copy to work
with local excludes.
- Pluck entry.destination out immediately, to keep
code changes minimal.
- Document the parameters.
- list_excludes() turns the extra mounts from global storage
into --exclude parameters for rsync; it doesn't do anything
with the destination parameter.
- while here rename to something more descriptive
- it's ok if item one creates directories where item two will write,
so don't check for existence of all directories on start-up.
Reported by ArcoLinux.
FIXES: #1252
This adds to the *machineid* module (which generates random UUIDs
for DBus and systemd) another key to configure generation of
a urandom pool in the target from the entropy in the host system.
- Improve documentation of the settings
- If sysconfigSetup is true, **only** setup sysconfig and ignore
the rest. This seems to be consistent with existing openSUSE-
derivative distro's, which set displaymanagers to something
nonsensical.
- the *mount* module inserts a rootMountPoint without trailing /
into global storage, so we can't assume that here. On the other
hand, the paths passed in to the Worker functions are absolute
paths -- adjust the tests to follow that.
- The code in Workers.cpp assumes that rootMountPoint ends in a /
so that it can have filenames appended easily; make the tests
fit that assumption, but still need to check that it is so in
production.
- refactor running the command into a helper function,
to deal with the regular if-command-failed-then-complain pattern.
- mark parameters as unused.
- move distinction about kind of DBus file up into the MachineIdJob
and remove the enum that marked it.
- Testing some of the functionality that's been added just now:
- copyfile fails, buggy implementation
- poolsize fails, buggy implementation
- removefile not tested
- read-urandom or copy-existing-file are implemented
- fairly chatty on failure
- needs tests (probably the implementation should be moved to
a separate file and unit-tested)
- keep the rootMountPoint and the path-with-random-data separate
instead of concatenating them at the beginning. Then we can
use the "clean" names also within the host system.
- this could be named isValid() instead, but basically the idea
is that this code makes sense:
JobResult r = do_thing();
if ( !r ) { /* Error happened! */ return r; }
/* Carry on .. */
- remove existing files for each kind of random-generation
that is enabled. There's a helper function for the case that
Cala is no longer setuid and needs help to remove those files
from the target (e.g. a setuid helper).
FIXES#1181FIXES#1188
You can now copy single files from the source image to the target.
You can now copy directories from the source image to the target.
- Just use the existing rsync code, which can do both
files and directory trees.
- The existing code assumed we were always copying directories.
Now double-check beforehand.
FIXES#1248
Now with documentation and chasing TryExec if a .desktop file is
given alongside a broken executable value (the value is still
mandatory, but `executable: /bin/nonexistent/no-really/whut`
is now a suitable setting).
- if a default DE is configured but the executable doesn't exist,
believe the .desktop file. Then use that, and warn if the
whole thing can not be found.
- for a DE entry which has a bad executable setting,
update the entry from the .desktop file using TryExec.
This assumes that the TryExec command is actually something
you might want to run.
- Moc generates Q_UNUSED(_a); which in turn (with clang) issues
a superfluous-semicolon warning. Existing code with automoc
uses utils/moc-warnings.h to turn off warnings that are issued
on moc code. Include it explicitly here because automoc isn't
applied.
- Sessions can be X11-sessions (living in xsessions) or Wayland-
(living in wayland-sessions). Look in both places.
- Refactor code a little to make it nicer to read.
- Drop the 1-argument QString constructor, it is suprising
- Drop the conversion to QString
- Add a toString() instead
- Drop tests for the removed API
- While here, apply code formatting to the tests
This is done to force consumers to update to strongly-typed
InstanceKeys.
- cover all the constructors
- Start with some tests that fail, showing bugs in the implementation
- Fix bug that "derp@derp" was creating a valid instance-key with
a bad module and id (need to use ::fromString() to get that
functionality).
- Extend tests with more bad cases.
- Refactor tests to simplify "this is bad" assertions.
- Things in libcalamares/ subdirectories are namespaced
according to that subdirectory (sometimes in namespace
Calamares, sometimes CalamaresUtils). Do that in modulesystem/ too.
- Do the async GeoIP checking in the async requirements-checking phase
- Do not return any requirements results -- we just need the async bit
- Drop the waiting widget, since it's not needed (done by the
requirements phase)
- If there is an item with id "" (empty), it is used as the
"no-package-selected" placeholder text.
- Existing code iterated over the abstract model and used the
name and description at the time the model was set -- but
by getting the name and description from the model, only
a single string was obtained instead of the full range
of translations.
- Therefore, when arriving on the page, the "no-package-selected"
information was displayed from the translation that was active
when the model was set.
Instead, extend the non-abstract model so we can find the no-package-
selected item and pass that explicitly to the page.
FIXES#1241
FIXES#1228
The label on the left can now be specified (and translated)
in the config file. The strings corresponding to "nothing
selected" from PackageChooserPage.cpp L33-34 can already
be specified in the *items* section.
- Since the package chooser might be used more than once, or for
more specific items than "Packages", introduce a way to provide
specific strings for display.
- The only string needed is the ViewStep name, since the item with
id "" can be used for the no-selection item.
- My usual test environment has umask set to 022, but on one dev
box it is 002, leading to test failures (which show the test
was bad, not that the umask-setting code is bad)
- sometimes a slot is easier than a lambda. Introduce
a macro CALAMARES_RETRANSLATE_SLOT that calls a given
slot in an object on language change.
- extend the retranslator with support for calling slots:
- use Qt's signal/slot mechanism alongside the private
list of functions to call
- provide convenience for obtaining the retranslator of
an object.
- This helps give meaningful names to code chunks
- Gives clang-format something to work with
- Reduces indentation depth
I think this is a bit of a code-style opinion issue: big complicated
lambdas doing UI things just don't seem like a good idea.
- since we also need to *disable* the shortcuts, and should tell a
V1 slideshow that it no longer is running,
- use existing function to set the property to true / false depending.
- instead of changeState( true ) or changeStage( false ), use
meaningful enum names so that the code at the call site
becomes readable; make the boolean part internal to the
state-changing method.
- hangs unpredictably during testing
- replace with the Calamares process-invocation runCommand(), which is also
synchronous but doesn't hang (or, hasn't, in testing so far)
- The compile failure came from bad #include paths, so restoring
this interface declaration wasn't a fix.
- Reported to cause runtime failures on both KaOS and Manjaro.
If we don't have/need an image for the rootfs, we might want to
configure the `/` directory as a source for unpackfs. Unfortunately,
this raises an error:
- unpackfs first creates a temporary directory
- it then creates a subdirectory for each source, using the source
path's basename
- when the source is `/`, the basename is an empty string, therefore
the module tries to create an already existing directory
In order to prevent this error, we use the `os.makedirs` function with
parameter `exist_ok=True` instead of `os.mkdir`.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
- Synchronous download of a given URL; not something to
do from the GUI thread.
- Use it from the GeoIP service, which downloads in a
separate thread to do GeoIP lookups.
- Drop now-unused headers.
- Adjust tests for GeoIP to use network service
- The networking service is intended to wrap up use of
QNetworkAccessManager and others for consumption within
Calamares, and to provide some convenience functions
for internet access.
- Medium term, it may also monitor network access, so that
we can respond to changes in network availability during
installation.
Currently very minimal and undocumented.
- AppData and AppStream can be disabled independently of finding
their requirements (possibly useful if you want to ignore
AppStream even when it's installed in your build environment).
- Add a little top-level documentation about WITH_
- These don't have to be static methods of PackageItem, a free
function is more convenient.
- Since it's not API of PackageItem anymore, need to
- update tests not to use API
- do API-not-available warnings in consumers
- The smallest size image of the default (or, if there is no
default, the first) screenshot is used.
- Remote URLs are not supported by QPixmap, so most will not
load anyway.
- Use *appstream* as key in one of the items for the package-
chooser to load data from the AppStream cache in the system.
- Usable for some applications; for DE-selection not so much.
- Currently unimplemented.
- Put the implementation entirely in a separate file, keep the
not-supported one in PackageModel.cpp (but only in an #ifdef).
- Makes the various optional-data-sources more similar.
- Simplify the iteration by first determining which partitions
are mountable (at all).
- This guards against the very rare case that a partition
does not have a mountPoint at all (the if guarded against that)
where the lambda passed to sort() would get a KeyError.
Instead of having a special case for extra mounts to be processed right
after the rootfs, a better approach is to add them to the partitions
list, and then sort the list by mount point.
This way, we make sure every partition is mounted right when it is
needed: `/` is obviously mounted first, `/run` is mounted before
`/run/udev`, and so on.
The overall process is therefore more generic and should suit all
use-cases.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
- the "Select language" tooltip was applied to the form, so it would
show up inappropriately all over the place
- the buttons didn't have useful tooltips.
- having show*Url and donateUrl seems inconsistent, although
the show*Url settings were originally boolean-only.
- add "show" to the Donate button setting, to make them
all consistent (putting a boolean there will generate a
warning and hide the button, that's all).
- the generic (enum-based) setupButton() can handle all four
of the buttons, so setupLinks() can go away. Only the
(re)translation of the text on the button needs to be
done, so move that to the main RETRANSLATE.
- Handle buttons and their URL-opening in a more
general way with an enum; drop existing three-boot
method and special setupDonateButton()
- Doesn't compile because consumers haven't changed.
Require KCoreAddons. This is one of the KDE Frameworks, small
and lightweight libraries adding functionality on top of Qt.
Since lots of **other** parts of Calamares require KDE Frameworks,
including the partitioning module, requiring a tier-1 for
basic functionality seems reasonable.
This brings:
- using KPluginLoader instead of an ancient fork
- availability of KMacroExpander everywhere
- kaboutdata (needed for KCrash anyway)
- kjobs (need to look into using those as a base for Calamares jobs)
Currently, the `bytesToSectors()` function rounds a partition size to the
nearest MiB unit, which may lead to inconsistencies when a partition
is expected to only be a few KiB's.
This patch changes the behaviour of `bytesToSectors()` so that it aligns
on sector size, without rounding the partition size to a multiple of
1MiB.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
Currently, all size units are expressed as KiB, MiB or GiB (resp. 2^10,
2^20 or 2^30).
In order to maximize compatibility and consistent results with other
partitioning tools, this commit adds support for sizes expressed as KB,
MB or GB (resp. 10^3, 10^6 or 10^9).
This change won't affect existing users, it simply adds a new option
that wasn't previously handled.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
- this is not entirely straightfoward, since we need
different constructor arguments for the objects
Calamares creates (no QVariantList& args, in particular).
Implement our own registerPlugin() and createInstance()
for that.
- work around a bug in K_PLUGIN_FACTORY_DECLARATION_WITH_BASEFACTORY
As the config files integer are now of type `QVariant::LongLong` instead
of `QVariant::Int`, requirements relying on this type were not parsed
correctly.
This patch fixes this, and adds an option to the python conversion to
take into account `QVariant::LongLong` types.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
Currently, a number of configuration parsing-related functions and
classes use only `int` type for dealing with integers. Should the user
need a bigger integer value, this would result in an erroneous value
being used (`0`), as the correct value would overflow the 32-bits type.
In order to prevent these overflow, this patch replaces `int` with
`qint64` in the following functions & classes :
* CalamaresUtils::yamlScalarToVariant()
* CalamaresUtils::getInteger
* NamedSuffix
* PartitionSize
This way, sizes or other integer values greater than 2^31 (for signed
types) can be used.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
When the rootfs partition is read-only, mount points for the other
partitions cannot be created, therefore they need to be created in a
tmpfs, already mounted somewhere in `/`.
However, the extra mounts are only mounted at the end, which causes an
error as no tmpfs is currently mounted.
This patch makes sure all extra mounts are mounted right after the `/`
partition, allowing the use of a read-only rootfs.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
This variable is declared in `if m:`. Of course if this codepath doesn't
run, the variable is not declared an Python doesn't like this kind of
surprise...
Signed-off-by: Arnaud Rebillout <arnaud.rebillout@collabora.com>
- If KPMcore is found -- it requires some other KDE Frameworks but
at least in pre-4.0 versions doesn't check very well for them --
then missing its dependencies is no cause for CMake failure.
Instead, log it nicely and suppress the module.
- stop compiler warnings with some judicious casting;
that's what you get when a container indexed by int
stored those indexes as quintptr.
- apply coding style
- do static initialization more carefully
- float -> qreal (double) because that's what the Qt API expects,
to reduce type-conversion warnings
- apply current coding style
- calamares_automoc() sets AUTOMOC, but also adds some flags
to avoid compilation warnings from the generated MOC code.
- drop weird hard-coded include paths
- Although milliseconds::count() is long long, we pass it to
a Qt interface that only takes int; let's assume we have
only a 32-bit count, since a timeout of 4 billion milliseconds
is roughly 46 days, which we'll just call "no timeout".
- Drop the round-trip of forming a JSON document from a QVariant,
then parsing the document into JSON objects and building a
model out of that. View the Variant directly.
- This is a fairly specialized class, for use only in the
whole-application where it ties in with the module system.
Move it to the application directory and slim down the UI library.
- Include it from the new location.
- Add UIC to Calamares (the application) because there's now
a designer-based widget in it.
- KDE and GNOME selection images were drawn by me for the bogus
package model, and should not be used.
- Keep Calamares logo though, even if it doesn't make much sense
to use it in package selection.
- Keep the no-selection image since it might be used more often,
but it's not very good.
- The ID and Screenshot entries might be weird in AppData (in particular,
a remove URL) so put those back under the control of Calamares even
when using AppData as the source of descriptions.
- Document all the static inline methods that do the work
- Fill up a QVariantMap from <name>, <summary> and <description><p>
elements, and use that to initialize the PackageItem.
- Doing a manual read of the XML, since existing appdata libraries
don't seem to have a convenient entry for what I need.
- Expand tests to loading AppData (currently, they fail).
- Massage the implementation a bit, don't insert a meaningless
copy of the key as the untranslated message.
- Add isEmpty() to check for presence of the untranslated message.
- Document API.
- Update tests.
- Add a FALLTHRU macro to annotate fallthrough situations in both
Clang and GCC,
- Annotate intentional fallthroughs.
- Add missing break which meant that the selection mode was
always multiple-selection.
- The tests should be run in C locale, otherwise the plain get()
function uses the current locale, which will fail (e.g. running
LANG=nl ./libcalamareslocaletest returns the Dutch strings for
plain get, which isn't what we expect).
- sr@latin is still special.
- Require CMake 3.3 for the IN_LIST operator in if() statements
- It looks like Qt 5.12.2 (possibly earlier) supports a QLocale("eo")
so enable Esperanto if that Qt version or later is detected.
- While QObject::tr and gettext give us translations **most** of the
time via the translation mechanism, we sometimes have strings
embedded in configuration files that need to be shown to people
as well. Follow the .desktop style in handling this.
- A key's value **might** be translated; use `key[lang]` for the
translation into one of the languages that Calamares understands.
Code that expects a translated (human-readable) string in a configuration
file can use TranslatedString to collect all the translations of a
given key, so that it displays the right string from the configuration
when needed.
- Using id's as keys in a map orders them indeterminately -- in
practice, alphabetically by key. Switch to a list form so that
the products stick to the order they have in the config file
(which means distro's can list "preferred" versions at top).
- Change to std::chrono::seconds wasn't tried against the (optional)
PythonQt bindings, leading to build failure. Reported by Phil (Manjaro).
FIXES#1210
- Need to create just one QApplication (subclass) with the right
parameters for the UI to work.
- If the UI is enabled and it's a View module, then show the widget
rather than running the jobs.
- The ViewManager needs branding information, which wasn't
initialized -- leading to crashes. Add -b option to give
a specific branding, and default to something take makes
sense when testing modules from the build directory.
- Allows the module to load; doesn't show the UI though.
Package chooser is a **low density** package selector -- unlike
netinstall which offers a high density tree view -- for picking
zero, one, or more items from a small collection of packages.
This can be used, e.g., for "pick exactly one desktop environment",
"pick zero or more text editors" which can then be installed
by another module. The UI is big and shiny (rather than netinstall's
text-based tree view) and isn't suitable for more than a dozen or
so items.
- preservefiles generally needs to have the target filesystems
mounted, so that it can preserve to them; but you can also
configure it such that there is no need for mounted filesystems
(e.g. in OEM setup).
- Add an example line in CMakeLists.txt to show how that would be done.
- The mount module must happen before unpackfs because that (mount)
module sets up the root mount point (in /tmp) and some other
variables needed later.
This factors out the functionality for the pastebin and removes
the automatic-failure it introduced, but leaves the pastebin
enabled on failure (but not configurable).
- While called from the ViewManager (to post the debug log)
this isn't really part of the ViewManager itself, so factor
out the pasting code into its own file.
Added new configuration "efiMountOptions" to fstab.conf
When generating the fstab entry for the ESP, take the mount options from
the new configuration or fall back to "mountOptions".
- The mitigations are slightly intrusive, and may clash
with other, similar mitigations (especially for initramfs,
the recommended solution is to configure the system with
the snippet outside of Calamares).
- These tests exercise the createTargetFile() logic,
which is essential for creating a safe initramfs
configuration snippet.
- Could be moved into libcalamares instead, since the tests
are not really initramfs specific.
- In tests, a System object might be created without first
setting up a JobQueue. In that case, there's no instance,
so no GS to insert into. Avoid crash here.
- Calamares may need to create files in the target system;
provide a convenient API for doing so.
- This is mostly intended for small files with constant contents.
- This is a simple variation on the theme of things-that-call-a-
initramfs-updater, so the code is mostly a copy of initramfs/
module. I didn't even bother to strip out the configuration-
handling (I figure it might be good for *something*) so now
"" and "$uname" are valid kernel names as well.
- Fixes security issue where the initramfs ends up readable
by all, and that includes the cryptfile for LUKS.
SEE #1190
- Rename classes and functions to be more descriptive
(a LuksDevice is .. information for a LUKS device, for instance).
- Move the smarts of unpacking a QVariantMap to LuksDevice.
- Apply code formatting
- Having an int timeoutSec is suggestive -- it's probably a number
of seconds -- but having an explicit type that says it's seconds
is better.
- Doesn't compile, because the implementation and consumers have
not changed.
- Use 120 seconds for update-initramfs, instead of 10. Previous
Python code had no timeout at all, which wasn't so hot either.
10 seconds, though, is too short for slow CPU & slow disk.
- Give each check a name (based on the module it runs for, so
there might be overlaps when there are multiple module instances).
- Log the remaining checks each time the timeout fires, to help
figure out which one is hanging.
- new implementation handles blank (maps to "all") configuration,
- allows specifying "$uname" as kernel name, to use `uname -r`,
- allows specifying a specific kernel.
- Just read /proc/partitions and process it; split into columns,
add relevant bits.
- This implementation supports devices named "name", which the other
didn't (but that would be really weird).
The tests now pass.
- This is a tiny bit of TDD to replace the existing implementation
(a shell pipeline) with processing inside Calamares.
- The test fails right now, since the implementations are not
the same.
- Most of the time the working dir and stdin are not important,
you just want to run a command in the host, so simplify that
by providing a suitable overload.
- Use that overload from the partition service (for mount and sync).
- updateButtonLabels() knows all the special cases for
buttons, so use it when the language changes instead
of setting up some possibly-wrong values.
- One edge case that this fixes is: have **just** the welcome
page before the first exec section in sequence. Then the
*next* button label was *next* instead of *install*.
- Minimal tests just check that all the availableTranslations()
entries have a reasonable language setting.
- Checks that Esperanto is still broken as a locale in Qt.
- The component isn't ready immediately, so instatiate
once it is fully loaded and ready
- Edge case if the execution view step is already visible, then
start the show (because a previous call to onActivate() will
have missed it).
- Copy the .qm files (compiled translations) into the build
dir as part of the build process. This is independent of
**installing** those same translations, but does allow
the translations to be used by Calamares when run from the
build dir for testing.
- Just translate two simple strings, to avoid burdening translators,
- Add Dutch translation already.
These translations are not yet processed by ci/txpull and push.
- By instantiating only on activation, an ugly "white" gap
appears where there is no widget at all. So instantiate
earlier so that the widget already exists and is painting
by the time the slideshow part is visible.
- This makes the net effect of this branch so far zero:
the slideshow is still loaded and started when Calamares starts.
- Calculate the length once at the start -- this is because
future work will modify the queue rather than just iterating
over it.
- Describe the slightly-surprising progress-percentage calculation.
- provide complete information for feature_summary
- set the right API version when building libcalamares
- report the beta version number when it's wrong
- The InternalManager object should have at most one living
instance at a time.
- getInternal() hands out shared_ptr<>s to the one living instance,
or creates a new one.
- The creation of a new InternalManager shouldn't count as a reference
to it, and it mustn't be deleted after the shared_ptr<>s have done
their work.
- So static shared_ptr<InternalManager> was the wrong choice,
since that leads to double deletes.
- While here, be a little more chatty when loading KPMCore.
- Starting to centralize utility code for partitioning into
libcalamares instead of scattered and weirdly shared between
modules.
- This particular commit breaks compiling the modules, though.
- Update coding style (more braces!) and coding documentation,
reformat parts. The idea is to go through and re-do the
coding style across the whole codebase incrementally, but
systematically, in the next release or two.
- astyle can do some things that clang-format doesn't (e.g.
adding brackets; you need clang-tidy for that),
- clang-format does a much nicer job with lambdas and certain
other constructions,
- allow passing in directories at a time for formatting.
- since we mix Python (indentation is important) with C++ (it isn't),
having indented one-line blocks which suddenly need {} when a
statment is added is confusing and error-prone. Instead, make
the blocks explicit, always, in C++.
- From an exec section, next() is called automatically when
all the jobs in that section are done.
- If there **is** no next section (e.g. there's no finished
page to show after the exec), then m_steps.at() would assert
on an out-of-range index.
- Introdcuce a helper predicate isAtVeryEnd() which handles both
out-of-range and normal at-the-end scenarios.
- If there's no page following the exec section, stay with the
slideshow but update buttons to match the normal last-page
behavior, and don't ask about cancel (since we're done).
- This avoids processes that wait on stdin, and e.g. improves
reaction to having just "cat" (no file) in a command, or
a package manager that asks for input.
- JobQueue is only needed to get global settings, which are needed
when running in the target; for host commands, allow running
without a queue.
- Settings is needed for the value of debugsettings; assume if
there's no settings object, that we're in a test and should
print debugging information.
- This is the same as EFAIL: a block is indented as if it's a multi-
line else block. This isn't Python though, and the return always
applies.
- Add the necessary braces.
- Apparently noone uses this code path (until ProcessJob was re-
factored to do so).
- Use the system runCommand() instead of a 90% copy of it.
This **does** change the overall command to `env /bin/sh -c`
rather than running only `/bin/sh -c`, though.
- Replace magic numbers like -3 with named enum values
(NoWorkingDirectory, for -3).
- Downside is big-ugly static_casts, but that's what you get
for having an int as return value for processes.
- This solves a crash where the thread is destroyed while still
running (e.g. cancelling during install).
- The thread might not cooperate in being terminated, but then we
have a bigger problem anyway (and Calamares will still crash on
exit).
FIXES#1164
- The not-publicly documented setContent() method does all the
parenting and resizing needed; some of this isn't available
from outside of the widget either.
The QML slideshow now sizes and re-sizes correctly.
- Load QML on startup, compile async
- Create QML component when the page is reached.
- On leave, stop the slideshow (otherwise, e.g. timers will keep running)
This should move some of the delay from loading a large
slideshow forward as the engine is already initialized when
we reach the install / slideshow page.
- The static destructor issues a warning on exit:
QBasicTimer::start: QBasicTimer can only be used with threads
started with QThread
so instead, heap-allocate the model. This leaks memory, but
it's a singleton *and* we're exiting anyway.
- after model resets, restore what was previously selected.
- This avoids having an **empty** combobox, SEE #1141 but does
not actually set it back to the value the user had previously
picked (e.g. changing swap settings **still** breaks the
selection).
- d78bc0c5 added an early `return false` when cancel is disabled,
before checking if we were at the last step; so last-step
didn't get any special handling.
- refactor so that last-step now gets special handling first,
**then** disable-cancel handling, and then the usual case.
- Avoid races which might double-delete the timer, or enter
the if twice (which would lead to duplicate emissions of
requirementsComplete and the associated UI glitches).
If the requirements checking is **really fast**, e.g. you don't
have a check for internet connectivity, then the checks
might be done as fast as the 0-timeout single-shot timer,
which means that finished() is called once by the QFutureWatcher,
and then after that by the QTimer .. leading to two messages
"All requirements have been checked", but also twice
requirementsComplete being emitted, so you end up with two
results lists being added by the CheckerContainer.
Stop that by using the results-progress timer as an additional
flag: the first time everything is complete, delete that timer
and set the pointer back to nullptr.
- In debug mode, hitting assert(false) is meaningless,
- In release mode, the assert is optimized out.
- So assert the condition we're actually testing, for better messages.
- It's ok to use path / filenames in images, but you can also
use icon names according to the FDO icon spec. This makes
sense for at least *productLogo*, possibly *productIcon*, but
not really for *productWelcome*.
- Using next and back buttons calls onActivate() on the view step
that you end up on.
- The first view step to be shown, though, doesn't get an onActivate()
(unless you go, say, next and then back).
- Explicitly call onActivate() on the first view step once they're
all loaded.
FIXES#1156
- Branding images might want to use os-release data as well.
- Refactor a little to keep the number of #ifdefs the same;
an intermediate expand() lambda handles expansion (or not,
if it's not enabled).
FIXES#1153
- From the debug-window, clicking *reload stylesheet* does just
that, and applies the new stylesheet to the Calamares window.
- Remove stylesheet caching from the Branding class; we only
need the sheet once (on Calamares startup) or when updating
the stylesheet, which is seldom-enough that we don't need
to keep an extra copy around.
- To use, start Calamares, open the debug window, open stylesheet.qss
in an editor. Make changes, save, then click *reload stylesheet*.
SEE #1149
- Adds another tool to the debug window, which dumps (to the debug
log) a tree-like view of all the widgets in the application.
This can be used when writing stylesheets.
- allows you to use -- at runtime -- values from os-release in the
branding file.
- WIP because the only machine I have with sufficiently new KF5
is the FreeBSD box.
- Do the checking for IsMap inside loadStrings() and use
YAML::Exception to get to bail() (since we're already dealing
with exceptions here, no extra costs). This tidies up the code
somewhat.
- Don't need an extra indirection from WITH_KF5Crash to WITH_KCRASH,
just use the cmakedefine directly.
- Since the setting is only used in main.cpp, move the define
down there and remove cmakedefine entirely.
- Checking if the **next** step is an execute-step is a little
weird, so make the API more general (and add the +1 to indexes
where it was using NextWillExecute before).
- The sub-directories under libcalamares (e.g. Utils, ..)
all live in namespace CalamaresUtils (well, except for Logger).
The services (e.g. subdirs other than utils/) live in their
own nested namespace, so partitioning should go into
CalamaresUtils::Partition for consistency.
- Clang 8 can detect that there is no need for a return if all
previous paths already return. GCC 8 does not. Clang warns if
the unreachable return is there, GCC errors out if it isn't.
- Introduce a hack NOTREACHED that comments-out on Clang, and
marks as unreachable (but still present) on GCC.
- This might go away with an [[unreachable]] annotation or
similar.
- Although None will be filtered out already by unitsComparable(),
include it in the switch to avoid a warning .. then we can
drop the post-switch return since the switch covers all possible
values of the enum.
- Use unitsComparable where applicable
- Use SizeUnit instead of unit_t -- since this is a template
specialization, we have the more meaningful type name to
use, instead of the generic one.
- Not all kinds of units are comparable. Introduce a method
in PartitionSize to check for comparability (this could
also be a free method, but seems more tidy here because it
is specifically about comparing in the context of partition sizes).
- the switch handles all values of the enum and the compiler should
be smart enough to know that (therefore default isn't needed,
nor the return afterwards).
- Declaring namespace A::B is a C++17 extension, and Calamares
is C++14. Split the namespace declarations.
- While here, fix extra const warning as well.
src/modules/bootloader/main.py (install_secureboot): Run the configured
grubMkconfig command (should be `grub-mkconfig` or `grub2-mkconfig`) to
create `/boot/efi/EFI/$efi_bootloader_id/grub.cfg`. The sb-shim is just
a chainloader to GRUB 2, which expects a grub.cfg in that location, so
something has to create it or the installed system will not boot beyond
the GRUB rescue shell.
(install_grub): Fix misleading comment above the grubMkconfig call: it
is not the file specified in grubCfg that should be already filled out
by the grubcfg job module, that file is written by `grub*-mkconfig`
using `/etc/default/grub` as the input file. It is that input file
`/etc/default/grub` that should already be filled out by the grubcfg job
module. (The same input file is used in install_secureboot.)
- The output of subprocess is a bytes object, which needs to
be decoded so we can use it like a regular string (alternatively,
we could have changed more code to manipulate bytes, but eventually
we need a string to pass to a subsequent command anyway).
- Centralize the sanitizer so that it's consistent in different
environments.
- While here, add () to the sanitizer to avoid some distro's with
parenthesized names from creating weird EFI dirs.
- FIXES#934
- Whether this is really wanted depends on the distro, and I'm not
100% convinced the likely tags from Unicode are correct (or it'd
take a lot more data). In any case, starting Calamares in "NL"
gets me "nl_NL" as translation; presumably starting it in "BE"
will get me that as well (what about Les Wallons?)
- This also shows off that it's a real hack to have so much program
logic in the *widget* parts of each ViewStep. Longer-term,
a lot of functionality should go to the ViewStep itself, which
will then control the UI.
- Which translations are available is a global property
of Calamares itself, not of the plugins, so getting
the model of available translations should live there.
Move the relevant code (which is simple) from the
Welcome module.
- Use namespace CalamaresUtils::Locale consistently for this service.
- Move locale-related non-GUI support code from the Welcome module
to libcalamares; these are generally useful. Both Label (naming a locale)
and LabelModel (managing a bunch of those Labels) have been moved.
- Lookup country data based on enum or 2-letter code
- No data yet, so return only stubs
- The (generated) data tables are not listed as sources because
they are #include'd by the API implementation; they're full of
otherwise-unused static tables, so don't make sense to compile
separately.
- While here, tidy up the CMakeLists a bit to reduce the number
of superfluous variables.
- Continuing the notion that libcalamares should provide
(non-GUI) services for modules, add a locale service.
- This will, unfortunately, roughly duplicate Qt's QLocale
database, but in a form that is public and more readable.
On systems with SELinux enabled, we have to create the directories on
top of which we mount another partition or virtual file system (e.g.,
/dev) with the correct SELinux context, BEFORE we mount the other
partition. Otherwise, SELinux will get really confused when systemd
tries to recreate the mount tree for a private file system namespace for
a service. And unfortunately, even an autorelabel does not fix it
because it runs when /dev etc. are already mounted.
Without this fix, on Fedora >= 30, the system installed with Calamares
would fail to start the dbus-broker system bus, leading to several
important pieces of functionality not working (e.g., shutdown as
non-root).
On systems without SELinux enabled, chcon (which is part of coreutils)
will just print a warning and do nothing, so this should always be safe.
Instead of relying on a module-specific implementation, use the new
PartitionSize class for storing partition sizes.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
Instead of relying on a module-specific implementation, use the new
PartitionSize class for storing partition sizes.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
Using PartUtils::PartSize as reference, this commit creates a new
PartitionSize class in libcalamares, which will then be used in every
module needing such a class.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
In order to prepare for future refactoring of the PartSize class, move
the bytesToSectors() function to libcalamares in the CalamaresUtils
namespace.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
In the sidebar, the "Install" step should be named "Set Up" when in
setup mode, which will be more consistent with the other UI texts,
including button labels.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
- Although KDE CI onlt tests with Qt 5.10, and KPMCore 4 requires
Qt 5.10, Calamares is still ok with older Qt and KPMCore 3.3,
so drop the dependency back down again. This means, though, that
the code will build against a Qt version we don't usually test.
We're going to assume that Someone Else does the LTS-Qt testing
for us.
- This small header file contained a few unrelated typedefs.
Move those typedefs to the classes they relate to. This
**does** mean that some consumers need to #include something
else instead.
- Use type names more consistently.
Editorial: why are **pages** responsible for creating the jobs?
- Remove (heavy-handed) top-level include_directories, in favor
of more focused ones; this helps to make sure that the dependencies
ordering is correct.
- Currently just moves a single enum, but this is prep-work for
moving the non-GUI parts of the module system into libcalamares,
to better support GUI-less operation.
src/modules/partition/jobs/ClearMountsJob.cpp
(ClearMountsJob::getCryptoDevices): Skip not only `/dev/mapper/control`,
but also `/dev/mapper/live-*`. Fedora live images use
`/dev/mapper/live-*` internally. We must not unmount those devices,
because they are used by the live image and because we need
`/dev/mapper/live-base` in the `unpackfs` module.
src/modules/unpackfs/main.py (UnpackOperation.mount_image): Check
whether entry.source is a regular file or a device and only use
`-o loop` on regular files, not devices.
At least on Fedora >= 29, `-o loop` fails on the read-only device
`/dev/mapper/live-base` (though `-o loop,ro` would be accepted).
- Simplify delegate: unused m_parent, tidy up inheritance, then drop
unnecessary custom constructor and extra Q_OBJECT macro.
- Drop some unnecessary included headers
- Drop single-use #define. APP was used in only one place; remove it
(that would be stylistically correct, anyway).
- Update copyright headers
- Document new label-handling
- The text rectangle was **moved**, not shrunk-in-place. Add
the missing - sign for the right and bottom margin.
- While here, move from #define to constexpr.
- Use a named enum instead of a collection of booleans
- Support old-style configuration but complain about it
- Update AppImage config as well
The new setup allows four different restart modes: never,
always, user-unchecked and user-checked. The user-modes
are interactive and give the user a choice (defaulting to
unchecked-don't-restart and checked-do-restart respectively).
The non-interactive versions vary in how they are
displayed.
CMakeModules/BoostPython3.cmake: Also try e.g. "python37" as the module
name, because Fedora 30 switched from the e.g. "python-py37" format to
that. Otherwise, Boost::Python3 cannot be found on Fedora without
manually setting CALAMARES_BOOST_PYTHON3_COMPONENT.
- deprecate the old entries
- use a geoip sub-map for GeoIP configuration
- polish up documentation
- drop mention of blank and "legacy" styles for GeoIP config,
just update your URLs already.
- Dealing with legacy formats and alternate configurations
is something that consumers should do (and then hand off
to the 3-string constructor) instead.
- If KPMCore is not found, don't require the KF5 components
that it would depend on.
- If ECM is found, use KDEInstallDirs always, not just when
the partitioning module is used.
- OEMID is a module for configuring phase-0 things for an OEM,
like batch-ID. This is just a stub.
- Currently planned functionality is limited to just batch-ID.
- The only remaining functions in the file are string-related, so
rename to match their purpose.
- Drop this include file from most places, since they don't actually
use the string functionality at all.
- Remaining modules [networkcfg] [openrcdmcryptcfg] [rawfs] with
code that throws on bad configuration. Replace with meaningful
error messages, to better check cases of SyntaxError &c.
- One might argue whether an empty list of partitions to mount is
a bad thing. It suggests that the partition module wasn't used,
and so we're in an OEM situation -- but then everything should
already be mounted anyway. That's why I choose empty -> bail.
- [initcpio] remove superfluous inner function
- [initcpio] catch errors from mkinitcpio itself and report them in a nice
readable format.
- Save translators the effort of doing a dozen messages
with just the name of the module changed. All of these modules
bail out on bad configurations with a meaningful message.
- [initcpiocfg]
- [fstab]
- [initramfscfg]
- [localecfg]
- [luksbootkeyfile]
- [luksopenswaphookcfg]
- [machineid] Warn on bad config. It's conceivable that this is run
with an empty rootMountPoint (i.e. "") to modify the running system,
so only bail on None.
- Document meaning of error codes.
- The test-loader considers internal errors a real (test) failure,
while errors returned normally by the modules (e.g. because the
configuration is broken) to be ok for testing purposes.
- Loading the module will check Python modules for syntax,
and C++ modules for symbols. This would be a good idea,
except for where it calls exec() and does things to the
running system. Most modules are harmless with an empty
config, but you never know (e.g. a process module).
- Load full text, toggle display
- Swap Up and Down arrow semantics on button, to match usual
text-editor display (down means it's expanded, displayed)
- Even when Cancel is hidden, also disable it (prevents DBUS
triggers, for instance),
- Re-enable it when exec is over, if it's disabled then.
- simplify code a little.
- If all of the licenses are optional, you should be able to
continue without accepting. Refactor to a single visible
slot to check the conditions.
- Always set the globalsettings value; to "false" on entry
to make sure it's there.
- When setting the list of entries, check the conditions
(because if the list is empty, or all of them are optional,
then it's ok to continue).
FIXES#1124FIXES#1125
- QVector is a better match with passing in QStringList, otherwise
you end up dealing with Qt's int indexes vs. std::vector's uint
indexes everywhere.
- Introduce find()
- There is no reason for JobThread to have a Q_OBJECT macro,
so drop the moccing (this also stops some warnings from
the generated moc code).
- Define the (virtual) destructor out-of-line to avoid vtable
warnings.
- The auto-generated code produces a lot of warnings from
Clang 8; this obscures the more meaningful warnings from
actual Calamares code, so tone the warnings down.
- For Clang, set CALAMARES_MOC_OPTIONS.
- Add convenience CMake function for automoccing. It applies
the options as needed to a given target.
- Use only utils/YamlUtils.h to pull in yaml-cpp and supporting code.
- When compiling with clang, turn off warnings that the system header
for yaml-cpp would generate.
- This is an older copy of kdsingleapplicationguard, now updated for
C++11 warnings; removed __ in header guards, fixed up last of 0-for-
nullptr, signedness mismatch.
This commit adds several checks while reading the configuration of the
`partition` module, in case the partition layout configuration is
misformed. If an error is encountered, an message is printed to the
console and the module reverts to the default partition layout.
Checks are also added when implementing the partition layout, in case a
problem occurs that couldn't be anticipated (for example, when a
partition size is in %, checking its absolute value require knowing the
total device size, which is not the case when the configuration is
being read).
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
Every call of `ParseStringSize` is replaced by using an instance of the
`PartUtils::PartSize` class.
This commit also removes the now-unused previous size parsing functions.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
In order to maintain consistency, and make use, create a new PartSize
class in the PartUtils namespace, which inherits from NamedSuffix for
easier parsing and handling of size strings.
The switch to using this class instead of the previous functions will be
done in a follow-up commit.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
Fixed 'prepend' terminology in comments, restored old loop as it seems to work for me now in overwriting the file as one overall multiline instead of overwriting the file with each line at a time, code simplification based on review comments... credits-adding will come in the next commit.
This change fixes a few issues and adds a few improvements to the LightDM Autologin configuration process:
Fixes:
- Fixes malforming of configuration file out of the box, as without `[SeatDefaults]`, `[Seat:*]` or similar in the configuration file LightDM will break on a lot of distributions using LightDM
- Preserves the intended lightdm.conf file settings outside of `autologin-user` if the distribution has an /etc/lightdm/lightdm.conf file of its own
Misc. changes:
- Small spelling fix
- Instead of Continuation(), write just Continuation
- All that futzing with overloads and tag-classes isn't needed
since the whole point is to output some constant string. Leave
cleverness for later, if it's needed.
- KDE neon ships a post-3.3.0 KPMCore, with deprecations, but not yet
the KPMCore 4 API, so add another API-version check to handle the
deprecations. Keeps warnings down.
- Switch debug-level to unsigned
- Don't shadow usings; the first TR type is enough
- The (bogus) return values were commented as // NOTREACHED,
but still yield unreachable code warnings. Drop them
instead, and rely on the compiler understanding [[noreturn]]
on parser.usage().
- Don't use this if we don't need it (QObject::tr is static).
- C++14 allows (copy) binding to arbitrary expresstions in lambda's,
so detach from this.
When using a custom partition layout with partition sizes in %, it can
be useful to set an upper limit to the partition size.
For instance, using a 20% size for the `/` partition will create a 24G
partition on a 120GB drive, but a 200GB partition on a 1TB drive, which
is not useful, and could be avoided by setting a maximum partition size.
This commit adds the `maxSize` parameter (with a default value of 100%).
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
- Using project() to set up the version is idiomatic for CMake
and more standardised than doing it by hand. Do retain the
RC flag, because that's used in other parts of versioning.
- Misplaced $D
- Set XDG_*_DIRS without the /calamares/ trailer
- Don't overwrite XDG_*, but append for AppImage, avoid unnecessary :
- Explain XDG_* tweaks in the AppImage documentation at the top.
- When environment is empty, use default values from spec
- Search in application-named subdirs first (but keep previous
behavior of also searching directly in the named dirs)
- Don't consider empty XDG_* elements
- Settings XDG_DATA_DIRS=":" would yield an empty list of extra
directories to check; don't bother setting haveExtraDirs for that.
- When the manual partitioning page exists, it reacts to
changes in a bunch of models; these models can be changed
repeatedly from the choice page.
- the manual partitioning page really only needs to deal with
the relevant selections at the moment it is instantiated.
- Add independent oem-setup entry to the example configuration.
- Document that things may have a default value (so you don't **have**
to set them in the file) but that Calamares will complain.
- This initial bit of code re-uses the *dont-chroot* setting;
it may need to be made independent.
- This branch will use `isSetupMode()` to adjust user-visible
strings to match the intended use.
SEE #1100
- rsync reports its own progress, and reports on files that
find -type f doesn't. This meant that the numbers didn't
match what was stored in entry.total
- The ir-phase adds files to be handled; to-phase happens once
ir-phase is over and the remaining files are processed.
By adding the to-phase files, percentages over 100% were
reported (in part because the number of files doesn't match).
- Update expected entries total from rsync output.
- Re-jig computation of how done everything is: tally it
up in integers, and do only one global progress percentage.
- The mismatch between "ir-chk" and the comment "to-check" led me
to check (ha!) the output of rsync, and it outputs "to-chk"
during small transfers; make sure the comment reflects what
is actually being used to track progress (which is "ir-chk").
- After the BootLoader model is reset, if a bootloader location
has been selected before, try to find it in the (now-reset)
model to preserve the selection.
- clear() signals modelReset(), which is true, but inconvenient
when we do a bunch of changes afterwards. Block signals,
and rely on own signaling when all of the changes are done.
- Keep blocking signals while updating the model, since the row
appends otherwise trigger a change in the connected combo box.
- script was set up for KPMCore master (e.g. KDE neon), and
didn't support older KPMCore releases; now it doesn't fatal
error when the KPMCore plugins can't be found.
- when it finishes, tell the user where the artifacts are found.
SEE #1110
There isn't really anything to fix: partitions are aligned to 1MiB
boundaries now. Manjaro 18.0.3 is probably before the early-august
commit that added that.
While here, add some better partitioning-debugging and cleanups.
- For unsafe installations (compile-time option), make sure
things fail before partitions are actually written, unless
the other option is also turned off.
- This is a compile-time choice, and off by default. This may be useful
for developers that need to get through installation to a different
partition on their root drive.
- Add an option to avoid actually doing unsafe things. This is an extra
safeguard; you need to turn on one and turn off the other option to
really be unsafe.
- Remove the commented-out cruft and the whinging
- Fix use of COMPILE_DEFINITIONS with a list passed in
- Remove unused arguments (TYPE, TARGET)
- Document calamares_add_library
- Document how to use COMPILE_DEFINITIONS (in calamares_add_plugin)
FIXES#999 (In a way: that asked for Flatpak. People will sill need to
**build** Calamares themselves, but it could then be bunged a much
older system to install that one.)
SEE #1082 (Not really: that is about installing containerized
applications as if there is a package manager for them; AppImage is
developing a CLI tool to do fetch-and-store-in-the-right-place, so
that could be added to the packages module as well.)
- Prepare for using Conda for the Python environment in the
AppImage. This does not actually work, because the Python
support in Calamares doesn't find the alternative environment.
- Also log everything, rather than re-starting the log with
each build step.
- set PYTHONPATH inside the AppImage so libcalamares is found
- add Python module to the sample configuration
- relax password requirements (while we're at it)
- Add a script for building a Calamares AppImage file (this is
useful in *some* limited contexts, not a general way to distribute
Calamares since it's much more efficient to use installed libs).
- Add example config files for this AppImage build.
- Download the linuxdeploy tools if they are missing
- Document script flags some more
- Avoid crash due to invalid iterator, when modules
are removed due to missing requirements.
- Simplify code, factor out the determination of
which required modules are missing.
- Load instances list in a separate method
- Load sequence list in a separate method
- Don't rely on QASSERT, explicitly throw if something is missing.
- This was commented out to combat the crash in device->type()
- I believe the crash was caused by double-deletion, which was
fixed in 2092ec3c9a by not re-
parenting an immutable copy of something.
- Restore the button-fix, since we need that to keep the
*create* button in-sync with the selected partition.
FIXES#1097
As requested, this commit adds a new configuration option to the
partition.conf file, name `efiSystemPartitionSize`.
When this option is absent, the default size of 300MiB will be used.
Fixes#1090
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
In order to allow the use of these functions across the whole partition
module and keep all partition size-related functions in the same
namespace, this commit moves them to PartUtils.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
This commit creates a _KiB operator for future use by the partition
module.
It also fixes a typo in one instance of MiBtoBytes(), requiring a couple
extra fixes.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
In order to be able to parse partition size strings using the same
functions across the partition module, the parseSizeString() function is
exported to the PartUtils namespace.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
- Make some methods that are called mostly as slots, actual slots,
instead of going through extra lambdas.
- Use QOverload<>::of for disambiguation instead of homebrew casts.
- Provide a convenience method that names a Partition* with the
best human-readable name we can find (worst-case, spit out a
pointer representation which will at least help figure out
the identity of the Partition*).
- These methods are used for multi-page view-steps, which are rare.
For all the others, just drop the empty implementation and defer
to the base class.
- Next was enabled early; presumably to cover the case that no requirements
were checked and the requirements checker never emitted an update signal.
Drop that since the module manager is now responsible for doing that checking.
- Can't re-parent across threads easily
- If device is made by immutableDeviceCopy(), then it's still owned by the
PartitionCoreModule; giving it away to the widget is not a good idea.
- The NAM is being created from a method call on the GeneralRequirements
object in the requirements-checking thread, while the GR object itself
was created in a different thread. This cross-thread parenting
produces a warning, and we don't need the parent relationship here
anyway.
- If a distro provides an install-scenario that doesn't provide a DM,
(e.g. via netinstall) then that should be ok; if there **is** a DM
it should be configured.
FIXES: #1095
Due to changes to the FileSsytem::typeForName() function, more
processing is needed to deal with locales and different cases.
This is done by refactoring the findFS() function, initially located in
the PartitionViewStep class, and making it available to the whole module.
Additionnally, more checks have been implemented regarding the use of
global storage in the PartitionLayout class, and the filesystem types
now use the correct FileSystem::Type, as requested.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
- The default window title in the designer file wasn't a good string
to translate. Use one of the titles instanced from elsewhere.
- The window titles set in subclasses were not translatable.
FIXES#1092
When using the default partition layout (only a `/` partition), the
filesystem used was ext4, ignoring the `defaultFileSystemType`
configuration option.
This commit fixes this bug, so that any supported filesystem can now be
used for the default partitioning scheme.
Fixes#1093
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
- Move the actual checking into a separate object with some lifecycle-
management signals.
- Right now this is still single-threaded and blocking, so no net gain.
- Strings like "{} the {} with {}" are terrible for translators:
- no context
- no possibility to re-order grammatical units
- substituting in English parts-of-speech is going to make a mess
- Write the strings out with explicitly named substitutions,
no part-of-speech substitution, and better formatting.
- Add a (superfluous, since they don't have their own signals or slots)
Q_OBJECT macro to the VG jobs, to silence a Transifex warning (this
does make sure that the tool knows about the context for the translated
messages)
- The test wants to read settings.conf, but by default it's run
from way inside the build dir, where there is no such file.
Go looking for one (but not too far).
- Part of the tests checks that the example configuration
is not empty. So uncomment the example. (Distro's should
not be installing the example configs, and this one in
particular needs to be customized).
- Store changes to the selected swap-choice when the combobox changes
- Use that member instead of dereferencing the combobox
This avoids nullptr crashes when the combobox isn't even created
(e.g. when there is only one swap choice).
- it's enough to know which "band" a translation is in, no
need to keep them in translation-completeness order
- makes it easier to sort-and-spot what languages have moved
between bands
- suppress es_ES automatically.
- drop the localized comparisons; that's just confusing
- warn when no default FS is set (then use ext4)
- fix case-insensitive fallback; it used fsType, which was
set to Unknown in the for loop.
- Make the explanations about 3 times as wide as the text-boxes
that they are explaining. This is partly moot because the
text-boxes have fixed pixel sizes in the designer file, but keep
it flexible for now.
- Using the assignment-operator just generates blank lines.
- Using QLog with a log-level avoids the cDebug()-style special
handling of warnings and errors (useless here, but may as well
fix code style).
When using the `rawfs` module for copying data, it may be useful to
save the source device used for later checks or actions. This commit
therefore adds a `source` field to each corresponding partition entry in
global storage, so that this information can be retrieved later during
the installation process.
Another small improvement is that global storage is now modified only
once (it was previously modified as many times as there were entries
processed by the `rawfs` module).
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
When choosing `systemd-boot` as the bootloader, numerous problems
occurred:
- the kernel and initrd were not copied to the EFI System Partition,
and therefore could not be reached by the bootloader
- the fallback entry used the default initramfs image instead of the
fallback image
`systemd-boot` provides the `kernel-install` utility, which
automatically copies the kernel + initramfs to the EFI partition, and
creates the corresponding bootloader entry.
Unfortunately, `kernel-install` cannot be used here as the module is not
executed in a chroot. As setting up one only for running a single
command would be overkill, this patch re-creates what `kernel-install`
usually does:
- copy the kernel and initramfs to their own subdirectory at the root of
the EFI partition
- create the corresponding entry configuration file
To this end, the `systemd-boot` installation code in the `bootloader`
module has been largely refactored, including removing a few duplicate
LOCs.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
In its current state, the 'rawfs' module requires the source partition
to be identified either by its mount point or device name, but using a
symlink to either one (e.g '/dev/disk/by-uuid/...') would fail.
This patch fetches the real path of source partition, allowing the use
of symlinks.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
When setting the size of a partition without indicating the unit, two
problems occur:
- the size is parsed as an integer, not as a string, hence the
configuration parsing fails
- the size parser doesn't recognize the fact that the size has no units
and defaults to 100%
This patch fixes the configuration parsing as well as the size string
parsing.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
When a partition doesn't have a minimum size in the partition layout
configuration, it defaults to using 100% of the available space.
This patch fixes this error by setting the minimum partition size to 0
when the attribute has been omitted.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
- Write out Int, Double
- Special-case empty lists
- Do objects (not lists of objects) correctly
Now passes the tests for all the example config files.
- The code in loadYaml was refactored out of the module-descriptor
loading code, but the variable names in the implementation were
not changed and still strangely specific to the prior task.
- Add global- and job-configurations for test runs.
- Add a driver script that sets up some assumptions on the host
system so that the tests can complete.
- The idea is that these tests together get a decent code-coverage
for the module.
- This is a driver script for running testmodule.py multiple times
with different global- and job-configurations.
- Usage: testpythonrun.sh <modulename>
- Run the script from the build-directory. It uses files from the
tests/ (source) subdirectory to drive the test runs.
- Only need to get the list of supported filesystems *once*,
not for each and every filesystem that is going to be unpacked.
- Be more Python-idiomatic.
- Experiments show that the partitionmanager crashes are not new
or specific to the swap-UI. So reduce the number of open branches
by merging everything back to master, for a 3.2.4 release once
the crashes are disabled (and the UI is up-to-snuff).
- Pull in and document new code from Collabora.
In some cases, we might want to copy a filesystem as if we were using a
simple 'dd' command, in order to create an exact copy, down to the block
level.
This can be useful in particular when working with dm-verity for
checking the rootfs integrity: that way, we can make a direct copy of
the rootfs and its verity partition and keep the system usable.
This patch adds a new 'rawfs' module to calamares, making possible to
block-copy a filesystem to a block device.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
In some cases, e.g. when calamares is used as an "initial setup" tool,
we may want to user to go through all the configuration steps in order
to end up with a usable system.
Therefore, disabling the "Cancel" button can be useful in this case.
This commit adds an option to settings.conf which disables this button
when set to "true". If the option is not present in the settings file,
the default behavior ("Cancel" button enabled & visible) is enforced.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
- A size of 64em has a value less than 1024, which is the minimum
size **in pixels**. The check doesn't make sense as-is and would
have to take the unit into account. Leave that to clients of
branding (e.g. CalamaresWindow, which already does this).
Keeping std::initializer_list around is fraught. Causes segfaults
because I'm not keeping the underlying temporary array around
properly. Switch to vectors because those initialize from the
underlying array.
TODO: look into making this sufficiently constexpr -- perhaps
just use std::array and make find() work on that.
For (all?) those cases where we have configuration with
a value followed by a unit, introduce a class that
uses the NamedEnum properties to make parsing and split-up easier.
- Use locale "C" for checking filesystem names
- Also check other possibilities and case-insensitive, to
be more forgiving of weird configurations (and localizations)
- The language and BCP need to be in-sync
- Existing code was inconsistent in setting things, which is why
you could get through the locale page without setting a locale
(at all) or it would keep English in spite of picking Germand on
the welcome page.
- Patch tests to use that API.
Due to a computation error when calculating the total drive space and
each partition's last sector, the last partition's last sector was out
of boundaries, leading to an error creating this partition.
This patch fixes the computation algorithm to get rid of this error.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
- Allow split-setting of the language and formats
- Test new constructors
- Since fromLanguageAndLocation can handle empty localeGen
lists just fine, skip all the weird checks that return
invalid guessed locale configurations.
- Replace createDefault() with a constructor that takes a
locale name; use it with en_US.UTF-8 in those places where
createDefault was previously used.
Some code was copied and adapted from PartitionActions.cpp. For full
compliance, it is best to copy the copyright holders list from this file
to PartitionLayout.cpp.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
When chosing the "Replace partition" option, free space is not handled
like any partition. In order to apply the custom partition layout in
that case too, we have to modify the code where "replace free space" is
handled.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
In some cases where a custom partition layout is used, use of this
layout is mandatory (this can be the case when using a read-only rootfs
which is updated by block-cpying an image file to it).
For these cases, the user must not be able to change the partition
layout, therefore we have to disable manual partitioning.
In order to stay consistent with current behaviour, manual partitioning
is still enabled by default. It will only be disabled if the partition
module's config file contains the corresponding option set to "false".
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
When choosing "Install alongside another system", the custom partition
layout is applied to the space freed by resizing the selected partition.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
This patches add new methods to both PartitionLayout and
PartitionCoreModule classes which apply the partition layout to the
available drive space.
In addition, the partition creation code from PartitioinActions is
removed to call the newly created methods instead, thus applying the
custom partition layout when the "Erase whole disk" and "Replace
partition" choices are selected.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
As we move some of the partition creation code away from
PartitionActions, we will need the bytesToSectors function. Rather than
copying it, we export it in the PartitionActions namespace, so that
other classes can use it.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
In order to keep the partition layout during calamares' execution, we
add a PartitionLayout object instance to PartitionCoreModule. This class
will therefore be used to initialize the PartitionLayout object and
interact with it thoughout the program's execution.
When no partition layout is present in the config file, we initialize
the layout with a single ext4 partition mounted on '/', as it was
previously done.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
In order to use a custom partition layout in the partition module, we
need to write this layout in the module's config file, and store it into
a dedicated object.
As it doesn't look appropriate to extend an existing class with layout
information, we create a new PartitionLayout class, which will be used
to parse the layout from the config file and keep it in memory.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
This basically means we talk about localization in the respective
localized variant. e.g. "German (Germany)" ➡ "Deutsch (Deutschland)".
If geoip lookup failed or isn't configured for whatever reason it's a
stretch to expect the user to know english enough to find their own
language. Preferring the localized strings resolves this issue.
Additionally this happens to bypass #712 respectively
https://bugreports.qt.io/browse/QTBUG-34287
as the native names are properly spelled. So, as long as Qt has localized
names the names will also be properly spelled.
- Add automatic tooling to retrieve translation stats and
output new CMake variable settings.
- If there are i18n language selection warnings, stop CMake.
- If a key is missing from mount.conf, don't raise KeyError
- If both keys are missing, suggest that mount.conf might
be missing instead (a consequence of INSTALL_CONFIG=OFF, for
instance).
- Simplify code a bit.
- Don't bother returning None explicitly.
- for remove and localInstall, add support for pre- and post-
scripts like there already was for install.
This feels like there's code duplication going on, but I haven't
thought of an elegant way to distinguish the available operations
so that I can pass around functions instead.
- The noload option prevents journal re-play (so it's an extra-
strong read-only) but is only applicable to ext3 and ext4.
Check the FS type before mounting; other FS types don't
accept -o noload and will fail to mount.
- This only applies to legacy (non-EFI) BIOS systems, and
adds the FlagBoot to whatever is already set for the root
filesystem, and only when autopartitioning the device.
Submitted by aliveafter1000.
FIXES: #1046CLOSES: #1049
Suggested by aliveafter1000: having a default value, and then
filling in the default in one place it is used and not others,
is weird. Instead of dropping the one use, remove the default
value: partition flags are important enough to be explicit.
Several PRs from aliveafter1000 (no real name known) were
discussed and this branch contains re-formatted and slimmed-
down changes that implement those PRs.
- Handle legacy and modern config, mixed-configs,
- Translate strings to enum values,
- Default and warn as appropriate.
- Doesn't **do** anything with the config, though.
- Use DATA for the qml and branding directories (looks for qml/
and branding/<name>/ in those directories).
- Use CONFIG for the global settings and module settings (looks
for settings.conf and module/<name>/ in those directories).
FIXES#941
- Running lsblk and mount for debugging purposes can be
skipped when the debugging is going to be suppressed anyway.
This will speed things up just a little for regular users.
- While winnowing devices, the zram and nullptr cases
were mixed together; split them, for the sake of
logging more accurately.
- While here, fix up some coding-style issues.
- Distinguish size and atleast; in percentages they mean different
things (atleast is a bit weird as a percentage, but hey).
- Fix bug in percentage calculation.
- Avoid percentage above 100.
- Add documentation in config-file.
- Q_ASSERT doesn't work in constexpr functions because it's not
- May as well calculate bytes at compile-time, no need to give
the runaround via number-of-MiB
- Be more verbose when things go wrong while loading module-
configuration files.
- Allow more forms of paths to be specified. In debug mode, this
is mostyle helpful for the module test-loader.
- Test the parsing of configuration values, that it gets the right
values when given correct(-ish) configurations. Doesn't test
any situations with bad config.
- Make RelativeSize public so we can use it in non-member functions
- Make a template out of matching the string suffixes; this is
safer because the length of the suffix can be computed at compile-time
(+1 for the trailing NUL) rather than writing it out in boilerplate.
- Non-functional as yet, WIP
- Intended for use on SBC images and similar, which need to resize
the root partition to the size of the SD card they're on.
FIXES#921
- The choice of swap needs to be handled in more places,
so make the enum available in the partition module core instead
of just inside the choice page.
- Q_ASSERT doesn't work in constexpr functions because it's not
- May as well calculate bytes at compile-time, no need to give
the runaround via number-of-MiB
- Fix typo in the build-debugging bits
- Increase tmpfs size of /build because it looks like "make install"
ends up filling the disk, and then it fails.
- The calculations for swap-space are a little wiggy, with
space used rising to 8GiB or more, and then dropping
down to 4GiB, and rather inconsistent for the case
ensure-hibernate and not-ensure-hibernate. This branch
will harmonize the calculations.
- Allow a UI to select swap usage (e.g. a drop-down with
choices for the user, which may be enabled by the distro).
FIXES#848FIXES#1006
This fixes the crash by calling the model-reset first, then
refreshing. Previously, the destructors that do the work
were still being called in the wrong order.
FIXES#1019
- The ResetHelper only finalized changes to the module on
destruction, but calls to refresh() assumed it was already
done. This leads to crashes when refresh() uses an intermediate
state of the model.
Introduce extra helpers, and rename refresh() to avoid calling the
old implementation from any code. The new helper just creates and
destroys a ResetHelper, before creating and destroying an object
that calls the new refreshAfterModelChange().
FIXES#1019
- document new variable from the CMake module
- use it in libcalamaresui to simplify #include'ing the
header for the "all" extension.
Suggested by Denis Proskurin.
ESP == boot. at best this is duplicated information, at worst kpmcore may
implode if you try to set a boot flag since that is technically an MBR
type flag and means nothing within the context of GPT where ESP is the flag
to set.
having ESP as active flag AND then trying to set ESP means nothing is
set since kpmcore will think ESP is already set (it is listed as active
after all). this ultimately meant that nothing was set since there was
no delta between the requested flags and the already active flags.
- The parameter list was wrong, and could never have worked
(apparently noone mixes LightDM with basic setup, even though
it's one of the few with basic_setup()).
- Shorten some lines.
- Make the Travis scripts a bit more verbose on failure
- Fix wrong filename tested for picking up the configuration
(this is why the builds were failing: missing the force-webkit
flag, while webengine isn't in the dockerfile for Travis)
FIXES#1018
- Move variable initializations closer to where they are first used
- Also warn if no implementations are available
- Handle sysconfig as any other DM; there's no real reason
to treat it specially.
- Add (empty) implementations of all the abstract methods that
are not needed (or supported) by various DMs.
- Order the abstract methods by calling order
- Fix up have_dm
- Make root_mount_point a parameter of the DM classes
- Create instances as needed, then check if they're available
- Keep instances that actually need to be configured
- Clean up remaining cruft from removing old setup_autologin()
with all the string-comparison magic.
- Some DMs allow setting up the default DE. Factor that
out into a method like basic_setup() and setup_autologin()
and add it to the configuration chain.
- For all the DMs that have some kind of basic setup,
introduce a method in the DM class for doing just that.
- The Python code now doesn't call basic setup anywhere,
so this specific revision isn't going to work properly.
- Split the entire body of setup_autologin() to a method
per implementation class.
- Make the check for presence of a DM a class-method,
since if it fails, instantiation is going to be useless.
If displaymanagers is not set in the job config or globally,
it wasn't set at all, leading to a runtime error. Set to
None, so that the regular error message will be triggered.
FIXES#1002
- Reported by Bill Auger (I think), a 15GiB disk wouldn't hold
a 8.9GiB root plus 4GiB swap -- due to 10% overprovisioning
of swap, plus the 2.1GiB fudge factor.
- Calculating first free sector had an off-by-one so that
partitioning would start at 2049.
- EFI boot partition grew 1 sector larger than desired.
- While here, align everything to 1MiB boundaries as well.
FIXES#1008
- Similar to the refactorings in Calamares proper, just split out
collecting the search paths into a static function. This makes
it a little easier to find places that will need expansion for
more-than-one-config-directory.
Switching to INSTALL_CONFIG=OFF breaks tests by not having them
in the build directory. Some logic was coupling not-installing
to not-using-in-build-dir too closely.
This is the start of a release script. The idea is to automate
a whole bunch of the steps documented in ci/RELEASE.md, so that
a release becomes more straightforward. Assumptions abound:
basically this is going to work on my workstation, and not
on any other.
- Make *mandatory* optional (and default to false); this
allows shorter lists of entries
- Allow degenerate entries which are just a name
(which have *mandatory* set to false as well).
SEE #992
- Allow just a name entry, instead of requiring an object
entry; this makes "foo" equal to { name: "foo", runlevel: "default" }
and simplifies more for the straightfoward case of #974.
- Based on comments from #974, follow the configuration
scheme from services-systemd, so with separate lists
"services" and "disable". This ties it **slightly**
less closely to the commands passed to rc-config.
- If runlevel isn't set (at all) then use "default". For
most systems that do not use multiple runlevels, this
simplifies the configuration to just a list of service names
to add or delete.
- Document the functions some more
- Only "state" (i.e. action) "add" and "del" make sense,
avoid calling rc-update for other keys (e.g. typo's).
This matches the documentation, although there might be
other actions that make sense (see also services-systemd,
with its enable, disable and mask actions).
- With refactored code, introducing new kinds of actions
is very few lines of code. Allow disabling targets
(services was already possible). Allow masking units,
but as a special case require the complete name.
FIXES#975
- The three steps of modifying services in the target
system do basically the same thing, so factor out
the loops and logging into a systemctl() function.
- Log to warning() instead of just debugging, on failure.
- There is more to failing out of loadModules() than just
emitting modulesFailed, so instead share the failure
code with the code after loading modules -- but don't load any.
- Module dependency-checking is done in two phases:
first, catch any unknown modules that are listed
in *requiredModules* and bail out before loading
anything. Second, check that the modules required
by X occur before X in the sequence.
- The value set in module.desc was never stored for use,
but isn't an attribute of the instance, either. It belongs
with the descriptor, in ModuleManager.
If USE_<foo> is given a value that doesn't match **anything**,
then bail out. Since USE_* is an explicit distro choice for a
specific implementation, it's an error if that implementation
is not there.
When there are multiple modules doing a thing and it really only
makes sense to have one of them in a given Calamares compilation,
the USE_<foo> variables allow you to select one, while ignoring
all the other implementations. If USE_<foo> is not set, all
implementations are included (as usual).
- The examples files are not harmless, so distro's should take a
explicit decision to install the config examples (instead of
putting files in /etc/calamares).
- Switch INSTALL_CONFIG to OFF by default **or**
- Make all the example configurations "harmless" or trigger
specific failure modes in the modules.
- Document that distro's should be creating their own set
of config and settings files and using those, rather than
relying on upstream example configs.
- Implement the required: module description field. This
would have prevented the plymouthcfg / grub failure fixed
in 3.2.1.
- Think about improving the available OPTIONs at a CMake level
to auto-fill SKIP_MODULES (e.g. it only makes sense to pick
**one** services module).
- Rename services to services-systemd
- Improve the example file in services-systemd
- Document it
- Make the sample harmless
- (Rougly) merge #972#975
- Merge OpenRC module
- Only with documentation
- Use the generalized module from #966
- Use YAML-CPP API for finding out if a node has a value at all.
- Asking for Type() of an undefined or NULL node throws an
exception, so the existing code didn't **actually** catch
cases where a required setting wasn't set at all.
- A valid line (as explained in the comments at the top of
the locale.gen file) is <locale> <encoding> (two fields),
so lines with more than two fields can't be valid locale-
listing lines. For them, pretend they name locale "",
which won't be matched.
- Improved debug-logging
- Fix the actual problem of listing locales more than once,
by listing them all, uniqified, at the end, with an explanitory
comment in the generated file.
- Be more accepting of what constitutes a locale-line; this allows
spaces before and after the `#` comment sign, but because we're
uniquifying, this doesn't cause duplicates.
- Because we write the enabled locales at the end, the full file
comment-header is retained un-mangled (instead of accidentally
enabling a locale mentioned as an example there).
Testing for existence of a file in the live system, and then
copying it in the target system, is not a recipe for success.
- Fix the restore-from-backup part.
- Document that your live and target system must both have
/etc/locale.gen if you want this to work at all.
just lines which might be comments, might be human-readable-text, or
might be example locales. Instead of modifying any comment-lines,
write enabled locales at the bottom of the file, while matching
very loosely with the comment lines from the file.
FIXES#940 (insofar as that is fixable)
Also make install for yum and dnf follow the documented syntax: options
(-y) before the command (install), even though yum and dnf also accept
the other order. This also makes it consistent with remove.
Untangle the shortcuts; Create and Cancel had an overlap.
Skip 'r' (Revert all changes) and 'e' (Edit) and settle on
'a' (which might also mean "Add").
FIXES#977
Introduce the notion of emergency modules and emergency jobs.
Initial use will probably center around the preservefiles module,
and possibly umount.
FIXES#928
- After a failure, skip non-emergency jobs.
- After running all emergency jobs, then emit failure message.
- In log, distinguish emergency and non-emergency jobs.
Any job can be an emergency job; emergency modules spawn
emergency jobs (but conversely, a non-emergency module
can spawn an emergency job explicitly).
A potentially emergency module is one that has EMERGENCY
(in CMake) or emergency: true (in module.desc) set.
Any such module must also set emergency: true in the
configuration of the module. This is to allow for
instances of a module that **don't** run as emergency
modules, alongside actual emergency ones.
Although the NO_INSTALL keyword could be specified for
Calamares plugins, it didn't actually do anything. Now
it does. A NO_INSTALL module does not install configs
or libraries.
- In many cases, using QLatin1String is a de-optimization, when
applied to a C string literal. Kevin Kofler pointed out that
those should basically all be QStringLiteral, instead. (Compile
tests with -O3 show that in the optimized object file, the
code size difference is negligible).
- Drop the explicit constructor entirely in cases where we're calling
QProcess::execute(), for consistency.
- Do a little less messing around in the mapping of keyboard locales
to keyboard map names.
As Kevin pointed out, there's an extra conversion involved here --
although with -O3 the difference boils away leaving only a call
to a from-ASCII helper or a from-Latin1 helper.
While here, coding-style.
The plymouthcfg Calamares module is optional. Distributions which
write filesystems with a full plymouth configuration won't even
want to use it (see plymouthcfg docs).
However, now grubcfg depends on plymouthcfg to run because
the globalstorage value to trigger setting 'splash' in grub,
is set in the plymouthcfg module.
Just check for plymouth existence separately in the grub module.
Fixes ea1c8a0e5d
- The new format was introduced in Qt 5.7, and Qt 5.9 introduced
the --format-version flag to rcc to switch back to the reproducible
format 1. For distro's with Qt 5.7, don't use the new flag.
- Reported from Neptune Linux, #979
Since this is a new language, it is currently 0% translated.
That is why it goes into _tx_bad. It will move to one of the
other categories once some translation has happened. Add the
(still empty) Transifex files already.
- Add a TODO for allowing modules to come from somewhere other
than the module loader (this would allow "internal" modules
that are always present)
- Warnings are warnings
- Add -v (verbose) and -b (load via bytearray)
- Verbose prints the keys read from the file,
- Bytes reads via an indirection through QByteArray, like Settings does
- Collect the failed modules, instead of bailing out on the first one
(this also prevents crashes caused by quit() called from a timer).
- Introduce a slot to report on failed module loading (no UI yet).
- This is only found in order to know where polkit files should
be installed. In distro's that don't use polkit, may as well
make it entirely optional.
- Follow previous move of user-adaptable settings and regularly-updated
variables to the top of CMakeLists.txt with a move of the list of
translated languages.
- Put all the options near the top, easy to spot when reading the file
- Put the settings that need regular updates, like version, near the top
- Add some "section headers"
The validation of the configuration files (modules' .conf files,
as well as settings.conf overall) spits out warnings, but does
not do all the validation it can:
- should print locations more clearly (e.g. if there's a tab
in welcome.conf)
- should also print some part of the bad text, if possible
- if a module cannot be created, that should be treated as
a fatal error (now the module is silently ignored). This
is different from a module that can't be found, which
immediately triggers a fatal failure.
Test plan:
- introduce a tab into welcome.conf
- introduce a bad conversion into settings.conf
With just the bad welcome.conf, it should complain clearly, and
refuse to start. With a bad conversion, it seems that there is
a problem but execution can continue, so it should be made clearer
what the problem is. If welcome.conf is buggy, and welcome is
listed to show, this should be a fatal error.
Deal with some errors in placement of markers (both North and South,
the map is stretched a bit), fix timezone pixel maps to fix wrong
zone display.
This was triggered by Reykjavik being moved around, but expanded
when Johannesburg was also somewhere it isnt.
FIXES#967
- Fudge the numbers in the North, to improve location
of the pins and lines of latitude.
- Inuvik, Yellowknife, Cambridge Bay, Resolute look ok
- Thule, Scoresbysund look ok; Danmarkshavn a pixel or so too far North
- Reykjavik is a bit too far North
- Longyearbyen is a bit too far North
Since these places are off by one or two pixels, this becomes
invisible when a large pin + text label is placed on it.
The scaling on the map was a little off; the degrees of latitude
are a little wider there than around the equator and Europe.
- Johannesburg is in the right spot
- Hobart is no longer a suburb of Melbourne
- Punta Arenas is in Chile
Replace pin and text label with just a dot (to pinpoint where
locations are) and draw latitude lines on the globe when
DEbUG_TIMEZONE is set at compile time. Since there's probably
still timezone-related bugs (in particular in the images that
map points on the globe to timezones), leave this in the codebase.
This is orthogonal to the SKIP_* mechanism already documented
for avoiding modules. If the module is enabled, but its dependencies
are not present, don't bother building the module. This follows
e.g. plasmalnf as an "avoidably heavy dependency".
Related to a misplaced comment in ISSUE #956
This is code that was written as part of the fix-pythonqt branch,
but which isn't really PythonQt-related at all. That branch will
be abandoned soon, since it wasn't sufficiently well-thought-out
enough at the beginning.
This test-application should load a single module and execute it --
that can be used to quickly test configurations, loading, etc. This
is preparation for loading all sorts of Python modules by PythonQt.
The loader does some internals initialization and gets the module,
but doesn't actually run it yet.
This introduces configuration to allow switching between the
behavior noted in #964, and the desired behavior from PR #955.
For the Manjaro Openbox edition, this means they should add:
```
userShell:
```
To users.conf, while others will see the return of the previous
behavior of passing -s /bin/bash.
FIXES#964
- Add a *userShell* key, which can be left out (default, backwards-
compatible) to retain the old /bin/bash behavior, or explicitly
set to empty to defer to useradd-configuration, or explicitly
set to something non-empty to use that shell.
- This is prep-work for #964, which was caused by #955
- Original assumption was that distro's would have a working
useradd configuration; @abucodonosor already pointed out that
this was probably not the case, but I ignored that.
- document accessors
- put all path and directory accessors together
- make simple accessors inline
- rename "pathprefix" to "directory" to be consistent with others
- more flexible way to keep (all kinds of) files from the host
system, into the target system.
- WIP: substitutions like in shellprocess (@@ROOT@@, @@HOME@@ probably)
- WIP: creating a JSON file from global settings
Extensive go-over on the partitioning code. #622 is maybe "possibly fixed",
but there's no real indication of what constitutes an invalid combination
of flags.
FIXES#884FIXES#951FIXES#953FIXES#622
The substitution of @@ROOT@@ should happen when running in the
host, not in the target, system. Also only complain about it
if @@ROOT@@ is actually used in the commands.
FIXES#954
- If there is a partition already (newly) created, then pass that
to the dialog so that it can use the setings previously applied
(e.g. mount point and flags).
- This avoids the case where you create or format a partition,
then click on it again to edit it and the previous settings are lost.
- Setup the lsit of flags consistently, by providing the available
and to-be-checked flags.
- In CreatePartitionDialog, assume that ~0 is all the flags.
This file is full of helper functions for the partition-editing
dialogs. At first it was just mount-point helper functions,
but there is other functionality that can be refactored.
- If we're changing the flags to enable EFI boot, then that's
enough to satisfy the (future) EFI bootability check.
This is for issue #622 as well. Fixes#884.
- Use the desired (future) flags, if set, to initialize the
flags checkboxes. If there are no future flags set, this
returns active flags as before.
- This fixes the situation where editing a partition, changing
flags, then editing it *again* re-starts with the original
flags instead of the modified flags.
- PartitionInfo maintains information on "what is desired" for
a given Partition. Now we can set desired flags, alongside
the flags already supported by Partition (where activeFlags()
gives you the flags currently set on that partition).
- Avoids case where you edit a partition with a mountpoint
set; previously, calling setText() would update the text
but leave the selected index unchanged (usually 0), so that
later calling selectedMountPoint() would return empty.
- Move to one place which handles the standard mount points
- While here, introduce explicit "(no mount point)" string
into the combo box. This is prep-work for issue #951.
I consider this a Qt bug: there is an enum value for the language,
the language is fully (?) detailed in the ICU tables, and yet
it gets mapped hard to C locale.
- Some locales have no nativeLanguageName(), so instead display
the locale id (e.g. "eo") and the resulting language in English
(which, if it is really unsupported, will be "C").
- suppress languages we've decided not to have anymore
- prevent txpull from losing .desktop keys it doesn't understand,
by splitting off a desktop.in file with only the (source) fields.
- Include all headers for types that need to be fully-defined
(e.g. return types). This guards against uses in contexts where
those headers have not been implicitly or previously included.
FIXES#948
Users will never want to install the distribution installer from a
software center like KDE Discover or GNOME Software, so exclude it from
the AppStream metadata collection.
QLocale::name() doesn't include script information, and if it did
it would probably use sr_RS@Latin; when searching for translation
files it won't consider dropping just the country.
- The QLocale constructor which takes a string (locale name) doesn't
understand sr@latin, and returns the Cyrillic locale. Fix that
by creating locales ourselves for @latin locales.
- sr and sr@latin now display correctly in the right script in the
native language dropdown.
- The (RTL) text "Arabiy (Misr)" should be entirely RTL, so
make the parenthetical insert -- which would otherwise be LTR
and so mess up the placing of those parenthesis around the country --
explicitly RTL.
- Since there are no RTL languages in Calamares right now with
country-local translations, this isn't visible.
- A locale suggests it is country-specific by having the form <lang>_<country>
- This mostly fixes locale "ar" being presented as "Arabiy (Misr)" when
there is no need to (and the RTL is messed up then, too).
- Introduce intermediate data class for building up the list
of languages to present.
- Sort on the English names, with en_US at the top (ugh).
- Show the native names.
- Much like std::find_if, but slightly muddled because there's
no iterator that we can sensibly use.
- Scan the ComboBox for a locale that matches a predicate.
- Log more as the search for a good locale progresses.
- Don't mix matching the locale with filling the ComboBox
(even though that's slightly more efficient).
- Since these tests use network resources, they are not enabled by default.
Set the environment variable TEST_HTTP_GET to actually do them.
- Do one request for each provider and check that they are all consistent.
(This works for me, yielding Europe/Amsterdam for all).
- Some providers don't provide a single flat JSON object
(e.g. "{time_zone: foo}") but a nested structure
(e.g. "{location: {time_zone: foo}}"), so allow dots
in the selector to do multi-level selection.
- Some providers return weirdly escaped data; strip out useless
escaping before splitting (there are no characters in correct
time zone names that need escaping)
- Add some tests for TZ splitting
- In GeoIP handler constructors that take a string (to configure the
selector to use), interpret the empty string (which generally isn't
a meaningful selector) as meaning "use the default".
- Drop the no-argument constructors in favor of a default-argument
which is empty.
- GeoIP gets a string selector; the interpretation is up to derived classes.
- GeoIPXML and GeoIPJSON use the selector to select an element by tag
or an attribute, respectively.
- The handler for JSON data should be called that, not named
specially after the original provider it was implemented for.
- Make filename and classname consistent, GeoIPJSON.
- The screenshot stays one size, but different ThemeWidgets may overlap
partially when you shrink the screen or have more than three / four
themes listed.
- Probably needs work in the surrounding container and overall better
page-scrollbar support.
- Unchanged config files will continue to use the weird addition
of /json, and interpret JSON data.
- Allow to specify full URL with data format through one of
geoipStyle: json
geoipStyle: xml
- XML support is optional
- Don't insert a space before the output of a process
- To do this, suppress space and quoting on the output, and to do
that move the labeling-output for warnings and errors into
the constructor (so that an idiomatic .nospace() does the right thing).
- Settings is just a settings class, no UI involved, so
move to libcalamares where it can be used also from
system helpers.
- YAML utilities are useful at a lower level of the stack, too.
- Put the (constant) 'Calamares will now quit' on its own debug line.
- Tell the user what the search paths are if a module is not found
(prompted by a mis-configuration in a Neon live image).
- Make the BCP47 value explicitly lower-case.
- Add some constness and encapsulation.
- Fix up documentation in the packages module explaining the
format of the ${LOCALE} replacement (now forced to lower-case,
but it is also only the language part, not e.g. en-UK).
FIXES#922
- Count only the packages that will be changed, given the current
locale settings.
- Preserve global storage unchanged (don't remove any locale-packages).
- Use DebugRow for one-row-at-a-time output with continuations.
- Use DebugList for one-item-per-line with continuations.
- Use DebugMap for one-row-at-a-time output of a QVariantMap.
- This enables working in three modes:
- No themes listed; all are shown without screenshots,
- Themes listed, showAll false; only those are shown,
- Themes listed, showAll true; the installed-but-not-listed
themes are shown after the listed ones, and have limited info.
- Although it's not necessarily accurate for an extensively-modified
Plasma configuration, we can read the Look-and-Feel from the
configuration files. Allows auto-detection.
- For OEM modes where there is already a theme, add a preselect:
key to pick a specific theme and have that one come up as already-
selected in the list.
- Don't re-run the lnftool if an already-selected theme is clicked
again. Use toggled() instead of clicked().
- Don't bother with the address of the main thread
- Do put a marker on restart into the log file
- Do put the Calamares version into the log file (previously, the version
was printed through cDebug() before the log file was opened, so it was
lost to the on-disk log).
The RCC output files in version 2 contain a timestamp of the
source file, which changes per build. Drop down to version 1,
which just removes the timestamp.
See reproducible builds note 'timestamps in source generated by rcc'.
FIXES#917
Documentation lives both in Calamares and in the calamares-branding
repo. Whether a slideshow has navigation arrows or not is up to the
slideshow / branding component author, but Calamares now ships some
support QML to make that easy.
FIXES#841FIXES#904
It is the distro's responsibility to produce screenshots that look
good; previously I chose to preserve the aspect ratio on the grounds
that this would keep the look of the screenshot even if the distro
had done one in a weird size. This makes the screenshot part
of the LNF selection look weird, though, since then you get
blank parts.
Switch to ignoring the aspect ration; distro's should produce
screenshots in a 12x8 (i.e. 3:2) aspect ratio, preferrably at
least 120x80 pixels -- but keep in mind hiDPI and the default
font sizes of the distro, which may make other sizes look better.
(this follows discussion with BlueStar Linux)
Since we install the CMake files now, also put license headers in them.
These files are intended to help plugin and branding component authors
write them in a simple Calamares-idiomatic way.
The convenience include file CalamaresUse should DTRT and set up
all the bits needed to write Calamares branding components and
modules. So add the bits for i18n.
- Fix broken subdirectory call
- Automatically process lang/ if there isn't a CMakeLists.txt,
this was a bogus restriction
- Add support macros for installing branding and translations
- Auto-advance the default presentation
- Add more example slides to the fancy presentation
- Expand README.md explaining what the default classes can do
Removed these features that make sense in a presentation slideshow
(e.g. during a talk) but that are potentially confusing during
a passive slideshow like Calamares has:
- Using 'c' blanks the slideshow.
- Entering a slide number + enter changes slides.
- Add a NavButton, which shows a directional arrow, and fades in on hover.
It can be used left- or right- by setting an image source
and click handler.
- Specialize NavButton to Forward and BackButton.
- Add a SlideCounter navigation aid.
the original code does not distinguish the document comments inside the locale.gen file from the real locale list. The language was then enabled from the header comments of the file instead of the correct value in the list.
The new code verify tha the complete locale string is just after the first character of the string, enablig only the correct value of the locale list.
An example:
# en_US.UTF-8 UTF-8 --> document header, should not be enabled
#en_US.UTF-8 UTF-8 --> correct section to enable
Related to this request:
https://code.chakralinux.org/tools/calamares-chakra/issues/2
The install-bits branch commit 83639b182b
dropped .so-versioning for libcalamares and the creation of the Python-
support symlink. This broke KDE Neon dev-unstable because the embedded
Python can no longer find libcalamares.
Installing unversioned .so's straight to LIBDIR is also not a good thing
(according to Debian), so revert to the original scheme with versioned
.so and a Python-support symlink.
Medium-term fix is to install unversioned straight into LIBDIR/calamares
and fix up the RPATH for the executable.
- Applies to libcalamares and libcalamaresui.so, install with no
version, just the bare .so. Since Calamares doesn't do versioning
anyway, and its plugins should be re-compiled for any change,
putting them in lib as unversioned .so's should make Calamares
happy and silence lintian.
- The Python testmodule script can end up calling in to System
methods (via System::instance()). This is unusual, and the
System instance has not been created at that point.
Now, create an instance and warn about it.
- ValueCheck shouldn't own the pointer, since it's just a QPair
and there are temporary copies made (e.g. in
ContextualProcessBinding::append() ) and we get double-deletes.
- Do deletion by hand; going full unique_ptr would be a bit overkill.
- Re-build the structures for doing value-checks, is now more tree-like.
- Document pointer ownership.
- Introduce wildcard matches ("*")
- Don't drop empty command-lists, since they can be used to avoid
wildcard matches. (E.g. "in this case, do nothing, but don't
fall through to wildcard").
- Since the image size isn't known a priori (due to sizing based on fonts),
load the image and then resize in all code paths.
- Use the right resizing flags.
- .. and actually use the resulting scaled pixmap.
Thanks to Jeff Hodd.
- The CMake modules for Calamares expect to find CMakeColors
- Also the translation support macro
- Restore CalamaresUse.cmake
- File was removed after 3.1 in db105079, but it is actually useful
for out-of-tree modules. Restore it and massage into better shape.
- Simplify by adding path to the search path (otherwise the individual
macro files would also have to switch to including with a full path).
- If the next step will be an install-step (e.g. hit the optional
confirmation step) then change the text on the 'next' button to
'install'.
- Do a little refactoring to make that more pleasant.
FIXES#905
- Move logging-levels to an enum
- (re-)Order logging-levels so that the normal debug statement is
not the most-important (lowest level).
- Drop using namespace std;
These additional pointers were introduced for translations,
and needed their own tricks to get lupdate to recognize the
strings. Using QCoreApplication::translate() removes the
need to a QObject to provide context. Drop the now-unneeded
parameters.
Instead of using tr and some macro hacks to get lupdate to
recognize the translation, instead use QCoreApplication::translate()
which takes its own context for translation.
- For both shellprocess and contextualprocess, add a top-level key
"timeout" that defaults to 10 seconds (which it already did).
- Allows setting "global" timeout for command-lists, while still
allowing individual timeouts per-command.
- Setting timeout per global variable in contextualprocess is not
supported; that would restrict the possible space of comparisions,
while not supporting a global setting timeout seems reasonable enough.
Use instances if you need wildly variable timeouts and don't want to
set them individually.
- Replace plain StringList with a list of <String, timeout> pairs,
and run that instead. All code paths still use the default 10sec
timeout and there's no way to change that.
- Copy stdout from timed-out process into the output variable,
instead of just dumping it into the log file. This will
improve the user experience, too, because they will get some
feedback / explanation of what the process has done.
- add license file from libpwquality for provenance
- translate pwquality_strerror() into the PWSettingsHolder convenience class
- use Qt translations, since we'd otherwise also have to wire up, and
wire in, libpwquality gettext translations.
- Use shared_ptr and a helper class to hide away raw pointer use
from libpwquality. Provide a convenience C++ API.
- Simplify configuration through helper class.
Use the samegame example from the Qt Quick demos as a branding "slideshow".
Instead of watching slides go by, you can play samegame! Click on
"new game" to start, and then click on groups of same-colored balls to make
them go away -- at least two same-colored balls must be touching.
Once the exec step is done, the game vanishes automatically.
This is an additional example for #841
- Remove some superfluous intermediate defines
- baseFactory was not used (always Calamares::PluginFactory)
- Move DECLARATION and DEFINITIONS apart
- CALAMARES_PLUGIN_FACTORY_DEFINITION was redefined (identically)
- CALAMARES_PLUGIN_FACTORY_DECLARATION was redefined (identically)
- __VA_ARGS__ was constant
If Python isn't found, or PythonQt isn't found, there is no point
in copying over the modules into the build tree; this may even be
misleading because the files are there, but won't work and this
will be noticed at runtime only.
Instead, skip the modules and explain why.
- Issue asks to make the setting more visible, which seems sensible to
me. It **is** kind of hidden away for those distro's that make
the setting visible (not everyone does).
- While here, add a tooltip explaining what it does.
FIXES#893
Allow running one or more commands based on the value of
a global configuration variable. This could, of course,
be done in a Python module with some custom code,
but for simple cases this is more straightforward
to configure through module instances.
Uses the CommandList developed for the ShellProcess
module to do the actual work.
FIXES#874
- Move CommandList so it can be used from more modules than
just ShellProcess
- Allow a CommandList to run itself. This centralizes
code for executing one or more commands and simplifies
the ShellProcess module.
Various small cleanups:
- mention instance id in log message
- code formatting / style
- This turns off the space-available check in the welcome module;
without libparted, always fail that check.
- Allows running the welcome module on OS without libparted.
- Also allow a single string instead of a list
- Add count() method to CommandList
- Drop over-engineering, add more logging
- Expand tests with some more examples
This is basically dummyprocess, except with an expanded configuration
interface so you can run 1 or more shell commands in the live
or target system with a suitable configuration file and instance
of shellprocess in settings.conf.
It can replace downstream modules that implement their own
process modules with a command, by an instance of shellprocess.
Back targetEnvCommand() with a more general runCommand()
that takes an argument selecting the location to run
the command in. This allows us also to use the same
API for running processes in the host during install,
as we do for running them in the target system.
One reason for this change is wanting to run (user-specified)
commands and independently from the global dontChroot setting,
run those commands in the live system or the target.
This changes the ABI of the DLL, since targetEnvCommand()
is no longer exported. Plugins will need to be recompiled.
- refactor targetEnvCommand() into more general runCommand().
- While here, allow host system commands to run even if
there is no global storage.
- provide convenience accessors for ProcessResult members
- Move explanation of process errors out of ProcessJob
- Move from ProcessJob to ProcessResult, so it can be
reused outside of ProcessJob (e.g. from ShellProcessJob).
- Add some convenience functions, too.
Make a function out of explaining-skipped-modules, and call it
not only after collecting all the modules, but also after
the feature summary, so that it's quite clear which modules
are skipped.
Scenario is this: you have no suitable installation devices on
your system (everything is mounted, or HDD has died), click through
to partition page, where you have all the buttons available, but no
devices in the list. The following actions then cause a crash:
- clicking "back"
- clicking any button
Prevent that:
- you can click "back", but if there is no device selected
nothing happens to the device state (no nullptr deref,
and no crash)
- button code is now more resilient to this scenario
- buttons are hidden until a device is available, so you
can't even click on them to trigger the code.
- remove hide-close-button hack
- refactor code in viewmanager for confirming quit
- hook up confirm-and-quit to WM close button
- also works for alt-F4 and other quit methods
- while here, update copyright year
FIXES#870
Modules may be skipped for different reasons: SKIP_MODULES
is the traditional approach to suppress some, but other modules
may have unmet build requirements (e.g. Plasma Look-and-Feel,
or the Partitioning module) and should be able to opt-out
of being built. For all those skipped, log it explicitly after
all the modules have been examined.
Only CMake-based (e.g. C++) modules support opting-out in this way.
This is meant to run one or more jobs based on specific global
configuration values; if could also be done by a Python
module with just some if's, but this one can be used with
just the config file and covers a bunch of use-cases.
The dummyprocess module can be used to run a single
shell command; it can be used effectively with instances
to run one or more commands during installation.
- calculate a hash of the filename, and use that
- makes it possible to distinguish different screenshots
even when the image file is missing / badly configured
- most colors will be dreadful
Patch by Gabriel C. (@abucodonosor).
- use libcalamares functions
- no need to copy /etc/adjtime over we can run hwclock in chroot
since we have /proc , /sys , /dev , /run/* already bind mounted.
- added RTC and ISA probing methode ( see issue #873)
- we probe default from /dev/rtc* ,
- fall back to ISA
- still doesn't work we just print a BIOS/Kernel BUG message and continue
- NOTE: issue #873 is about broken ArchLinux kernel config but there
are HP boxes with real RTC problems no matter what kernel config
is used so let us be nice and don't error out..
FIXES#873
- Implement various ways of getting the LNF; the process-based one
uses a recent CLI-tool from the Plasma developers.
- Fill the UI with (meaningless) LNF package IDs.
- Move widget behavior into its own container / widget class
- Change the RequirementsChecker class to just check the
requirements, returning a results list
- Connect from the module manager to the results widget.
- Move type and rename it; put in Calamares namespace
- Emit signals from the viewmanager as results come in
- Remove state changing from welcome view step based on its internal
requirements checking (for now this breaks progressing past the
welcome page)
- Log checking of the requirements
Introduce a method checkRequirements() into the module system so that
individual modules can do their own checking (as opposed to stuffing
it all into the welcome module).
Do a better job determining what the arguments could mean; this supports
lazy devlopers who don't want to pass in full paths to all kinds of things.
Simple invocation can now be:
testmodule.py <modulename> - +
to read <modulename>.conf from src/modules/<modulename>/
This, kids, is why you don't switch writing C++ and Python too often.
The C++ code isn't a syntax error in Python, although this would fail
at runtime.
Update documentation, add a new key *skip_if_no_internet* to support
systems that **recommend** having an internet connection (but don't
require it), and which also use the packages module. This prevents
a long delay while the package manager tries to access the internet
and times out (repeatedly).
Existing configurations are unchanged.
Use dict methods, in particular d.get(k, v), to retrieve
the pretty_name() function (or None if it isn't there).
Using getattr() on a dict will not return values in the
dict.
Instead of using state-foo icons, use the corresponding emblems because
they are larger and don't have the 'cloud state' background.
Keep the existing names because I don't feel like churning
more of the codebase than necessary.
These new icons are from KDE Neon breeze-icon-theme 5.40, e.g.
breeze-icon-theme: /usr/share/icons/breeze/emblems/8/emblem-error.svg
For called processes, replace the not-very-useful type message
with the command-explanation, and replace the value (previously
command-explanation) by the stderr of the failed command.
FIXES#865
This is why the whole refactoring started: to get the process output
and exit code in one spot so we can attach the process output
to the (Python exception) CalledProcessError in all the code
paths, not just those that are explicitly looking for output.
- Add a more general targetEnvCommand() that returns both
error code and process output.
- Change existing targetEnvCall() and targetEnvOutput()
to use general form while discarding some data.
- Refactor, internal _handle_check_target_env_call_error doesn't need
to be in header or visible.
- Add optional output (of the command) to the Python exception.
Root is always selected, can't be unselected, and has its own explicit
constructor and name. This resolves issue reported where unchecking
all *visible* groups caused the root to be unchecked, after which
hidden-but-still-selected subgroups were not installed.
Reported by crazy@
Adds a "tracking" module which allows configuring phone-home,
machine and user tracking. Additional machine-tracking types
could be defined depending on distro needs.
This is not the final version -- there is still polishing to
do on the icons, perhaps layout.
Tested in KDE Neon devunstable by keeping an existing partition
which had an older Neon running. New machine-id is generated
and sed'ded into place.
FIXES#783
Following KDE Pholio M116, switch to using a radio button; instead
of 4 individually toggle-able settings, use a "level" indicator
to select none, install, machine, user .. each of which implies
the previous levels. Each level is individually enable-able from
the distro side.
If a subgroup is hidden, then it should be considered
selected if its parent is selected or partially-selected.
If the parent group is totally unselected, then the hidden
subgroup shouldn't be installed either. This allows putting
required-packages into a group, without cluttering the
interface.
FIXES#864
While walking up the tree, only switch the selectedness states
of parents with children. This avoids the case where a parent
has a first subgroup that is hidden -- in which case the
parent ends up with no children, and is unselected even though
it is marked as selected in the config file.
FIXES#864
Relying on auto-qobject deletion on shutdown generates a warning message
17:23:44 [0]: QBasicTimer::start: QBasicTimer can only be used
with threads started with QThread
which is annoying. Since we're in shutdown, just skip deletion
entirely, and leave the model unparented.
FIXES#472
Each kind of tracking has an associated webpage / URL describing
the policy for that tracking. The Calamares User Guide has some
generic information. When the user clicks on the Help (?) button
in a tracking-option block, go to that URL.
- Enable translations, substitute ShortProductName into string,
- Simplify code for enabling tracking option blocks,
- Set checkboxes based on configuration,
- Read checkboxes when leaving page,
- Don't stretch the tracking option blocks.
- add icons for graphical display of actions
- extend description of tracking options
- add debug logging
- enable next button
- show/hide tracking options based on configuration
- don't log when libs not found
- log that it's the Python libraries version (not Python itself)
- fix RE that was getting the wrong results for maj.min
- m_groups is only set to a non-nullptr value when data is received
and fully processed,
- avoid nullptr dereference when paging *back* from a netinstall
page that hasn't loaded groups data.
FIXES#859
- Document netinstall.conf a little,
- Add setting *required* which influences whether next is enabled or not
in case of missing or corrupt data,
- Enable *next* button only once some (any!) data is received.
This can be used to disallow stepping past the netinstall step when
there is no data (e.g. internet has failed between the welcome page
and the netinstall page).
- replace weird distinction between 3.0 and 3.2 by searching once
- prefer 3.2
- also look for suffixed versions (PythonXY) besides the Python3 suffix
FIXES#857
- Warn here since it may not be what the Distributor want.
Having wrong groups may result in broken permissions for
created user.
- explain what defaultGroups is for in users.conf
Welcome is only interested in checking partitions, not
in resizing them, so stick to one library. This will
become moot when the checks move to partitionmanager
and KPMCore can do the things.
- this applies to new partitions; existing documentation erroneously
said this happens with Replace as well,
- follow up on Andrius manual-partition PR with documentation that
manual mode doesn't switch to this FS when editing existing partitions.
- it doesn't make any sense to have restartNowCommand and fallback
set to the same command.
- also fallback should be something generic every init supports
- Was marked incomplete and unused; none of the existing modules
set any requirements, and the descriptors are not set up to
hold the requirements information anyway.
- Dependencies are generally through globalStorage values, or if
there are dependent jobs they should be created in-order by one
source (e.g. though a View or a subclass of CppJob which overrides
jobs() ).
- It is the responsibility of deployers to formulate a settings.conf
that includes all the required modules.
- A 'real' dependency system is going to lead to the introduction
of interface-definitions and a great deal of complexity, for a
use case that can be handled with careful deployment instead.
This is experimental, off-by-default, code for developing a telemetry /
tracking configuration module. It is preliminary work for issue #628,
but also for KDE Neon configuration. Any telemetry should conform to
the KDE Telemetry Policy [1] or similar Free Software telemetry policy
(e.g. the Mozilla one).
[1] https://community.kde.org/Policies/Telemetry_Policy
Initial idea is to distinguish three kinds of tracking:
- installs. This tracks that OS <foo> has been installed somewhere.
It might send some machine information to a remote server.
- machines. This enables some kind of machine tracking in the
installed system, for instance it could enable popcon on
Debian, or periodic phone-home-pings.
- users. This enables some kind of telemetry / tracking on the
installed user in the system.
A simple and transparent setting is to enable install-tracking and set
it to opt-in, and disable machine and user tracking. Explain to the
user that <foo> would like to know when <foo> is installed, and that
the following information <d1>, <d2> will be sent to <url> in accordance
to the <foo> telemetry policy at <url2>.
Work in this branch is subject to VDG review for the visuals, and
privacy oversight by whatever group is responsible for <foo> privacy.
Note that this module makes it *possible* for telemetry configuration
to be visible inside the installer; what distro's do with telemetry
already is entirely outside the scope of this configuration module.
Split locale into <language>_<country> and go looking for keyboard
layouts that match. Do that in reverse, so look for country first.
- known weakness is el_CY (should get layout gr) because CY and el
don't name any keyboard layout.
- known weakness are Hausa, Igbo .. which are ha_NG and ig_NG. They select
keyboard layout ng, which is labeled "English (Nigeria)"; they ought
to select ng(hausa) and ng(igbo), which are the right variant keyboard
layouts to use.
- similar selecting a locale in Canada (en_CA, fr_CA, iu_CA ...) will
select keyboard layout ca, which is for French-speaking Canada.
Locale en_CA should select keyboard en -- e.g. en(us). But iu_CA
(Inuktituk) needs layout ca(ike).
> Hi! Thank you for helping improve Calamares. If you are seeing a problem in installing a specific distribution, you should **probably** report the problem in the distribution's bug tracker, first. That helps filter out issues with packaging, mis-configuration, etc. that Calamares has no control over. If you are a distribution packager or maintainer, this page is for you.
**Describe the bug**
A clear and concise description of what the bug is. Please include 32/64 bit machine details, EFI/BIOS details, and disk setup.
**To Reproduce**
Steps to reproduce the behavior:
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error
**Expected behavior**
A clear and concise description of what you expected to happen.
**Screenshots and Logs**
If applicable, add screenshots to help explain your problem. Calamares has an installation log (usually `~/.cache/calamares/session.log`), please check it for confidential information and attach it if possible.
The test goals. e.g.: Evaluate the language selection and the partitioning configurations.
# Requirements
## Environment
What is the environment that should be tested and how it should be prepared. e.g.: The test needs to run in the release 3.32.34 installing Manjaro.
## User profile
Describe the target users you are looking for the test. e.g.: A user that has already used a system-installer.
## Facilitator
What the facilitator should be familiar with to run the tests. e.g.: The facilitator needs to know how to build Calamares to be able to run the tests.
# Test design
## Tasks
A list of tasks that the user has to perform. e.g.:
* Use another language.
* Change partitioning configurations.
## Scenarios
A list of scenarios for the user to perform the tasks. They should put the user in a context and not give specific hints about what you want the user to do. e.g.:
1. You want to change the installer language to English. Please, look for this option in the application.
2. You are a big fan of a lot of distributions and want to have some space left to install other distributions in your disk after this installation. Please, resize your disk to have 35GB of space left.
<!--
## Results
Uncomment this session once you have your results.
### Summary
| - | User 1 | User 2 | User 3 | User 4 | User 5 |
Describe what happened as expected. e.g.: Most users intuitively found the language selector for changing the installer language.
#### What were the challenges?
Describe where the users had issues and why. Try to write the details to ensure a good understanding of what happened. You can also attach videos, GIFs, or screenshots to illustrate. e.g.: Two of the users had issues searching for English on the language selector because they didn't realize they could scroll down to find it.
### Task 2
#### What went well?
Describe what happened as expected. e.g.: Most users intuitively found the language selector for changing the installer language.
#### What were the challenges?
Describe where the users had issues and why. Try to write the details to ensure a good understanding of what happened. You can also attach videos, GIFs, or screenshots to illustrate. e.g.: Two of the users had issues searching for English on the language selector because they didn't realize they could scroll down to find it.
feature_summary(WHATDISABLED_FEATURESDESCRIPTION"The following features have been disabled:"QUIET_ON_EMPTY)
feature_summary(
WHATOPTIONAL_PACKAGES_NOT_FOUND
DESCRIPTION"The following OPTIONAL packages were not found:"
QUIET_ON_EMPTY
)
feature_summary(
WHATREQUIRED_PACKAGES_NOT_FOUND
FATAL_ON_MISSING_REQUIRED_PACKAGES
DESCRIPTION"The following REQUIRED packages were not found:"
QUIET_ON_EMPTY
)
### PACKAGING
#
# Note: most distro's will do distro-specific packaging rather than
# using CPack, and this duplicates information in the AppStream, too.
set(CPACK_PACKAGE_VENDORcalamares)
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY"A Linux system installer")
set(CPACK_PACKAGE_DESCRIPTION
"Calamares is a Linux system installer, intended for Linux distributions to use on their ISOs and other bootable media to install the distribution to the end-user's computer. Calamares can also be used as an OEM configuration tool. It is modular, extensible and highly-configurable for Linux distributions from all five major Linux families."
message("-- ${BoldYellow}Warning:${ColorReset} branding component ${BoldRed}${SUBDIRECTORY}${ColorReset} has a translations subdirectory but no CMakeLists.txt.")
message("")
return()
endif()
# We glob all the files inside the subdirectory, and we make sure they are
message("-- ${BoldYellow}Warning:${ColorReset} tried to add branding component subdirectory ${BoldRed}${SUBDIRECTORY}${ColorReset} which has no branding.desc.")
message("-- ${BoldYellow}Warning:${ColorReset} tried to add module subdirectory ${BoldRed}${SUBDIRECTORY}${ColorReset} which has no CMakeLists.txt or module.desc.")
find_library(PYTHONQT_QTALL_LIBRARY_RELEASEPythonQt_QtAllPATHS"${PYTHONQT_INSTALL_DIR}/lib"DOC"Full Qt bindings for the PythonQt library.")
find_library(PYTHONQT_QTALL_LIBRARY_DEBUGNAMESPythonQt_QtAll${CTK_CMAKE_DEBUG_POSTFIX}PythonQt_QtAll${CMAKE_DEBUG_POSTFIX}PythonQt_QtAllPATHS"${PYTHONQT_INSTALL_DIR}/lib"DOC"Full Qt bindings for the PythonQt library.")
find_library(PYTHONQT_QTALL_LIBRARY_RELEASEPythonQt_QtAll-Qt5-Python3PATHS"${PYTHONQT_INSTALL_DIR}/lib"DOC"Full Qt bindings for the PythonQt library.")
find_library(PYTHONQT_QTALL_LIBRARY_DEBUGNAMESPythonQt_QtAll-Qt5-Python3${CTK_CMAKE_DEBUG_POSTFIX}PythonQt_QtAll-Qt5-Python3${CMAKE_DEBUG_POSTFIX}PythonQt_QtAll-Qt5-Python3PATHS"${PYTHONQT_INSTALL_DIR}/lib"DOC"Full Qt bindings for the PythonQt library.")
Calamares is a KDE-Frameworks and Qt-based, C++17, CMake-built application.
The dependencies are explained in [CONTRIBUTING.md](CONTRIBUTING.md).
## Contributing to Calamares
Calamares welcomes PRs. New issues are welcome, too.
There are both the Calamares **core** repository (this one),
and an **extensions** repository ([Calamares extensions](https://github.com/calamares/calamares-extensions)).
Contributions to code, modules, documentation, the wiki and the website are all welcome.
There is more information in the [CONTRIBUTING.md](CONTRIBUTING.md) file.
## Join the Conversation
GitHub Issues are **one** place for discussing Calamares if there are concrete
problems or a new feature to discuss.
Regular Calamares development chit-chat happens in a [Matrix](https://matrix.org/)
room, `#calamares:kde.org`. The conversation is bridged with IRC
on [Libera.Chat](https://libera.chat/).
Responsiveness is best during the day
in Europe, but feel free to idle. If you use IRC, **DO NOT** ask-and-leave. Keep
that chat window open because it can easily take a few hours for
someone to notice a message.
Matrix is persistent, and we'll see your message eventually.
* [](https://webchat.kde.org/#/room/%23calamares:kde.org) (needs a Matrix account)
* [](https://kiwiirc.com/client/irc.libera.chat/#calamares) (IRC supports guest accounts)
Calamares is released under the terms of the GNU GPL, version 3 or later. Every source file must have a license header, with a list of copyright holders and years.
Example:
```
/* === This file is part of Calamares - <http://github.com/calamares> ===
*
* Copyright 2013-2014, Random Person <name@example.com>
* Calamares is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Calamares is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty 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 Calamares. If not, see <http://www.gnu.org/licenses/>.
*/
```
Copyright holders must be physical or legal personalities. A statement such as
`Copyright 2014, The FooBarQuux project` has no legal value if "The FooBarQuux
project" is not the legal name of a person, company, incorporated
organization, etc.
Please add your name to files you touch when making any contribution (even if
it's just a typo-fix which might not be copyrightable in all jurisdictions).
Formatting
----------
This formatting guide applies to C++ code only; for Python modules, we use
[pycodestyle][https://github.com/PyCQA/pycodestyle] to apply a check of
some PEP8 guidelines.
* Spaces, not tabs.
* Indentation is 4 spaces.
* Lines should be limited to 90 characters.
* Spaces between brackets and argument functions, including for template arguments
* No space before brackets, except for keywords, for example `function( argument )` but
`if ( condition )`.
* For pointer and reference variable declarations, put a space before the variable name
and no space between the type and the `*` or `&`.
*`for`, `if`, `else`, `while` and similar statements put the brackets on the next line,
although brackets are not needed for single statements.
* Function and class definitions have their brackets on separate lines.
* A function implementation's return type is on its own line.
*`CamelCase.{cpp,h}` style file names.
Example:
```
bool
MyClass::myMethod( QStringList list, const QString& name )
{
if ( list.isEmpty() )
return false;
foreach ( const QString& string, list )
cDebug() << "Current string is " << string;
switch ( m_enumValue )
{
case Something:
return true;
case SomethingElse:
doSomething();
break;
}
}
```
You can use the `hacking/calamaresstyle` script to run
[astyle](http://astyle.sf.net) on your code and have it formatted the right
way.
**NOTE:** An .editorconfig file is included to assist with formatting. In
order to take advantage of this functionality you will need to acquire the
[EditorConfig](http://editorconfig.org/#download) plug-in for your editor.
Naming
------
* Use CamelCase for everything.
* Local variables should start out with a lowercase letter.
* Class names are capitalized
* Prefix class member variables with `m_`, e.g. `m_queue`.
* Prefix static member variables with `s_`, e.g. `s_instance`.
* Functions are named in the Qt style, like Java's, without the 'get' prefix.
* A getter is `variable()`.
* If it's a getter for a boolean, prefix with 'is', so `isCondition()`.
* A setter is `setVariable( arg )`.
Includes
--------
Header includes should be listed in the following order:
* own header,
* Calamares includes,
* includes for Qt-based libraries,
* Qt includes,
* other includes.
They should also be sorted alphabetically for ease of locating them.
Includes in a header file should be kept to the absolute minimum, as to keep compile times short. This can be achieved by using forward declarations instead of includes,
like `class QListView;`.
Example:
```
#include "Settings.h"
#include "CalamaresApplication.h"
#include "utils/CalamaresUtils.h"
#include "utils/Logger.h"
#include "YamlUtils.h"
#include <QDir>
#include <QFile>
#include <yaml-cpp/yaml.h>
```
Use include guards, not `#pragma once`.
C++ tips
--------
All C++11 features are acceptable, and the use of new C++11 features is encouraged when
it makes the code easier to understand and more maintainable.
The use of `nullptr` is preferred over the use of `0` or `NULL`.
For Qt containers it is better to use Qt's own `foreach`. For all other containers, the
range-based `for` syntax introduced with C++11 is preferred ([see this blog post][1]).
When re-implementing a virtual method, always add the `override` keyword.
Try to keep your code const correct. Declare methods const if they don't mutate the
object, and use const variables. It improves safety, and also makes it easier to
understand the code.
For the Qt signal-slot system, the new (Qt5) syntax is to be preferred because it allows
the compiler to check for the existence of signals and slots. As an added benefit, the
new syntax can also be used with `tr1::bind` and C++11 lambdas. For more information, see
Some files were not shown because too many files have changed in this diff
Show More
Reference in New Issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
