def store(self):
self._data.extend(self._new_data)
metadata = get_project_metadata(find_project_basedir('.'))
metadata.update({'messages': list(self._data)})
with open(os.path.join(find_project_basedir('.'), '.leapp/info'),
'w') as f:
json.dump(metadata, f, indent=2)
def cli(args):
base_dir = find_project_basedir('.')
repository = scan_repo(base_dir)
repository.load()
actors = [actor for actor in repository.actors]
models = [model for model in get_models() if _is_local(base_dir, model)]
topics = [topic for topic in get_topics() if _is_local(base_dir, topic)]
tags = [tag for tag in get_tags() if _is_local(base_dir, tag)]
if not args.json:
_print_group('Models', models)
_print_group('Topics', topics)
_print_group('Actors',
actors,
name_resolver=lambda x: x.class_name,
path_resolver=_get_actor_path)
_print_group('Tags', tags)
else:
output = {
'project': get_project_name(base_dir),
'base_dir': base_dir,
'topics':
{topic.__name__: _get_topic_details(topic)
for topic in topics},
'models':
{model.__name__: _get_model_details(model)
for model in models},
'actors':
{actor.class_name: _get_actor_details(actor)
for actor in actors},
'tags': {tag.name: _get_tag_details(tag)
for tag in tags}
}
json_mod.dump(output, sys.stdout, indent=2)
def cli(args):
basedir = find_project_basedir('.')
if not basedir:
raise UsageError(
'This command must be executed from the project directory')
basedir = os.path.join(basedir, 'tags')
if not os.path.isdir(basedir):
os.mkdir(basedir)
tag_path = os.path.join(basedir, args.tag_name.lower() + '.py')
if os.path.exists(tag_path):
raise UsageError("File already exists: {}".format(tag_path))
with open(tag_path, 'w') as f:
f.write('''from leapp.tags import Tag
class {tag_name}Tag(Tag):
name = '{tag}'
'''.format(tag_name=make_class_name(args.tag_name),
tag=make_name(args.tag_name)))
sys.stdout.write("New tag {} has been created in {}\n".format(
make_class_name(args.tag_name), os.path.realpath(tag_path)))
def cli(params):
configure_logger()
repository = scan_repo(find_project_basedir('.'))
repository.load()
for wf in leapp.workflows.get_workflows():
if wf.name.lower() == params.name.lower():
wf().run(until_phase=params.until_phase, until_actor=params.until_actor)
def cli(args):
class_name = args.class_name
short_name = args.short_name
name = args.name
base_dir = find_project_basedir('.')
workflows_dir = os.path.join(base_dir, 'workflows')
class_name = class_name or make_class_name(name)
short_name = short_name or make_name(name)
if not os.path.exists(workflows_dir):
os.mkdir(workflows_dir)
workflow_path = os.path.join(workflows_dir, make_name(name) + '.py')
if not os.path.exists(workflow_path):
with open(workflow_path, 'w') as f:
f.write(
"""from leapp.workflows import Workflow, Phase, Flags, Filter, Policies
from leapp.tags import FactsTag, {workflow_class}Tag, CommonFactsTag, ChecksTag, CommonChecksTag
class {workflow_class}Workflow(Workflow):
name = '{workflow_name}'
tag = {workflow_class}Tag
short_name = '{workflow_short_name}'
description = '''No description has been provided for the {workflow_name} workflow.'''
class FactsCollection(Phase):
name = 'Facts collection'
filter = Filter(
tags=(({workflow_class}Tag, FactsTag),
(CommonFactsTag,)))
policies = Policies(
error=Policies.Errors.FailPhase,
retry=Policies.Retry.Phase)
flags = Flags()
class Checks(Phase):
name = 'Checks'
filter = Filter(
tags=(({workflow_class}Tag, ChecksTag),
(CommonChecksTag,)))
policies = Policies(
error=Policies.Errors.FailPhase,
retry=Policies.Retry.Phase)
flags = Flags()
""".format(workflow_name=name,
workflow_class=class_name,
workflow_short_name=short_name))
def cli(args):
log = configure_logger()
basedir = find_project_basedir('.')
repository = scan_repo(basedir)
repository.load()
messaging = ProjectLocalMessaging()
messaging.load()
actor_logger = log.getChild('actors')
repository.lookup_actor(args.actor_name)(messaging=messaging, logger=actor_logger).run()
if args.save_output:
messaging.store()
if args.print_output:
json.dump(messaging.get_new(), sys.stdout, indent=2)
def cli(args):
class_name = args.class_name
short_name = args.short_name
name = args.name
base_dir = find_project_basedir('.')
workflows_dir = os.path.join(base_dir, 'workflows')
class_name = class_name or make_class_name(name)
short_name = short_name or make_name(name)
if not os.path.exists(workflows_dir):
os.mkdir(workflows_dir)
workflow_path = os.path.join(workflows_dir, make_name(name) + '.py')
if not os.path.exists(workflow_path):
with open(workflow_path, 'w') as f:
f.write("""from leapp.workflows import Workflow
from leapp.workflows.phases import Phase
from leapp.workflows.flags import Flags
from leapp.workflows.filters import Filter
from leapp.workflows.tagfilters import TagFilter
from leapp.workflows.policies import Policies
from leapp.tags import {workflow_class}Tag
class {workflow_class}Workflow(Workflow):
name = '{workflow_name}'
tag = {workflow_class}Tag
short_name = '{workflow_short_name}'
description = '''No description has been provided for the {workflow_name} workflow.'''
# Template for phase definition - The order in which the phase classes are defined
# within the Workflow class represents the execution order
#
# class PhaseName(Phase):
# name = 'phase_name'
# filter = TagFilter(PhaseTag)
# policies = Policies(Policies.Errors.FailPhase,
# Policies.Retry.Phase)
# flags = Flags()
""".format(workflow_name=name, workflow_class=class_name, workflow_short_name=short_name))
sys.stdout.write("New workflow {} has been created in {}\n".format(class_name,
os.path.realpath(workflow_path)))
def cli(args):
model_name = args.model_name
basedir = find_project_basedir('.')
basedir = os.path.join(basedir, 'models')
if not os.path.isdir(basedir):
os.mkdir(basedir)
model_path = os.path.join(basedir, model_name.lower() + '.py')
if os.path.exists(model_path):
raise UsageError("File already exists: {}".format(model_path))
with open(model_path, 'w') as f:
f.write('''from leapp.models import Model, fields
class {model_name}(Model):
topic = None # TODO: import appropriate topic and set it here
'''.format(model_name=make_class_name(model_name)))
sys.stdout.write("New model {} has been created in {}\n".format(
make_class_name(model_name), os.path.realpath(model_path)))
def cli(args):
actor_name = args.actor_name
basedir = find_project_basedir('.')
actors_dir = os.path.join(basedir, 'actors')
if not os.path.isdir(actors_dir):
os.mkdir(actors_dir)
actor_dir = os.path.join(actors_dir, actor_name.lower())
if not os.path.isdir(actor_dir):
os.mkdir(actor_dir)
actor_test_dir = os.path.join(actor_dir, 'tests')
if not os.path.isdir(actor_test_dir):
os.mkdir(actor_test_dir)
actor_path = os.path.join(actor_dir, 'actor.py')
if os.path.exists(actor_path):
raise UsageError("File already exists: {}".format(actor_path))
with open(actor_path, 'w') as f:
f.write('''from leapp.actors import Actor
class {actor_class}(Actor):
name = '{actor_name}'
description = 'For the actor {actor_name} has been no description provided.'
consumes = ()
produces = ()
tags = ()
def process(self):
pass
'''.format(actor_class=make_class_name(actor_name),
actor_name=make_name(actor_name)))
sys.stdout.write("New actor {} has been created at {}\n".format(
make_class_name(actor_name), os.path.realpath(actor_path)))
def cli(args):
topic_name = args.topic_name
basedir = find_project_basedir('.')
basedir = os.path.join(basedir, 'topics')
if not os.path.isdir(basedir):
os.mkdir(basedir)
topic_path = os.path.join(basedir, topic_name.lower() + '.py')
if os.path.exists(topic_path):
raise UsageError("File already exists: {}".format(topic_path))
topic_path = os.path.join(basedir, topic_name.lower() + '.py')
with open(topic_path, 'w') as f:
f.write('''from leapp.topics import Topic
class {topic_name}Topic(Topic):
name = '{topic}'
'''.format(topic_name=make_class_name(topic_name),
topic=make_name(topic_name)))
sys.stdout.write("New topic {} has been created in {}\n".format(
make_class_name(topic_name), os.path.realpath(topic_path)))
def _get_class_file(cls, project_relative=True):
path = os.path.abspath(sys.modules[cls.__module__].__file__.replace(
'.pyc', '.py'))
return os.path.relpath(
path,
find_project_basedir('.') if project_relative else os.getcwd())
def _get_actor_path(actor, project_relative=True):
path = actor.directory
return os.path.relpath(
path,
find_project_basedir('.') if project_relative else os.getcwd())
def load(self):
self._data = self._manager.list(
get_project_metadata(find_project_basedir('.'))['messages'])
def cli(args, extra):
load_all_from(find_project_basedir('.'))
wf = leapp.workflows.IPUWorkflow()
print(wf.initial, wf.consumes, wf.produces)
json.dump(names(wf.phase_actors), sys.stdout, indent=2)
sys.stdout.write('\n')
