sprinter Package

directory Module

directory.py stores methodology to install various files and packages to different locations.

class sprinter.directory.Directory(namespace=None)

Bases: object

add_to_rc(content)

add content to the rc script.

bin_path()

return the bin directory path

config_path()

return writable handle to config file

install_directory(feature_name)

return a path to the install directory that the feature should install to.

lib_path()

return the lib directory path

symlink_to_bin(name, path)

Symlink an object at path to name in the bin folder. remove it if it already exists.

symlink_to_lib(name, path)

Symlink an object at path to name in the lib folder. remove it if it already exists.

environment Module

A module that completely encapsulates a class. This should be a complete object representing any data needed by recipes.

class sprinter.environment.Environment(namespace=None, logger=None, logging_level=20)

Bases: object

activate()

activate environment specific injections

add_to_rc(content)

clear(filename)

commit_injections(filename, content)

context()

get a context dictionary to replace content

deactivate()

deactivate environments

destroys()

finalize()

command to run at the end of sprinter’s run

get_config(param_name, default=None, temporary=False)

grab_inputs()

inject(filename, content)

install_directory(feature_name)

isDebianBased()

isFedoraBased()

isLinux()

isOSX()

load_manifest(target_manifest, source_manifest=None)

load_namespace(namespace=None)

load_target_implicit()

rc_path()

recipe_dict = {}

reloads()

setups()

symlink_to_bin(name, path)

symlink_to_lib(name, path)

updates()

validate()

validate_context(content)

check if all the config variables desired exist, and prompt them if not

injections Module

Injections.py handles injections into various configuration files throughout files on the file system. These operations are batched and applied together.

class sprinter.injections.Injections(wrapper)

Bases: object

Injections are staged until they are committed with the commit() method. This allow for aggregations until the commiting is ready to be performed.

clear(filename)

add the file to the list of files to clear

clear_dict = set([])

commit()

commit the injections desired, overwriting any previous injections in the file.

inject(filename, content)

add the injection content to the dictionary

inject_dict = {}

logger = None

wrapper = None

install Module

The install script for a sprinter-based setup script.

sprinter.install.main()

lib Module

Library module for sprinter. To handle a lot of the typical features of the library.

sprinter.lib.call(command)

sprinter.lib.get_recipe_class(recipe, environment)

Get the recipe name and return an instance The recipe path is a path to the module. get_recipe_class performs reflection to find the first class that extends recipebase, and that is the class that an instance of it gets returned.

>>> issubclass(get_recipe_class("sprinter.recipes.unpack").__class__, RecipeBase)
True

sprinter.lib.prompt(prompt_string, default=None, secret=False)

Prompt user for a string, with a default value

manifest Module

manifest.py is a utility class to help determine version differences in sprinter apps.

example manifest sections look like: [FEATURE] version = {{ manifest_version }} {{ configuration vars }}

class sprinter.manifest.Manifest(target_manifest=None, source_manifest=None, namespace=None)

Bases: object

Class to represent a manifest object

>>> m.namespace
'sprinter'

activations()

Return a dictionary of activation recipes.

>>> m.activations()
{'myrc': {'target': {'recipe': 'sprinter.recipes.template'}}}

config = {}

deactivations()

Return a dictionary of activation recipes.

>>> m.activations()
{'myrc': {'target': {'recipe': 'sprinter.recipes.template'}}}

destroys()

Return a dictionary with all the features that need to be destroyed. >>> m.destroys() {‘mysql’: {‘source’: {‘brew’: ‘mysql’, ‘apt-get’: ‘libmysqlclientnlibmysqlclient-dev’, ‘recipe’: ‘sprinter.recipes.package’}}}

get_config(param_name, default=None, secret=False)

grabs a config from the user space; if it doesn’t exist, it will prompt for it.

get_context_dict()

return a context dict of the desired state

grab_inputs()

Look for any inputs not already asked accounted for, and query the user for them.

load_source(source_manifest)

reload the source manifest

load_target(target_manifest)

reload the source manifest

load_target_implicit()

Attempt an implicit load of a target file. An implicit load involves looking at source manifest’s config:source parameter and attempting to load from there. If that’s not possible, false is returned.

reloads()

return reload dictionaries

setups()

Return a dictionary with all the features that need to be setup. >>> m.setups() {‘myrc’: {‘target’: {‘recipe’: ‘sprinter.recipes.template’}}}

source_manifest = <ConfigParser.RawConfigParser instance at 0x10c8e9f38>

source_sections()

return all source sections except for reserved ones

target_manifest = None

target_sections()

return all target sections except for reserved ones

temporary_sections = []

updates()

Return a dictionary with all the features that need to be updated.

>>> m.updates()
{'maven': {'source': {'recipe': 'sprinter.recipes.unpack', 'specific_version': '2.10'}, 'target': {'recipe': 'sprinter.recipes.unpack', 'specific_version': '3.0.4'}}}

>>> m_old_only.updates()
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ManifestError: Update method requires a target manifest!

validate()

Checks validity of manifest files.

write(file_handle)

write the current state to a file manifest

exception sprinter.manifest.ManifestError

Bases: exceptions.Exception

recipebase Module

Recipe base is an abstract base class outlining the method required and some documentation on what they should provide.

class sprinter.recipebase.RecipeBase(environment)

Bases: object

activate(feature_name, config)

function to run when activating

deactivate(feature_name, config)

tasks to run when deactivating

destroy(feature_name, old_config)

Destroys an old feature if it is no longer required

reload(feature_name, config)

tasks to call when reloading

setup(feature_name, config)

Setup performs the setup required, with the config specified

update(feature_name, config)

Setup performs the setup required, and works with the old config is destruction is required

recipestandard Module

Recipe base is an abstract base class outlining the method required and some documentation on what they should provide.

class sprinter.recipestandard.RecipeStandard(environment)

Bases: sprinter.recipebase.RecipeBase

destroy(feature_name, config)

Destroys an old feature if it is no longer required

setup(feature_name, config)

Setup performs the setup required, with the config specified

update(feature_name, config)

Setup performs the setup required, and works with the old config is destruction is required

Subpackages

• recipes Package
  • command Module
  • env Module
  • git Module
  • package Module
  • perforce Module
  • ssh Module
  • template Module
  • unpack Module