- 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
- 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
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.
- 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.
- If there's no scripts involved in a package for netinstall, just
name it without the scripts; this lets the packages module
optimize to fewer package manager calls.
- Each element of the (list) packageOperations needs to be a
package operation, which is a dictionary with keys (identifying actions)
and lists of packages (which may be strings or script-info dictionaries).
- 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.
In the timezone widget, locations in the far north -- Inuvik,
Thule, Longyearbyen -- were displayed too far south, because the
map location calculation assumes a linear gradient, which places
90 degrees north at about 70 degrees. Change calculation to
pretend the world is flat south of 62 degrees north, and then
'bend' the remaining 28 degrees of latitude to the top of the
image. This puts most places in the right spot, although Yellowknife
is now on the south shore of Great Slave.
Fort Nelson should be north of Dawson Creek, too -- the math still
needs a little work.
While here, put Antarctica in the south, otherwise Rothera keeps
showing up in Greenland.
- 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 only a partial solution to warnings caused by third-party
code, since #including the headers from other sources won't apply
the warning-suppressions.
- Flags are not applied when building the source as part of a larger
target, but are on re-building just one object (it seems -- CMake
issue to track down).
Thanks to Kevin Kofler for pointing out what I'd forgotten about
source-file flags. While at it, introduce a generic mechanism for
suppressing warnings in third-party code.
Mostly reverts 4930484931
- include full license headers,
- copied from
- repo: https://github.com/snowwlex/QtWaitingSpinner
- rev: bb8f8987ca19406dc75704eb382ab52e981b773f
This revision *does not build* because the files have been renamed.
- Introduce a map 'passwordRequirements' in users.conf,
which is a list of named requirements. There are only
two settings right now, min and max length, but
additional checks can easily be added in UsersPage.cpp
by defining additional lambda's to check the given
password string.
- Add PasswordCheck instances as needed, with functions
to check acceptability and to produce messages on rejection.
- Documentation in the users.conf file itself.
- In passing, refactor setting of pixmaps on labels.
FIXES#790
Resolves issue where 'linuxswap' is translated to 'Linux-Swap',
for instance. FileSystem::name() provides a translated name,
not an untranslated one.
This should move to KPMCore.
FIXES#797
There is no need to force folks haing a random group
bc that is a Distro think. SDDM/GDM works just fine without
having a group for the user to autologin.
Just setup a group in users.conf .. is why we have a configuration
option for that.
- deleteLater() doesn't like nullptr (produces a warning, but is harmless)
- reparenting across threads doesn't work, comment on that but leave
it in, since this may be relevant for memory management.
- both NetInstall (group data) and Locale (GeoIP) use network
data returned as a source of YAML data. Try to explain
parsing errors for both.
FIXES#786
When NetInstall receives YAML data, handle parser errors more gracefully:
show line and column, but because it's network data (not in a local file),
do some work to print out the actual data received.
FIXES#786
If the summary widget is large, it gets a scrollbar. This looks really
weird, so prefer to grow the installer window instead. Discussed with
@sitter and settled on this solution.
ViewSteps can signal the ViewManager that they need more space (in pixels),
which may or may not be honored.
FIXES#778
This was WIP, working on the fstab / UUID problem, but stands on its
own; since others are zooming in on the fstab / UUID problem, close
down the branch.
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.
- Check for 'list' when it's actually a 'dict' is strange.
Reverse logic to consider 'str' a package name and everything
else is special.
- Refactor to handle the difference between package names and
packages-with-script-data in one place.
- Add code and config documentation.
- Switch sample configurations to dummy-backend.
When testing Python modules, passing option --lang should also
set the global 'locale' (to a BCP47 string, but hey) like it
already sets localeConf.LANG.
- For Boot and Device info widgets, add a retranslateUi() method,
since the labels change not only in response to translation
events but also UI events.
FIXES#779
- Add a target 'example-distro' which must be manually invoked
This creates an example.sqfs with a minimal binary distro
based on the build hosts's /bin and /lib.
The purpose is to provide a simple test image which the
default configuration of the unpackfs module can use to
create a system within which the *other* steps of the
installation can run.
Example files are some zoneinfo's (remember to choose an
existing zone when using the example distro), groups and
sudoers files, etc ..
The example distro has a special /xbin which contains bogus
binaries for many system-administration tasks (e.g. useradd
which would otherwise come from /usr/sbin).
- remove Job.gettextPath
- add libcalamares.utils.gettext_path()
- add libcalamares.utils.gettext_lang()
- modify examples in main.py
- add some gettext debug-output from dummypython
- correct namespace mis-labeling
- provide two forms of GlobalStorage
- regular use, has a JobQueue with storage
- testing use, creates GlobalStorage separately, provide
independent access to that for Python.
- Didn't run at all (at least since v3.1) because of mismatch between
GlobalStorage constructor arguments and use; special-case None
in the C++ code to allocate a new GlobalStorage object.
Add description of language and number formats to pretty status.
This is shown in the summary page. Refactor a little to produce
the strings only in one place. Constify methods.
FIXES: #564
This is preparatory work for making the available-space check consistent with
what the partition module will allow for installation. Right now, the check
for available space will allow a mounted drive, even /, to satisfy the check.
Switch the failure popup to non-modal, and quit the application when
the pop-up is closed. This allows signals to be delivered to other
slots connected to JobQueue::failed.
Only the string "fat32" and "fat16" will be replaced with vfat. If an
case sensitive "Fat32" some problems occure:
- mount: partition cannot be mounted (e.g. a fat32 efi partition)
- fstab: system won't even boot because fstab does not know the type "Fat32"
None of the Qt translations are found, nor shipped along with the
Calamares translations; it depends on the translations of Qt
on the live system. The mechanism was broken, anyway, by the
split into qt_<foo>.qm and qtbase_<foo>.qm, and the introduction
for QPT for the translation of standard button texts.
Just drop the special code looking for Qt translations and the
rcc hacks that entails.
FIXES#336
- no matter if for example slick-greeter is installed as "lightdm-slick-greeter" or whatever.
tested with lightdm-deepin-greeter and slick-greeter.
- plus some little simplifications
- added Copyright
https://github.com/calamares/calamares/issues/756
A new option BUILD_TESTING is available; you can turn this off at
CMake-time, but building the tests themselves is harmless (although
it takes some CPU time).
The main advantage of doing this is that running the tests becomes
simple:
make test
Instead of figuring out which tests there are and how to run them
individually. Note that the partition-manager tests will normally
fail, because they require an additional environment variable to
be set to tell them what disk to destroy.
On 1024x768, limit to 1024x520.
On 800x600, limit to 800x520. This is too small to show everything in the
timezone widget and keyboard, so it needs some more work.
Use QProcess::execute() with the 'safer' argument-list, rather than
escaping and de-escaping strings. Also reduce noise by only passing
a variant if there is one.
The hostname madagascarsteenplaatschildpad (.uva.nl) doesn't fit in 24,
and hostname(1) accepts up to 64 characters. The RFCs vary, but 63 +
terminating NUL or length-octet + data maximum 64 bytes seen to be
the common ground.
FIXES#514
This just puts a warning in the cmake log, but will help diagnose
situations where libatasmart.so.4 is installed, but libatasmart.so
is not -- in which case -latasmart fails.
Tested in a VirtualBox setup with screen set to 800x600,
all of the Generic Linux RT components are visible, and
the buttons are too (which fall off the screen otherwise).
FIXES#731
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).
If user picks an installer language on the welcome page, then
the system language follows that setting -- but only after the
first action where Calamares must guess the system language
based on location. So guess on entry, so that system language
follows installer language.
FIXES#688.
If the user selects a language from the dialog (by clicking 'change'),
then preserve that explicit choice even when clicking on another
location which would reset the language based on the installer-
language.
When selecting keyboard layout, pause, then select another, the
QTimer wasn't being disconnected from the previously selected
language, so the second selection would fire the timeout, and
then call *two* slots .. and then three, ... Disconnect when
the timer fires, too.
- to make it short - it doesn't help much if one try to find and process any
EFI related things in the live system. The better approach is to search in
the chroot.
- use python builtins for mkdir and cp
- replacing some subprocess calls
- Some PEP8 changes
- added myself to the copyright section
if the key "install" was used, the install would crash as the backwards
compatibility checks were incorrect. Fixed a typo in the run function so
pre- and post-install hooks now work correctly
the docs do not current reflect the new net-install and packages modules
changes well. This updates them to explain the new keys in the
configuration files.
This only kicks in if QNAM's check is inconclusive. It sends a request
and tries to read data from a user-provided URL.
CAL-404 #close Should be fixed in master, please test.
This allows for installing locale packages. This can be achieved
by adding a entry of the format packagename-${LOCALE} in the
packages configuration module.
This is done to support both Pythonic and Qt style method names, i.e.
both "isNextEnabled" and "is_next_enabled" is ok in a Python module.
Also better documentation in PythonQtViewStep, and stub for
setConfigurationMap.
Finally, proper handling of PythonQtViewStep Python-facing basewidget:
with this change, a call to PQVS::widget() only triggers a widget
relayout if it's necessary, and leaves it alone otherwise.
The INSTALL_CONFIG is "on" by default. When set to off,
no *.conf file, both global and related to a single module,
will be installed. A warning message is printed by cmake too,
and the module description is edited to make this visible.
This is useful for testing, when we want to install our
own libraries and binary but keep the configuration of the
live system we are testing on (e.g. path to distro image).
Tested on the master branch.
This means that when we edit a partition, we don't consider
its current mountpoint invalid because it is already in-use.
We need to do this for both "edit existing partition" and
"edit a partition that we are still creating".
We get the mountpoints already used by other partitions, and
disable the Ok button in the "Create new partition" dialog if
the user selects/writes a mountpoint which is already used.
We are going to do the same in the Edit partition dialog
after testing.
We need master to have a higher version than the stable branch. I used
2.4.80 so that it can be bumped again to 2.4.90 when starting to do
alpha/beta/RC releases.
We need master to have a higher version than the stable branch. I used
2.4.80 so that it can be bumped again to 2.4.90 when starting to do
alpha/beta/RC releases.
Package groups are divided into critical and non-critical
depending on whether we want all Calamares to fail if installing
a package in the group fails, or we are okay with just logging a
warning.
The distinction is configured in the YAML file listing the package
groups. By default, all groups are critical, to keep supporting
the previous behaviour.
On 32-bit UEFI (note that the bitness of the firmware is what matters
here, not the bitness of the distribution), instead of copying
grubx64.efi to bootx64.efi, copy grubia32.efi to bootia32.efi.
Patch by TeHMoroS from SparkyLinux.
CAL-403 #close
Use QNetworkAccessManager instead of raw QtDBus queries to
NetworkManager in RequirementsChecker::checkHasInternet(). This is much
simpler (i.e., less error-prone) and should be more portable (to, e.g.,
ConnMan).
Unfortunately, rsync returns exit code 23 (Partial transfer due to
error) if it cannot write extended attributes (with -X) because the
target file system does not support it, e.g., the FAT EFI system
partition. We need -X because distributions using file system
capabilities and/or SELinux require the extended attributes. But
distributions using SELinux may also have SELinux labels set on files
under /boot/efi, and rsync complains about those. The only clean way
would be to split the rsync into one with -X and --exclude /boot/efi and
a separate one without -X for /boot/efi, but only if /boot/efi is
actually an EFI system partition. For now, this hack will have to do.
See also:
https://bugzilla.redhat.com/show_bug.cgi?id=868755#c50
for the same issue in Anaconda, which uses a similar workaround.
In other words, support:
hidden: false
selected: true
groups.
This was supposed to work according to README.md, but not actually
implemented. Now it should be working.
Since sddm.conf follows the INI format we can use configparser
with a few added options to properly parse the config and write
it out instead of manually parsing each line which is slow and
prone to error.
For eg. The old code would fail to parse a conf which had no
commented out User key but where the user had configured autologin
in Calamares.
Address an old FIXME in
PartitionCoreModule::scanForEfiSystemPartitions(): Check the FlagEsp on
the Partition object (that KPMcore has been supporting since 2.1.0)
instead of running sgdisk.
The manual partitioning setup was already requiring the user to check
the ESP flag for the EFI System Partition. Now the autopartitioning also
sets it directly (a one-line change). The sgdisk call in the bootloader
module is thus no longer necessary (it was only a workaround because
kpmcore < 2.1.0 did not support FlagEsp), so remove that snippet.
This fixes configurations such as NVME disks where splitting boot_device
into boot_device[-1:] and boot_device[:-1] is not the correct split
(because the partition gets a 2-letter suffix) (reported by demmm on
IRC).
* add rd.luks.uuid to GRUB_CMDLINE (fixes unbootable system with dracut --nohostonly, and doesn't affect any other initramfs generators)
* typo
* only write rd.luks.uuid line if dracut is present, and leave other initramfs generators alone :D
* add missing = operator
Add a dracutlukscfg module to write a
/etc/dracut.conf.d/calamares-luks.conf file for LUKS full disk
encryption support with Dracut.
You should run:
* partition
* luksbootkeyfile
* dracutlukscfg
* dracut
in that order (not necessarily in immediate sequence). The
luksopenswaphook module is not used with Dracut.
If we use .replace("'", "'\\''") for escaping, we also need to use
single quotes, not double quotes.
This was broken by the port from '%' to format, which also randomly
changed quoting characters for no good reason. Changing the outer ones
does not matter, but \" or ' within a string is not the same thing!
Added an initramfscfg module to handle pre-configuration for the Debian
update-initramfs, such as installing hooks (needed for luks/FDE support
on Debian-based distros).
Closes#254. (Cherry-picked from the pull request.)
fstab.conf: Add a new "crypttabOptions" option that defaults to "luks".
Document that for Debian and Debian-based distributions, the
setting should be changed to "luks,keyscript=/bin/cat".
main.py: Append the options from the above setting to the end of every
line in crypttab.
At least the "luks" option should always be there, because there may be
different encryption types. The Debian initramfs-tools also require the
Debian-specific keyscript option and will otherwise ignore the keyfile
entirely (see pull request #254).
At least the Debian update-initramfs needs the entry to be there (see
pull request #254). Dracut will probably need it too. And logically, it
should be there.
These job plugins work similarly to view modules, with the following
differences:
* These jobs need to link only libcalamares, not libcalamaresui. For
this reason, PluginFactory was moved from libcalamaresui to
libcalamares. (It depends only on QtCore.)
* Instead of deriving from ViewModule, derive from CppJob (which is a
subclass of Job).
* Like process and Python jobs, a job plugin is a single job, whereas a
ViewModule can generate a whole list of jobs.
The CppJob and CppJobModule classes are new. In Module::fromDescriptor,
the combination type=job, intf=qtplugin is now supported and mapped to
CppJobModule.
locale -a returns the locales using ".utf8" names rather than ".UTF-8".
The case-insensitive match does not help because it is "utf8" rather
than "UTF-8". So we need to match both with and without the dash.
Pass the full name directly to useradd instead, using the "-c" (comment)
parameter, which is "currently used as the field for the user's full
name" according to the documentation.
The chfn utility is no longer installed by default on current Fedora
releases due to its dependency on libuser. (They split out chfn and chsh
from util-linux into an optional subpackage.) It could be added as a
dependency of Calamares, but since it is needed inside the chroot, it
has to be on the base live image, not the overlay. Thus, to allow
testing Calamares with a simple "dnf install calamares" again, the
dependency needs to go away. And it is unnecessary anyway.
This commit adds support for distribution to define sidebarTextHighlight to their
branding.desc file, to control the left panel (sidebar) with highlight behind the
current step (isCurrent) text label.
2016-01-06 20:02:56 -07:00
1268 changed files with 343037 additions and 95920 deletions
> 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.
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.")
SET(_summary"${_summary}\n-----------------------------------------------------------------------------\n-- The following external packages were located on your system.\n-- This installation will have the extra features provided by these packages.\n-----------------------------------------------------------------------------\n${_enabled}")
ENDIF(EXISTS${_enabledFile})
IF(EXISTS${_disabledFile})
SET(_missingDeps1)
FILE(READ${_disabledFile}_disabled)
FILE(REMOVE${_disabledFile})
SET(_summary"${_summary}\n-----------------------------------------------------------------------------\n-- The following OPTIONAL packages could NOT be located on your system.\n-- Consider installing them to enable more features from this software.\n-----------------------------------------------------------------------------\n${_disabled}")
ENDIF(EXISTS${_disabledFile})
IF(EXISTS${_missingFile})
SET(_missingDeps1)
FILE(READ${_missingFile}_requirements)
SET(_summary"${_summary}\n-----------------------------------------------------------------------------\n-- The following REQUIRED packages could NOT be located on your system.\n-- You must install these packages before continuing.\n-----------------------------------------------------------------------------\n${_requirements}")
FILE(REMOVE${_missingFile})
SET(_haveMissingReq1)
ENDIF(EXISTS${_missingFile})
IF(NOT${_missingDeps})
SET(_summary"${_summary}\n-----------------------------------------------------------------------------\n-- Congratulations! All external packages have been found.")
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.")
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.
Formatting
----------
* 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.
