inmanta-module-std 5.2.8__tar.gz → 8.3.0__tar.gz

{inmanta_module_std-5.2.8 → inmanta_module_std-8.3.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.2
 Name: inmanta-module-std
-Version: 5.2.8
+Version: 8.3.0
 License: Apache 2.0
 Requires-Dist: Jinja2<4,>=3.1
 Requires-Dist: email_validator<3,>=1.3
 Requires-Dist: pydantic<3,>=1.10
-Requires-Dist: inmanta-core<14,>=8.7.0.dev
+Requires-Dist: inmanta-core>=8.7.0.dev

{inmanta_module_std-5.2.8 → inmanta_module_std-8.3.0}/README.md

@@ -1,4 +1,4 @@
-# std Module
+# std module
 
 Inmanta base module that defines primitive types, entities and plugins regularly used when developing models.
 
@@ -42,7 +42,7 @@ class EntitlementResource(inmanta.resources.PurgeableResource):
     pass
 ```
 
-More information about developing Python Resources and Handlers can be found [here](https://docs.inmanta.com/inmanta-service-orchestrator/7/model_developers/handlers.html#handler).
+More information about developing Python Resources and Handlers can be found [here](https://docs.inmanta.com/inmanta-service-orchestrator/latest/model_developers/handlers.html#handler).
 
 Another example would be to define a new resource that can be created / updated / removed. The following example is really basic
 and should probably not be implemented, an inventory would be better for that. But for the sake of a basic example, let's suppose that

{inmanta_module_std-5.2.8 → inmanta_module_std-8.3.0}/inmanta_module_std.egg-info/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.2
 Name: inmanta-module-std
-Version: 5.2.8
+Version: 8.3.0
 License: Apache 2.0
 Requires-Dist: Jinja2<4,>=3.1
 Requires-Dist: email_validator<3,>=1.3
 Requires-Dist: pydantic<3,>=1.10
-Requires-Dist: inmanta-core<14,>=8.7.0.dev
+Requires-Dist: inmanta-core>=8.7.0.dev

{inmanta_module_std-5.2.8 → inmanta_module_std-8.3.0}/inmanta_module_std.egg-info/SOURCES.txt

@@ -17,14 +17,11 @@ inmanta_plugins/std/model/testing.cf
 inmanta_plugins/std/templates/host_uri.j2
 tests/test_agent.py
 tests/test_agentconfig.py
-tests/test_facts.py
-tests/test_file.py
 tests/test_get_attribute.py
-tests/test_in_docker.py
-tests/test_model.py
 tests/test_mutables.py
 tests/test_plugins.py
-tests/test_resources.py
+tests/test_reference.py
+tests/test_resource.py
 tests/test_template.py
 tests/test_types.py
 tests/test_unknown.py

{inmanta_module_std-5.2.8 → inmanta_module_std-8.3.0}/inmanta_module_std.egg-info/requires.txt

@@ -1,4 +1,4 @@
 Jinja2<4,>=3.1
 email_validator<3,>=1.3
 pydantic<3,>=1.10
-inmanta-core<14,>=8.7.0.dev
+inmanta-core>=8.7.0.dev

{inmanta_module_std-5.2.8 → inmanta_module_std-8.3.0}/inmanta_plugins/std/__init__.py

@@ -1,25 +1,26 @@
 """
-    Copyright 2016 Inmanta
+Copyright 2016 Inmanta
 
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
 
-        http://www.apache.org/licenses/LICENSE-2.0
+    http://www.apache.org/licenses/LICENSE-2.0
 
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
 
-    Contact: code@inmanta.com
+Contact: code@inmanta.com
 """
 
 import base64
 import hashlib
 import importlib
 import ipaddress
+import json
 import logging
 import os
 import random
@@ -39,6 +40,8 @@ from jinja2.runtime import Undefined, missing
 
 # don't bind to `resources` because this package has a submodule named resources that will bind to `resources` when imported
 import inmanta.resources
+from inmanta import util
+from inmanta.agent.handler import LoggerABC
 from inmanta.ast import NotFoundException, OptionalValueException, RuntimeException
 from inmanta.config import Config
 from inmanta.execute.proxy import DynamicProxy, UnknownException
@@ -549,21 +552,16 @@ def type(obj: "any") -> "any":
 
 
 @plugin
-def sequence(i: "int", start: "int" = 0, offset: "int" = 0) -> "list":
+def sequence(i: "int", start: "int" = 0) -> "list":
     """
     Return a sequence of i numbers, starting from zero or start if supplied.
 
     :param i: The number of elements in the sequence.
     :param start: The starting value for the sequence.
-    :param offset: [Deprecated] An offset value (this parameter will be removed in the future).
 
     :return: A list containing the sequence of ints.
     """
-    if offset != 0:
-        logging.getLogger(__name__).warning(
-            "The 'offset' parameter in the 'sequence' plugin is deprecated and will be removed in a future version."
-        )
-    return list(range(start, int(i) + start - offset))
+    return list(range(start, int(i) + start))
 
 
 @plugin
@@ -976,25 +974,40 @@ def server_port() -> "int":
 
 
 @plugin
-def get_env(name: "string", default_value: "string" = None) -> "string":
-    env = os.environ
-    if name in env:
-        return env[name]
-    elif default_value is not None:
-        return default_value
-    else:
-        return Unknown(source=name)
+def get_env(name: "string", default_value: "string?" = None) -> "string":
+    """
+    Get an environment variable, return Unknown if it doesn't exist.
+    Also log a warning to show the missing environment variable.
 
+    :param key: The name of the environment variable to get
+    """
+    val = os.getenv(name, default_value)
+    if val is not None:
+        return val
 
+    logging.getLogger(__name__).warning(
+        "Environment variable %s doesn't exist, returning Unknown(source=%s) instead",
+        name,
+        repr(name),
+    )
+    return Unknown(source=name)
+
+
+@deprecated(replaced_by="int(std::get_env(...))")
 @plugin
-def get_env_int(name: "string", default_value: "int" = None) -> "int":
-    env = os.environ
-    if name in env:
-        return int(env[name])
-    elif default_value is not None:
-        return default_value
-    else:
-        return Unknown(source=name)
+def get_env_int(name: "string", default_value: "int?" = None) -> "int":
+    # This plugin will remain, but it is recommended to use getenv
+    # instead
+    val: str | int | None = os.getenv(name, default_value)
+    if val is not None:
+        return int(val)
+
+    logging.getLogger(__name__).warning(
+        "Environment variable %s doesn't exist, returning Unknown(source=%s) instead",
+        name,
+        repr(name),
+    )
+    return Unknown(source=name)
 
 
 @plugin
@@ -1073,15 +1086,6 @@ def invert(value: "bool") -> "bool":
     return not value
 
 
-@deprecated
-@plugin
-def to_number(value: "any") -> "number":
-    """
-    Convert a value to a number
-    """
-    return int(value)
-
-
 @plugin
 def list_files(ctx: Context, path: "string") -> "list":
     """
@@ -1290,3 +1294,73 @@ def ip_address_from_interface(
     :param ip_interface: The interface from where we will extract the ip address
     """
     return str(ipaddress.ip_interface(ip_interface).ip)
+
+
+@plugin
+def json_loads(s: "string") -> "any":
+    """
+    Deserialize s (a string instance containing a JSON document) to an inmanta dsl object.
+
+    :param s: The serialized json string to parse.
+    """
+    return json.loads(s)
+
+
+@plugin
+def json_dumps(obj: "any") -> "string":
+    """
+    Serialize obj to a JSON formatted string.
+
+    :param obj: The inmanta object that should be serialized as json.
+    """
+    return json.dumps(obj, default=util.internal_json_encoder)
+
+
+@plugin
+def format(__string: "string", *args: "any", **kwargs: "any") -> "string":
+    """
+    Format a string using python string formatter, and accepting statements which
+    native inmanta f-string doesn't support (such as accessing dict values)
+
+    :param __string: The string to apply formatting to
+    :param args: The positional arguments to feed into the `str.format` method
+    :param kwargs: The keyword arguments to feed into the `str.format` method
+    """
+    return __string.format(*args, **kwargs)
+
+
+try:
+    from inmanta.references import Reference, reference
+
+    @reference("std::Environment")
+    class EnvironmentReference(Reference[str]):
+        """A reference to fetch environment variables"""
+
+        def __init__(self, name: str | Reference[str]) -> None:
+            """
+            :param name: The name of the environment variable.
+            """
+            super().__init__()
+            self.name = name
+
+        def resolve(self, logger: LoggerABC) -> str:
+            """Resolve the reference"""
+            env_var_name = self.resolve_other(self.name, logger)
+            logger.debug("Resolving environment variable %(name)s", name=self.name)
+            value = os.getenv(env_var_name)
+            if value is None:
+                raise LookupError(f"Environment variable {env_var_name} is not set")
+            return value
+
+    @plugin
+    def create_environment_reference(name: str | Reference[str]) -> Reference[str]:
+        """Create an environment reference
+
+        :param name: The name of the variable to fetch from the environment
+        :return: A reference to what can be resolved to a string
+        """
+        return EnvironmentReference(name=name)
+
+except ImportError:
+    # Reference are not yet supported by this core version
+    pass

{inmanta_module_std-5.2.8 → inmanta_module_std-8.3.0}/inmanta_plugins/std/model/_init.cf

@@ -103,7 +103,7 @@ typedef ipv_any_network as string matching std::validate_type("pydantic.IPvAnyNe
 """
     A string matching the requiremenst of ipv4_network or ipv6_network.
 """
-typedef negative_float as number matching std::validate_type("pydantic.NegativeFloat", self)
+typedef negative_float as float matching std::validate_type("pydantic.NegativeFloat", self)
 """
     A floating point number less than zero.
 """
@@ -111,7 +111,7 @@ typedef negative_int as int matching std::validate_type("pydantic.NegativeInt",
 """
     A integer number less than zero.
 """
-typedef positive_float as number matching std::validate_type("pydantic.PositiveFloat", self)
+typedef positive_float as float matching std::validate_type("pydantic.PositiveFloat", self)
 """
     A floating point number greater than zero.
 """
@@ -212,6 +212,25 @@ entity ManagedDevice:
     hoststring  name
 end
 
+entity Dataclass:
+    """ 
+        Super class for inmanta entities that have a python counterpart.
+
+        The python counterpart is expect to be 
+        - a frozen dataclass,
+        - with the same name 
+        - in the plugins package of this module
+        - in the corresponding submodule
+        - with the exact same fields 
+
+        The Inmanta entity is expect to
+        - have no relations
+        - have no indexes
+        - have only std::none as implementation
+
+    """
+end
+
 entity Host extends ManagedDevice:
     """
         A host models a server or computer in the managed infrastructure that
@@ -234,183 +253,6 @@ index Host(name)
 
 typedef hoststring as string matching /^[A-Za-z0-9-]+(\.[A-Za-z0-9-]+)*$/
 
-entity Reload extends Resource:
-    """
-        An entity to make the (old) reload mechanism compatible with the event mechanism
-
-        :attr reload: If a service requires this file, reload or restart the service when this file
-                      changes.
-    """
-    bool reload=false
-    bool send_event=undef
-end
-
-implementation reload for Reload:
-    self.send_event=self.reload
-end
-
-entity File extends Reload, PurgeableResource:
-    """
-        This represents a file on the filesystem
-
-        :attr path: The path of the file
-        :attr mode: The permissions of the file
-        :attr owner: The owner of the file
-        :attr group: The group of the file
-        :attr content: The file contents
-    """
-    string path
-    int mode
-    string owner
-    string group
-    string content
-    bool purge_on_delete=false
-    bool send_event=undef
-    string content_seperator="\n"
-end
-
-implement File using reload, fileHost
-
-entity Content:
-    """
-        A content block as a prefix or suffix to a file. This blocks are only merged with the content at export time. This
-        is an advanced pattern that can be used to speed up the compilation in very specific use cases.
-
-        :attr sorting_key: The key to use to sort the content blocks in the same list. When this attribute is not set
-                           value is used as sorting key.
-        :attr value: The value to prepend or append
-    """
-    string? sorting_key=null
-    string value
-end
-
-implement Content using std::none
-
-File.prefix_content [0:] -- Content
-File.suffix_content [0:] -- Content
-
-entity ConfigFile extends File:
-    """
-        A file with often used defaults for configuration files.
-    """
-    int mode=644
-    string owner="root"
-    string group="root"
-end
-
-implement ConfigFile using reload, fileHost
-
-File.host [1] -- Host.files [0:]
-
-index File(host, path)
-
-implementation fileHost for File:
-    self.requires = self.host.requires
-end
-
-# the state of a service
-typedef service_state as string matching self == "running" or self == "stopped"
-
-# a service that is managed
-entity Service extends Reload:
-    """
-        Manage a service on a host.
-
-        :attr name: The name of the service to manage
-        :attr state: The desired state of the service. Valid values are 'running' or 'stopped'
-        :attr onboot: Should the service start on boot.
-    """
-    string name
-    service_state state
-    bool onboot
-end
-
-implement Service using reload, serviceHost
-
-Service.host [1] -- Host.services [0:]
-
-index Service(host, name)
-
-implementation serviceHost for Service:
-    self.requires = self.host.requires
-end
-
-# the state of a package
-typedef package_state as string matching self == "installed" or self == "removed" or self == "latest"
-
-entity Package extends Reload:
-    """
-        A software package installed on a managed device.
-
-        :attr name: The name of the package to manage
-        :attr state: The state of the package. Valid values are 'installed', 'removed' or 'latest'.
-                     latest will upgrade the package when an update is available.
-    """
-    string name
-    package_state state
-end
-
-implement Package using reload, pkgHost
-
-Host.packages [0:] -- Package.host [1]
-
-index Package(host, name)
-
-implementation pkgHost for Package:
-    self.requires = self.host.requires
-end
-
-# a directory
-entity Directory extends Reload, PurgeableResource:
-    """
-        A directory on the filesystem
-    """
-    string path
-    int mode
-    string owner
-    string group
-    bool purge_on_delete=false
-end
-
-implement Directory using reload, dirHost
-
-entity DefaultDirectory extends Directory:
-    """
-        A directory that is world readable. It is also writable for its owner root.
-    """
-    int mode=755
-    string owner="root"
-    string group="root"
-end
-
-implement DefaultDirectory using reload, dirHost
-
-Host.directories [0:] -- Directory.host [1]
-
-index Directory(host, path)
-
-implementation dirHost for Directory:
-    self.requires = self.host.requires
-end
-
-# symlink
-entity Symlink extends Reload, PurgeableResource:
-    """
-        A symbolic link on the filesystem
-    """
-    string source
-    string target
-    bool purge_on_delete=false
-    bool send_event=undef
-end
-
-implement Symlink using std::reload, symHost
-
-Host.symlinks [0:] -- Symlink.host [1]
-
-implementation symHost for Symlink:
-    self.requires = self.host.requires
-end
 
 # define operating systems
 unix = OS(name = "unix")
@@ -431,7 +273,7 @@ entity OS:
         :attr python_cmd: Specifies what command should be used to launch the python interpreter on the other end
     """
     string name
-    number version = 0.0
+    float version = 0.0
     string? python_cmd = "python"
 end
 
@@ -558,15 +400,15 @@ end
 implement MutableString using std::none
 
 
-entity MutableNumber:
+entity MutableInt:
     """
-Wrapper for number values, used to pass a number out of an if statement or to
-use relations to create a mutuable set of numbers.
+Wrapper for int values, used to pass a int out of an if statement or to
+use relations to create a mutuable set of int.
 
 :Example:
 .. code-block:: inmanta
 
-    attr_a = std::MutableNumber()
+    attr_a = std::MutableInt()
     if some_condition:
         attr_a.value = 3
     else:
@@ -579,59 +421,71 @@ use relations to create a mutuable set of numbers.
     entity Test:
     end
 
-    Test.string_list [0:] -- std::MutableNumber
+    Test.string_list [0:] -- std::MutableInt
 
     a = Test()
-    a.string_list += std::MutableNumber(value=3)
-    a.string_list += std::MutableNumber(value=7)
+    a.string_list += std::MutableInt(value=3)
+    a.string_list += std::MutableInt(value=7)
 """
-  number? value
+  int? value
 end
 
-implement MutableNumber using std::none
+implement MutableInt using std::none
 
 
-entity MutableBool:
+entity MutableFloat:
     """
-Wrapper for boolean values, used to pass a boolean out of an if statement.
+Wrapper for float values, used to pass a float out of an if statement or to
+use relations to create a mutable set of float.
 
 :Example:
 .. code-block:: inmanta
 
-    attr_a = std::MutableBool()
+    attr_a = std::MutableFloat()
     if some_condition:
-        attr_a.value = True
+        attr_a.value = 3.0
     else:
-        attr_a.value = Null
+        attr_a.value = 4.0
+    end
+
+:Example:
+.. code-block:: inmanta
+
+    entity Test:
     end
 
+    Test.string_list [0:] -- std::MutableFloat
+
+    a = Test()
+    a.string_list += std::MutableFloat(value=3.0)
+    a.string_list += std::MutableFloat(value=7.0)
 """
-  bool? value
+  float? value
 end
 
-implement MutableBool using std::none
+implement MutableFloat using std::none
 
 
-entity Packages:
-    """ Defined the state for multiple packages at once
-
-        :param name: A list of package names
-        :param state: The state of the package
+entity MutableBool:
     """
-    string[] name
-    std::package_state state="installed"
-end
-
-Packages.host [1] -- std::Host
+Wrapper for boolean values, used to pass a boolean out of an if statement.
 
-implement Packages using pkgs
+:Example:
+.. code-block:: inmanta
 
-implementation pkgs for Packages:
-    for pkg in name:
-      std::Package(host=self.host, name=pkg, state=self.state, requires=self.requires, provides=self.provides)
+    attr_a = std::MutableBool()
+    if some_condition:
+        attr_a.value = True
+    else:
+        attr_a.value = Null
     end
+
+"""
+  bool? value
 end
 
+implement MutableBool using std::none
+
 entity ResourceSet:
     """
     A ResourceSet describes resources that logically belong together,

{inmanta_module_std-5.2.8 → inmanta_module_std-8.3.0}/inmanta_plugins/std/model/testing.cf

@@ -21,15 +21,17 @@ entity NullResource extends ManagedResource, PurgeableResource:
         A resource that does nothing, for use in tests and examples
 
         :attr name: the name of this resource
+        :attr value: a value this resource can cary, has no purpose
         :attr agentname: the name of the agent to deploy this resource on
         :attr fail: when true, this resource will always fail on both dryrun and deploy
     """
     string name = "null"
     string agentname = "internal"
+    string value = ""
     bool send_event = true
     bool fail = false
 end
 
 index NullResource(agentname, name)
 
-implement NullResource using std::none
+implement NullResource using std::none