| Age | Commit message (Collapse) | Author |
|---|
|
|
|
* When the ipv4 and ipv6 properties are used with a container, avoid
propagating the address out to the host.
* DnsInfo has been replaced with DnsInfoPropagated and
DnsInfoUnpropagated. (API change)
* Code that used fromDnsInfo . fromInfo changes to use getDnsInfo.
* addDNS takes an additional Bool parameter to control whether
the DNS info should propagate out of containers. (API change)
This commit was sponsored by Trenton Cronholm on Patreon.
|
|
|
|
Signed-off-by: Zihao Wang <dev@wzhd.org>
|
|
ghc 7 does not support -fno-warn-redundant-constraints so this can't be
done on a per-module basis.
It would be good to revert this commit when dropping support for ghc 7.
|
|
Only a couple of the constraints were really redundant. The rest are
essential to propellor's tracking of Info propigation, so I silenced the
warning for those.
It would be better to only silence the warning for the functions with the
extra constraints, but IIRC warnings can only be silenced on an entire file
basis.
This commit was sponsored by Andreas on Patreon.
|
|
(cherry picked from commit ee1f24f5cc31c3d3524b43a74b16acae1c3a4ee4)
|
|
(cherry picked from commit 3590a1241580ddcdd153e2619a3c02ce18a8db8c
but without the changes to src/Propellor/Precompiled.hs)
|
|
TODO: remove ANDROID (used in GitAnnexBuilder)
TODO: add other architectures
TODO: rename ARMHF
TODO: rename ARMEL
(cherry picked from commit 6f36f6cade4e1d8b15c714565e223562c6573099)
|
|
|
|
Renamed several utility functions along the way.
|
|
The new properties let the type checker know what the target OS is.
|
|
|
|
|
|
|
|
Import Prelude after modules that cause warnings due to AMP change
|
|
controller of other hosts.
The hard part of this is avoiding loops of controllers. To make that work,
a ControllerChain is passed to the host that's spun, and is added to the
Info of the host being spun, where the controller property can check it
to detect an avoid a loop.
That needed an expansion of the CmdLine data type. I made the new
ControlledRun only be used when there is a ControllerChain provided.
This avoids breaking backwards compatability with old propellor
deployments, as --spin still uses SimpleRun.
Note: Making an old propellor deployment be controlled by a controller
won't work until it's been updated to this commit, so it knows about
the ControlledRun parameter.
(Untested)
|
|
- add canonicalIP and reverseIP to Propellor.Types.Dns
- remove corresponding canonical and revIP from Propellor.Property.Unbound
- Propellor.Property.Dns: convert rValue, rField and genRecord to return
Maybe String
Signed-off-by: Félix Sipma <felix.sipma@no-log.org>
|
|
|
|
Convert Info to use Data.Dynamic, so properties can export and consume
info of any type that is Typeable and a Monoid, including data types
private to a module. (API change)
Thanks to Joachim Breitner for the idea.
|
|
|
|
* Property has been converted to a GADT, and will be Property NoInfo
or Property HasInfo.
This was done to make sure that ensureProperty is only used on
properties that do not have Info.
Transition guide:
- Change all "Property" to "Property NoInfo" or "Property WithInfo"
(The compiler can tell you if you got it wrong!)
- To construct a RevertableProperty, it is useful to use the new
(<!>) operator
- Constructing a list of properties can be problimatic, since
Property NoInto and Property WithInfo are different types and cannot
appear in the same list. To deal with this, "props" has been added,
and can built up a list of properties of different types,
using the same (&) and (!) operators that are used to build
up a host's properties.
|
|
The problem this exposes has to do with requires. As implemented,
requires yields either a Property HasInfo or a Property NoInfo depending
on its inputs. That works. But look what happens when it's used:
*Propellor.Types> let foo = IProperty "foo" (return NoChange) mempty mempty
*Propellor.Types> let bar = IProperty "bar" (return NoChange) mempty mempty
*Propellor.Types> foo `requires` bar
<interactive>:17:5:
No instance for (Requires (Property HasInfo) (Property HasInfo) r0)
arising from a use of `requires'
The type variable `r0' is ambiguous
Possible fix: add a type signature that fixes these type variable(s)
Note: there is a potential instance available:
instance Requires
(Property HasInfo) (Property HasInfo) (Property HasInfo)
-- Defined at Propellor/Types.hs:167:10
Possible fix:
add an instance declaration for
(Requires (Property HasInfo) (Property HasInfo) r0)
In the expression: foo `requires` bar
In an equation for `it': it = foo `requires` bar
This can be avoided by specifying the result type:
*Propellor.Types> (foo `requires` bar) :: Property HasInfo
property "foo"
But then when multiple `requires` are given, the result type has to be
given each time:
*Propellor.Types> (foo `requires` bar `requires` bar) :: Property HasInfo
<interactive>:22:6:
No instance for (Requires (Property HasInfo) (Property HasInfo) x0)
arising from a use of `requires'
The type variable `x0' is ambiguous
Possible fix: add a type signature that fixes these type variable(s)
Note: there is a potential instance available:
instance Requires
(Property HasInfo) (Property HasInfo) (Property HasInfo)
-- Defined at Propellor/Types.hs:167:10
Possible fix:
add an instance declaration for
(Requires (Property HasInfo) (Property HasInfo) x0)
In the first argument of `requires', namely `foo `requires` bar'
In the expression:
(foo `requires` bar `requires` bar) :: Property HasInfo
In an equation for `it':
it = (foo `requires` bar `requires` bar) :: Property HasInfo
<interactive>:22:21:
No instance for (Requires x0 (Property HasInfo) (Property HasInfo))
arising from a use of `requires'
The type variable `x0' is ambiguous
Possible fix: add a type signature that fixes these type variable(s)
Note: there are several potential instances:
instance Requires
(Property NoInfo) (Property HasInfo) (Property HasInfo)
-- Defined at Propellor/Types.hs:175:10
instance Requires
(Property HasInfo) (Property HasInfo) (Property HasInfo)
-- Defined at Propellor/Types.hs:167:10
Possible fix:
add an instance declaration for
(Requires x0 (Property HasInfo) (Property HasInfo))
In the expression:
(foo `requires` bar `requires` bar) :: Property HasInfo
In an equation for `it':
it = (foo `requires` bar `requires` bar) :: Property HasInfo
*Propellor.Types> (((foo `requires` bar) :: Property HasInfo) `requires` bar) :: Property HasInfo
property "foo"
Yuggh!
|
|
Not yet used
|
|
|
|
Properties now form a tree, instead of the flat list used before.
This simplifies propigation of Info from the Properties used inside a
container to the outer host; the Property that docks the container on the
host can just have as child properties all the inner Properties, and their
Info can then be gathered recursively. (Although in practice it still needs
to be filtered, since not all Info should propigate out of a container.)
Note that there is no change to how Properties are actually satisfied.
Just because a Property lists some child properties, this does not mean
they always have their propertySatisfy actions run. It's still up to the
parent property to run those actions.
That's necessary so that a container's properties can be satisfied inside
it, not outside. It also allows property combinators to
add the combined Properties to their childProperties list, even if,
like onChange, they don't always run the child properties at all.
Testing: I tested that the exact same Info is calculated before and after
this change, for every Host in my config file.
|
|
SSHFP records.
|
|
|
|
|
|
|
|
|
|
|
|
Since the containers are no longer on the host list, they were not found
while provisioning, oops.
To fix, had to add to a host's info a map of the containers docked to it.
Unfortunately, that required Propellor.Types.Info be glommed into
Propellor.Types, since it needed to refer to Host.
|
|
The problem is it fell back to looking for an alias for the bad hostname,
but to get the aliases, it needs to know which hosts are docked where,
so looped.
|
|
|
|
|
|
|
