Tooling for package preparation¶

Some package formats may require additional tooling to prepare package ZIP archive of desired structure. In such cases it is expected that those tools will be provided by plug-in authors either as part of the same Python package (by exposing additional shell entry points) or as a separate package or distribution.

The only two exceptions to this rule are native MuranoPL packages and HOT packages that are built into Murano (there is no need to install additional plug-ins for them). Tooling for those two formats is a part of python-muranoclient.

Package API interface reference¶

Plug-ins expose API for the rest of Murano to interact with the package by implementing murano.packages.package.Package interface.

Class initializer:

def __init__(self, format_name, runtime_version, source_directory, manifest):

• format_name: name part of the format identifier (string)
• runtime_version: version part of the format identifier (instance of semantic_version.Version)
• source_directory: path to the directory where package content was extracted (string)
• manifest: contents of the manifest file (string->string dictionary)

Note: implementations must call base class (Package) initializer passing the first three of these arguments.

Abstract properties that must be implemented by the plug-in:

def full_name(self):

• Fully qualified name of the package. Must be unique within package scope of visibility (string)

def version(self):

• Package version (not to confuse with format version!). An instance of semantic_version.Version

def classes(self):

• List (or tuple) of MuranoPL class names (FQNs) that package contains

def requirements(self):

• Dictionary of requirements (dependencies on other packages) in a form of key-value mapping from required package FQN string to SemVer version range specifier (instance of semantic_version.Spec or string representation supported by Murano versioning scheme)

def package_type(self):

• Package type: “Application” or “Library”

def display_name(self):

• Human-readable name of the package as presented to the user (string)

def description(self):

• Package description (string or None)

def author(self):

• Package author (string or None)

def supplier(self):

• Package supplier (string or None)

def tags(self):

• List or tags for the package (list of strings)

def logo(self):

• Package (application) logo file content (str or None)

def supplier_logo(self):

• Package (application) supplier logo file content (str or None)

def ui(self):

• YAML-encoded string containing application’s form definition (string or None)

Abstract methods that must be implemented by the plug-in:

def get_class(self, name):

• Returns string containing MuranoPL code (YAML-encoded string) for the class whose fully qualified name is in “name” parameter (string)

def get_resource(self, name):

• Returns path for resource file whose name is in “name” parameter (string)

Properties that can be overridden in the plug-in:

def format_name(self):

• Canonical format name for the plug-in. Usually the same value that was passed to class initializer

def runtime_version(self):

• Format version. Usually the same value that was passed to class initializer (semantic_version.Version)

def blob(self):

• Package file (.zip) content (str)

PackageBase class¶

Usually, there is no need to manually implement all the methods and properties described. There is a murano.packages.package.PackageBase class that provides typical implementation of most of required properties by obtaining corresponding value from manifest file.

When inheriting from PackageBase class, plug-in remains responsible for implementation of:

• ui property
• classes property
• get_class method

This allows plug-in developers to concentrate on dynamic aspects of the package type plug-in while keeping all static aspects (descriptions, logos and so on) consistent across all package types (at least those who inherit from PackageBase).