- 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)
- 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.
- 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.
- 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.
- 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.
- 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)
Introduces a "partitioning service" into libcalamares,
shuffles a bunch of things into it, tries to help out
with settling the system between partitioning actions.
- 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.
- 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
- 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 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
- 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.
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.
- 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).
- 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)
- 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 .. */
- 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.
- 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.
- 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.
- 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.
- 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.
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>
- 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".
- 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.
- 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.
- 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.
- 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.
- 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.
- 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).
- 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.
- 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.
- 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 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.
- 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.
- 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.
- 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.
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>
- 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?
- 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.
- Dealing with legacy formats and alternate configurations
is something that consumers should do (and then hand off
to the 3-string constructor) instead.
- 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.
- 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.
- 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.
- 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.
