Example #1
0
def run_load_fabfile(path, sys_path):
    # Module-esque object
    fake_module = Fake().has_attr(__dict__={})
    # Fake __import__
    importer = Fake(callable=True).returns(fake_module)
    # Snapshot sys.path for restore
    orig_path = copy.copy(sys.path)
    # Update with fake path
    sys.path = sys_path
    # Test for side effects
    load_fabfile(path, importer=importer)
    eq_(sys.path, sys_path)
    # Restore
    sys.path = orig_path
Example #2
0
def load_tests(loader, suite, patterns):
    """
    Custom test loader for functional tests
    """

    # Try to add vagrant functional tests
    from .vagrant import base_boxes, VagrantFunctionTestCase, VagrantTestSuite
    boxes = base_boxes()
    if boxes:
        vagrant_suite = VagrantTestSuite(boxes)

        # Add a test case for each task in each fabfile
        fabfiles = os.path.join(os.path.dirname(__file__), 'fabfiles')
        for filename in sorted(os.listdir(fabfiles)):
            if fnmatch.fnmatch(filename, '[!_]*.py'):
                fabfile = os.path.join(fabfiles, filename)
                _, tasks, _ = load_fabfile(fabfile)
                for task in tasks.values():
                    test = VagrantFunctionTestCase(task,
                                                   description=short_doc(task))
                    vagrant_suite.addTest(test)

        suite.addTest(vagrant_suite)

    return suite
Example #3
0
def ec2_fab(service, args):
    """
    Run Fabric commands against EC2 instances
    """
    instance_ids = args.instances
    instances = service.list(elb=args.elb, instance_ids=instance_ids)
    hosts = service.resolve_hosts(instances)

    fab.env.hosts = hosts
    fab.env.key_filename = settings.get('SSH', 'KEY_FILE')
    fab.env.user = settings.get('SSH', 'USER', getpass.getuser())
    fab.env.parallel = True

    fabfile = find_fabfile(args.file)
    if not fabfile:
        print 'Couldn\'t find any fabfiles!'
        return

    fab.env.real_fabile = fabfile
    docstring, callables, default = load_fabfile(fabfile)
    fab_state.commands.update(callables)

    commands_to_run = parse_arguments(args.methods)
    for name, args, kwargs, arg_hosts, arg_roles, arg_exclude_hosts in commands_to_run:
        fab.execute(name,
                    hosts=arg_hosts,
                    roles=arg_roles,
                    exclude_hosts=arg_exclude_hosts,
                    *args,
                    **kwargs)
Example #4
0
def cli_command_list(args):
    """
  Runs task from deploy file
  """

    filepath = args.get('filename')
    task_name = args.get('task')

    if filepath:
        fullpath = os.path.join(os.path.realpath(os.curdir), filepath)
        docstring, callables, default = load_fabfile(fullpath)

        if not docstring == None:
            print(docstring.rstrip('\n'))

        print('\nAvailable commands:\n')

        for task_name in callables:
            task_desc = callables.get(task_name).__doc__

            if not task_desc == None:
                description = task_desc.lstrip('\n').rstrip('\n')
            else:
                description = '\n'

            print('%s   %s' % (green(task_name), description))
def load_tests(loader, suite, patterns):
    """
    Custom test loader for functional tests
    """

    # Optional include/exclude list of fabfiles
    include_files = os.environ.get('FABTOOLS_TEST_INCLUDE', '').split()
    exclude_files = os.environ.get('FABTOOLS_TEST_EXCLUDE', '').split()

    # Try to add vagrant functional tests
    from .vagrant import test_boxes, VagrantTestCase, VagrantTestSuite
    boxes = test_boxes()
    if boxes:
        vagrant_suite = VagrantTestSuite(boxes)

        # Add a test case for each task in each fabfile
        fabfiles = os.path.join(os.path.dirname(__file__), 'fabfiles')
        for filename in sorted(os.listdir(fabfiles)):
            if fnmatch.fnmatch(filename, '[!_]*.py'):
                # Skip file if in exclude list
                if filename in exclude_files:
                    continue
                # Skip file if it's not in an explicit include list
                if include_files and filename not in include_files:
                    continue
                fabfile = os.path.join(fabfiles, filename)
                _, tasks, _ = load_fabfile(fabfile)
                for name, callable in tasks.iteritems():
                    test = VagrantTestCase(name, callable)
                    vagrant_suite.addTest(test)

        suite.addTest(vagrant_suite)

    return suite
Example #6
0
def load_tests(loader, suite, patterns):
    """
    Custom test loader for functional tests
    """

    # Optional include/exclude list of fabfiles
    include_files = os.environ.get('FABTOOLS_TEST_INCLUDE', '').split()
    exclude_files = os.environ.get('FABTOOLS_TEST_EXCLUDE', '').split()

    # Try to add vagrant functional tests
    from .vagrant import base_boxes, VagrantTestCase, VagrantTestSuite
    boxes = base_boxes()
    if boxes:
        vagrant_suite = VagrantTestSuite(boxes)

        # Add a test case for each task in each fabfile
        fabfiles = os.path.join(os.path.dirname(__file__), 'fabfiles')
        for filename in sorted(os.listdir(fabfiles)):
            if fnmatch.fnmatch(filename, '[!_]*.py'):
                # Skip file if in exclude list
                if filename in exclude_files:
                    continue
                # Skip file if it's not in an explicit include list
                if include_files and filename not in include_files:
                    continue
                fabfile = os.path.join(fabfiles, filename)
                _, tasks, _ = load_fabfile(fabfile)
                for name, callable in tasks.iteritems():
                    test = VagrantTestCase(name, callable)
                    vagrant_suite.addTest(test)

        suite.addTest(vagrant_suite)

    return suite
Example #7
0
File: main.py Project: eofs/aws
def ec2_fab(service, args):
    """
    Run Fabric commands against EC2 instances
    """
    instance_ids = args.instances
    instances = service.list(elb=args.elb, instance_ids=instance_ids)
    hosts = service.resolve_hosts(instances)

    fab.env.hosts = hosts
    fab.env.key_filename = settings.get('SSH', 'KEY_FILE')
    fab.env.user = settings.get('SSH', 'USER', getpass.getuser())
    fab.env.parallel = True

    fabfile = find_fabfile(args.file)
    if not fabfile:
        print 'Couldn\'t find any fabfiles!'
        return

    fab.env.real_fabile = fabfile
    docstring, callables, default = load_fabfile(fabfile)
    fab_state.commands.update(callables)

    commands_to_run = parse_arguments(args.methods)
    for name, args, kwargs, arg_hosts, arg_roles, arg_exclude_hosts in commands_to_run:
        fab.execute(name,
                    hosts=arg_hosts,
                    roles=arg_roles,
                    exclude_hosts=arg_exclude_hosts,
                    *args, **kwargs)
Example #8
0
def visit_fabfile(path=None):
    """Load and process a fabfile from the current working directory."""
    path = path or find_fabfile()
    if not path:
        raise ValueError('No fabfile detected')
    callables = load_fabfile(path)[1]
    return visit(callables)
Example #9
0
def get_task_list(parts):
    fabfile = '%s.py' % os.path.join(satellite.commands.__path__[0], *parts)
    if not os.path.exists(fabfile):
        return []
    docstring, callables, default = load_fabfile(fabfile)
    callables = dict((k, v) for k, v in callables.iteritems() if v.__module__ == parts[-1])
    return _task_names(callables)
Example #10
0
def load_tests(loader, suite, patterns):
    """
    Custom test loader for functional tests
    """

    # Try to add vagrant functional tests
    from .vagrant import base_boxes, VagrantFunctionTestCase, VagrantTestSuite
    boxes = base_boxes()
    if boxes:
        vagrant_suite = VagrantTestSuite(boxes)

        # Add a test case for each task in each fabfile
        fabfiles = os.path.join(os.path.dirname(__file__), 'fabfiles')
        for filename in sorted(os.listdir(fabfiles)):
            if fnmatch.fnmatch(filename, '[!_]*.py'):
                fabfile = os.path.join(fabfiles, filename)
                _, tasks, _ = load_fabfile(fabfile)
                for task in tasks.values():
                    test = VagrantFunctionTestCase(task,
                        description=short_doc(task))
                    vagrant_suite.addTest(test)

        suite.addTest(vagrant_suite)

    return suite
Example #11
0
def display_fabric_tasks():
    paths = find_fabfile()
    docstring, callables, default = load_fabfile(paths)
    callables.pop('setup', None)
    state.commands.update(callables)

    commands = list_commands(docstring, 'normal')
    print("\n".join(commands))
Example #12
0
 def setup(self):
     conf = self._service.config
     env.user = conf["user"]
     env.key_filename = conf["identity_file"]
     if "fabric" in conf:
         env.update(conf["fabric"])
     for name, func in load_fabfile(conf["fabfile"])[1].items():
         setattr(self, name, lambda *a, **kw: execute(func, hosts=self._service.hosts, *a, **kw))
Example #13
0
 def test_recursion_steps_into_nontask_modules(self):
     """
     Recursive loading will continue through modules with no tasks
     """
     module = fabfile('deep')
     with path_prefix(module):
         docs, funcs = load_fabfile(module)
         eq_(len(funcs), 1)
         ok_('submodule.subsubmodule.deeptask' in _task_names(funcs))
Example #14
0
 def test_newstyle_task_presence_skips_classic_task_modules(self):
     """
     Classic-task-only modules shouldn't add tasks if any new-style tasks exist
     """
     module = fabfile('deep')
     with path_prefix(module):
         docs, funcs = load_fabfile(module)
         eq_(len(funcs), 1)
         ok_('submodule.classic_task' not in _task_names(funcs))
Example #15
0
 def test_newstyle_task_presence_skips_classic_task_modules(self):
     """
     Classic-task-only modules shouldn't add tasks if any new-style tasks exist
     """
     module = fabfile('deep')
     with path_prefix(module):
         docs, funcs = load_fabfile(module)
         eq_(len(funcs), 1)
         ok_('submodule.classic_task' not in _task_names(funcs))
Example #16
0
 def test_recursion_steps_into_nontask_modules(self):
     """
     Recursive loading will continue through modules with no tasks
     """
     module = fabfile('deep')
     with path_prefix(module):
         docs, funcs = load_fabfile(module)
         eq_(len(funcs), 1)
         ok_('submodule.subsubmodule.deeptask' in _task_names(funcs))
Example #17
0
 def test_should_load_decorated_tasks_only_if_one_is_found(self):
     """
     If any new-style tasks are found, *only* new-style tasks should load
     """
     module = fabfile('decorated_fabfile.py')
     with path_prefix(module):
         docs, funcs = load_fabfile(module)
         eq_(len(funcs), 1)
         ok_('foo' in funcs)
Example #18
0
 def test_should_load_decorated_tasks_only_if_one_is_found(self):
     """
     If any new-style tasks are found, *only* new-style tasks should load
     """
     module = fabfile('decorated_fabfile.py')
     with path_prefix(module):
         docs, funcs = load_fabfile(module)
         eq_(len(funcs), 1)
         ok_('foo' in funcs)
Example #19
0
def import_fabfile(fabfile='fabfile.py'):
    """ you have to call this first to enable fabric tasks"""
    from fabric.main import find_fabfile, load_fabfile
    from fabric.network import normalize
    from fabric import state

    state.env.fabfile = fabfile
    _, fabfile = load_fabfile(find_fabfile())
    return fabfile
Example #20
0
 def test_implicit_discovery(self):
     """
     Default to automatically collecting all tasks in a fabfile module
     """
     implicit = fabfile("implicit_fabfile.py")
     with path_prefix(implicit):
         docs, funcs = load_fabfile(implicit)
         eq_(len(funcs), 2)
         ok_("foo" in funcs)
         ok_("bar" in funcs)
Example #21
0
 def test_implicit_discovery(self):
     """
     Default to automatically collecting all tasks in a fabfile module
     """
     implicit = fabfile("implicit_fabfile.py")
     with path_prefix(implicit):
         docs, funcs = load_fabfile(implicit)
         eq_(len(funcs), 2)
         ok_("foo" in funcs)
         ok_("bar" in funcs)
Example #22
0
 def test_explicit_discovery(self):
     """
     If __all__ is present, only collect the tasks it specifies
     """
     explicit = fabfile("explicit_fabfile.py")
     with path_prefix(explicit):
         docs, funcs = load_fabfile(explicit)
         eq_(len(funcs), 1)
         ok_("foo" in funcs)
         ok_("bar" not in funcs)
Example #23
0
 def test_class_based_tasks_are_found_with_proper_name(self):
     """
     Wrapped new-style tasks should preserve their function names
     """
     module = fabfile('decorated_fabfile_with_classbased_task.py')
     from fabric.state import env
     with path_prefix(module):
         docs, funcs = load_fabfile(module)
         eq_(len(funcs), 1)
         ok_('foo' in funcs)
Example #24
0
 def test_explicit_discovery(self):
     """
     If __all__ is present, only collect the tasks it specifies
     """
     explicit = fabfile("explicit_fabfile.py")
     with path_prefix(explicit):
         docs, funcs = load_fabfile(explicit)
         eq_(len(funcs), 1)
         ok_("foo" in funcs)
         ok_("bar" not in funcs)
Example #25
0
 def test_class_based_tasks_are_found_with_proper_name(self):
     """
     Wrapped new-style tasks should preserve their function names
     """
     module = fabfile('decorated_fabfile_with_classbased_task.py')
     from fabric.state import env
     with path_prefix(module):
         docs, funcs = load_fabfile(module)
         eq_(len(funcs), 1)
         ok_('foo' in funcs)
Example #26
0
 def _load_fabfile(self):
     app.logger.info("loading fabfile %s" % self.fabfile_path)
     if not state.commands:
         docstring, callables, default = load_fabfile(self.fabfile_path)
         state.commands.update(callables)
         app.logger.info("loaded {0} tasks from fabfile".format(
             len(state.commands)))
     # Don't prompt me bro
     state.env.abort_on_prompts = True
     # Let us capture exceptions
     state.env.abort_exception = FabricException
Example #27
0
 def _load_fabfile(self):
     app.logger.info("loading fabfile %s" % self.fabfile_path)
     if not state.commands:
         docstring, callables, default = load_fabfile(self.fabfile_path)
         state.commands.update(callables)
         app.logger.info("loaded {0} tasks from fabfile".format(
             len(state.commands)))
     # Don't prompt me bro
     state.env.abort_on_prompts = True
     # Let us capture exceptions
     state.env.abort_exception = FabricException
Example #28
0
def get_fabric_tasks(request):
    """
    Generate a list of fabric tasks that are available
    """
    try:
        docstring, callables, default = load_fabfile(find_fabfile(None))
        all_tasks = _task_names(callables)
        dict_with_docs = {task: callables[task].__doc__ for task in all_tasks}
    except Exception as e:
        messages.error(request, 'Error loading fabfile: ' + e.message)
        dict_with_docs = {}
    return dict_with_docs
Example #29
0
def get_fab_tasks():
    fab_task_list = {}

    if type(settings.fabfile).__name__ == 'dict':
        for alias, fabfile in settings.fabfile.items():
            (docstring, tasks, default) = main.load_fabfile(fabfile)
            fab_task_list[alias] = {'tasks': tasks,
                                      'doc': docstring,
                                      'default': default,
                                      'alias': alias,
                                     }
    return fab_task_list
Example #30
0
def get_fabric_tasks(request):
    """
    Generate a list of fabric tasks that are available
    """
    try:
        docstring, callables, default = load_fabfile(find_fabfile(None))
        all_tasks = _task_names(callables)
        dict_with_docs = {task: callables[task].__doc__ for task in all_tasks}
    except Exception as e:
        messages.error(request, 'Error loading fabfile: ' + e.message)
        dict_with_docs = {}
    return dict_with_docs
Example #31
0
 def __init__(self, path):
     _path = path
     if not path.endswith('fabric'):
         _path = os.path.join(path, 'fabfile')
     if 'fabfile' in sys.modules.keys():
         del sys.modules['fabfile']
     self.doc, _dict = load_fabfile(_path)[:2]
     self.task_dict = dict((x.name, FabricTask(x)) for x in _dict.values() if hasattr(x, 'name'))
     _modules = [k for k, m in _dict.items() if not hasattr(m, 'name')]
     for _m in _modules:
         self.task_dict.update(dict(('{0}.{1}'.format(_m, x.name), FabricTask(x, m=_m)) for x in _dict[_m].values() if hasattr(x, 'name')))
     self.directory = os.path.split(path)[0]
Example #32
0
def get_fabric_tasks(request):
    """
    Generate a list of fabric tasks that are available
    """
    try:

        docstring, callables, default = load_fabfile(settings.FABFILE_PATH)
        all_tasks = _task_names(callables)
        dict_with_docs = {task: callables[task].__doc__ for task in all_tasks}
    except Exception as e:
        messages.error(request, "Error loading fabfile: " + str(e))
        dict_with_docs = {}
    return dict_with_docs
Example #33
0
def get_fab_tasks(fabfile_dir):

    fab_task_list = dict()

    if os.path.isdir(fabfile_dir):

        for fabfile in os.listdir(fabfile_dir):
            if fabfile.endswith('.py') and fabfile != '__init__.py':
                (docstring, task, default) = load_fabfile(fabfile)
                task_name = fabfile.replace('.py', '')
                fab_task_list[task_name] = task[task_name]

    return fab_task_list
Example #34
0
def get_fab_tasks():
    fab_task_list = {}

    if type(settings.fabfile).__name__ == 'dict':
        for alias, fabfile in list(settings.fabfile.items()):
            (docstring, tasks, default) = main.load_fabfile(fabfile)
            fab_task_list[alias] = {
                'tasks': tasks,
                'doc': docstring,
                'default': default,
                'alias': alias,
            }
    return fab_task_list
Example #35
0
def load_tests(loader, tests, patterns):
    """
    Custom test loader
    """
    suite = VagrantTestSuite(BASE_BOXES)

    # Add a test case for each fabric task
    path = os.path.join(os.path.dirname(__file__), "fabfile.py")
    _, tasks, _ = load_fabfile(path)
    for name, task in tasks.items():
        suite.addTest(VagrantFunctionTestCase(task))

    return suite
Example #36
0
def load_tests(loader, tests, patterns):
    """
    Custom test loader
    """
    suite = VagrantTestSuite(BASE_BOXES)

    # Add a test case for each fabric task
    path = os.path.join(os.path.dirname(__file__), 'fabfile.py')
    _, tasks, _ = load_fabfile(path)
    for name, task in tasks.items():
        suite.addTest(VagrantFunctionTestCase(task))

    return suite
Example #37
0
def get_fab_tasks(fabfile_dir):

    fab_task_list = dict()

    if os.path.isdir(fabfile_dir):

        for fabfile in os.listdir(fabfile_dir):
            if fabfile.endswith('.py') and fabfile != '__init__.py':
                (docstring, task, default) = load_fabfile(fabfile)
                task_name = fabfile.replace('.py', '')
                fab_task_list[task_name] = task[task_name]

    return fab_task_list
    def allcmds(self):
	if self.sets:
	    return self._allcmds
	self.sets.extend( findfabfiles() )
        for fabfile in self.fabfiles:

            #fabric._load_default_settings()
	    commands = load_fabfile(fabfile)
            self.sets.append((commands,fabfile))
        self._allcmds = {}
        for commands,fabfile in self.sets:
            self._allcmds.update(commands)
        return self._allcmds
Example #39
0
def cli_command_run(args):
    """
  Runs task from deploy file
  """

    filepath = args.get('filename')
    task_name = args.get('task')

    if filepath:
        fullpath = os.path.join(os.path.realpath(os.curdir), filepath)
        docstring, callables, default = load_fabfile(fullpath)

        if task_name in callables:
            execute(callables[task_name])
Example #40
0
def build_deploy_docs(docs_path):
    try:
        from fabric.main import load_fabfile
    except ImportError:
        warn("Couldn't build fabfile.rst, fabric not installed")
        return
    project_template_path = path_for_import("mezzanine.project_template")
    commands = load_fabfile(os.path.join(project_template_path, "fabfile"))[1]
    lines = []
    for name in sorted(commands.keys()):
        doc = commands[name].__doc__.strip().split("\n")[0]
        lines.append("  * ``fab %s`` - %s" % (name, doc))
    with open(os.path.join(docs_path, "fabfile.rst"), "w") as f:
        f.write("\n".join(lines))
Example #41
0
def build_deploy_docs(docs_path):
    try:
        from fabric.main import load_fabfile
    except ImportError:
        warn("Couldn't build fabfile.rst, fabric not installed")
        return
    project_template_path = path_for_import("mezzanine.project_template")
    commands = load_fabfile(os.path.join(project_template_path, "fabfile"))[1]
    lines = []
    for name in sorted(commands.keys()):
        doc = commands[name].__doc__.strip().split("\n")[0]
        lines.append("  * ``fab %s`` - %s" % (name, doc))
    with open(os.path.join(docs_path, "fabfile.rst"), "w") as f:
        f.write("\n".join(lines))
Example #42
0
 def __init__(self, path):
     _path = path
     if not path.endswith('fabric'):
         _path = os.path.join(path, 'fabfile')
     if 'fabfile' in sys.modules.keys():
         del sys.modules['fabfile']
     self.doc, _dict = load_fabfile(_path)[:2]
     self.task_dict = dict((x.name, FabricTask(x)) for x in _dict.values()
                           if hasattr(x, 'name'))
     _modules = [k for k, m in _dict.items() if not hasattr(m, 'name')]
     for _m in _modules:
         self.task_dict.update(
             dict(('{0}.{1}'.format(_m, x.name), FabricTask(x, m=_m))
                  for x in _dict[_m].values() if hasattr(x, 'name')))
     self.directory = os.path.split(path)[0]
Example #43
0
def main():
    """Load our default fabfile, then attempt to load any local fabfiles."""
    our_fab = os.path.join(os.path.dirname(__file__), 'default_tasks.py')
    docstring, callables, default = fab.load_fabfile(our_fab)
    fab.state.commands.update(callables)


    fabfiles = []
    other_fab = fab.find_fabfile()
    if other_fab:
      fabfiles.append(other_fab)

    fabfiles.append(our_fab)


    fab.main(fabfiles)
Example #44
0
def schema(request):
    """
    Parses the project fabfile and returns API listing
    the available commands.  Commands are made available by
    adding the @tailored decorator to a fabric function.
    """

    if request.REQUEST.get('key'):
        if request.REQUEST.get('key') in djangosettings.TAILOR_API_KEYS.values():
            fabfile = djangosettings.TAILOR_FABFILE_PATH
            fabric_dir = os.path.dirname(fabfile)
            # Custom importer
            importer = lambda _: imp.load_source('fabfile', fabfile)

            sys.path.insert(0, fabric_dir)
            os.chdir(fabric_dir)
            try:
                _, task_map, _ = load_fabfile('/fabfile.py', importer)

                task_list = _task_names(task_map)

                fab_dict = {
                    'tasks' : {
                        'map'    : task_map,
                        'folded' : task_list
                    }
                }
                del sys.path[0]
                response = json.dumps(fab_dict)
                return HttpResponse(response, mimetype='application/json', status=200)
            except:
                return HttpResponse("Failed to build schema", status=500)
            finally:

        else:
            return HttpResponse("API Key Not Recognized", status=403)
    else:
        return HttpResponse("API Key Required", status=403)
Example #45
0
def load_tests(loader, tests, patterns):
    """
    Custom test loader
    """
    suite = unittest.TestSuite()

    # Add unit tests (import here to avoid circular import)
    suite.addTest(loader.loadTestsFromModule(unit))

    # Try to add vagrant functional tests
    boxes = base_boxes()
    if boxes:
        vagrant_suite = VagrantTestSuite(boxes)

        # Add a test case for each fabric task
        path = os.path.join(os.path.dirname(__file__), 'fabfile.py')
        _, tasks, _ = load_fabfile(path)
        for name, task in tasks.items():
            vagrant_suite.addTest(VagrantFunctionTestCase(task))

        suite.addTest(vagrant_suite)

    return suite
Example #46
0
def run():
    try:
        # Parse command line options
        parser, options, arguments = parse_options()

        # Handle regular args vs -- args
        arguments = parser.largs

        if len(arguments) > 1:
            abort("You can call only one command!")

        if arguments:
            tmp_parts = arguments[0].split(':')
            parts = tmp_parts[0].split('.')
            if not command_exists(parts):
                print
                print 'Warning: command not found!'
                print
                return
            fabfile_locations = ['%s.py' % os.path.join(satellite.commands.__path__[0], *parts[:-1])]
            arguments[0] = parts[-1] + ''.join(":%s" % i for i in tmp_parts[1:])
        else:
            print "Command tree:"
            print_tree_commands()
            return

        # Update env with any overridden option values
        # NOTE: This needs to remain the first thing that occurs
        # post-parsing, since so many things hinge on the values in env.
        for option in env_options:
            state.env[option.dest] = option.default

        # Handle --hosts, --roles, --exclude-hosts (comma separated string =>
        # list)
        for key in ['hosts', 'roles', 'exclude_hosts']:
            if key in state.env and isinstance(state.env[key], basestring):
                state.env[key] = state.env[key].split(',')

        # Load settings from user settings file, into shared env dict.
        settings.update(load_settings(options.configfile))
        state.env.update(settings.fabric)

        # Find local fabfile path or abort
        fabfile = find_fabfile(fabfile_locations)
        if not fabfile:
            abort("""Couldn't find any fabfiles!

Use -h for help.""")

        # Store absolute path to fabfile in case anyone needs it
        state.env.real_fabfile = fabfile

        # Load fabfile (which calls its module-level code, including
        # tweaks to env values) and put its commands in the shared commands
        # dict
        default = None
        if fabfile:
            docstring, callables, default = load_fabfile(fabfile)
            state.commands.update(callables)

        # Abort if no commands found
        if not state.commands:
            abort("Fabfile didn't contain any commands!")

        # Now that we're settled on a fabfile, inform user.
        if state.output.debug:
            if fabfile:
                print("Using fabfile '%s'" % fabfile)
            else:
                print("No fabfile loaded -- remainder command only")


        # Parse arguments into commands to run (plus args/kwargs/hosts)
        commands_to_run = parse_arguments(arguments)

        if state.output.debug:
            names = ", ".join(x[0] for x in commands_to_run)
            print("Commands to run: %s" % names)

        # At this point all commands must exist, so execute them in order.
        for name, args, kwargs, arg_hosts, arg_roles, arg_exclude_hosts in commands_to_run:
            execute(
                name,
                hosts=arg_hosts,
                roles=arg_roles,
                exclude_hosts=arg_exclude_hosts,
                *args, **kwargs
            )
            # If we got here, no errors occurred, so print a final note.
        if state.output.status:
            print("\nDone.")
    except SystemExit:
        # a number of internal functions might raise this one.
        raise
    except KeyboardInterrupt:
        if state.output.status:
            sys.stderr.write("\nStopped.\n")
        sys.exit(1)
    except:
        sys.excepthook(*sys.exc_info())
        # we might leave stale threads if we don't explicitly exit()
        sys.exit(1)
    finally:
        disconnect_all()
    sys.exit(0)
Example #47
0
from datetime import date
from random import shuffle
''' GameQ Function Import '''
from gameq import gameq
''' Py-TS3 Imports '''
from tsstatus import clientdict, gen_privilegekey, get_privilegekeys, rem_privilegekey, tsviewer
import ts3.query as tsquery
import ts3.commands, ts3.response
from ts3.common import TS3Error
from socket import error as socket_error
''' Fabric3 Imports and Setup '''
import fabfile
from fabric import state
from fabric.api import execute
from fabric.main import load_fabfile
docstring, callables, default = load_fabfile('fabfile.py')
state.commands.update(callables)
''' Config.json Import '''
with open('../data/config.json') as cfg:
    config = json.load(cfg)
''' Initialize Flask App '''
app = Flask(__name__)

app.config.update(SQLALCHEMY_DATABASE_URI='sqlite:///../data/' +
                  config['sqlite']['db'],
                  SQLALCHEMY_TRACK_MODIFICATIONS=False,
                  SECRET_KEY=config['steam-api']['key'],
                  DEBUG=config['flask']['debug'],
                  HOST=config['flask']['host'],
                  PORT=config['flask']['port'])
''' Database and Open ID Instantiation '''
Example #48
0
from fabric.state import env
from fabric.main import load_fabfile

from fabmagic.utils import _rel
from fabmagic.constants import COOKBOOKS_NAME, COOKBOOKS_LIBRARY_NAME, ROLES_NAME

__all__ = 'BaseTestCase',

logger = logging.getLogger("fabmagic.test")

env_copy = deepcopy(env)
current_dir = os.path.dirname(__file__)
fabfile_path = _rel(current_dir, "fabfile.py")
env.real_fabfile = fabfile_path
loading_result = load_fabfile(fabfile_path)


class BaseTestCase(unittest.TestCase):
    """Base test case
    """
    def setUp(self):
        self.logger = logger
        self.current_dir = current_dir
        self.fabfile_path = fabfile_path
        self.locading_result = loading_result
        self.env_copy = env_copy
        self.env = env
        self.config_file = _rel(os.path.dirname(__file__), ".config")
        self.new_config_file = _rel(os.path.dirname(__file__), ".new_config")
Example #49
0
def list_output(module, format_, expected):
    module = fabfile(module)
    with path_prefix(module):
        docstring, tasks = load_fabfile(module)
        with patched_context(fabric.state, 'commands', tasks):
            eq_output(docstring, format_, expected)
Example #50
0
def print_task_list(path):
    tasks = load_fabfile(path)
    task_dict = tasks[1]
    for task in task_dict.values():
        print(u'{0:10}: {1}'.format(task.name, task.__doc__))
Example #51
0
File: fab.py Project: kvbik/paver
def import_fabfile(fabfile='fabfile.py'):
    "you have to call this first to enable fabric tasks"
    state.env.fabfile = fabfile
    _, fabfile = load_fabfile(find_fabfile())
    return fabfile
Example #52
0
def print_task_list(path):
    tasks = load_fabfile(path)
    task_dict = tasks[1]
    for task in task_dict.values():
        print(u'{0:10}: {1}'.format(task.name, task.__doc__))
Example #53
0
def gentleman():
    args_dict = docopt(__doc__, version=__version__)
    arguments = args_dict['COMMAND']
    if not os.path.exists(os.path.join(os.getcwd(), '.gentle.yaml')):
        if arguments != ['init']:
            print(red('This is not a gentle directory, Make sure this is the correct'  # noqa
                  'directory, and use `gt init` Initialization'))
            return sys.exit(1)
        else:
            init()
    arguments = args_dict['COMMAND']
    try:
        # state.env.update(load_settings(state.env.rcfile))
        fabfile = os.path.join(here, 'gt')
        state.env.real_fabfile = fabfile
        default = None
        if fabfile:
            docstring, callables, default = load_fabfile(fabfile)
            state.commands.update(callables)

        commands_to_run = parse_arguments(arguments)
        unknown_commands = []
        for tup in commands_to_run:
            if crawl(tup[0], state.commands) is None:
                unknown_commands.append(tup[0])

        if args_dict['--list']:
            show_commands(docstring, 'normal', 1)
        for type in ['show', 'hide']:
            t = args_dict['--' + type]
            if t is not None:
                hide = True if type == 'hide' else False
                set_output(t, hide=hide, only=args_dict['--only'])

        # Abort if any unknown commands were specified
        if unknown_commands:
            warn("Command(s) not found:\n%s" % indent(unknown_commands))
            show_commands(None, 'normal', 1)

        for name, args, kwargs, arg_hosts, arg_roles, arg_exclude_hosts in \
            commands_to_run:
            execute(
                name,
                hosts=arg_hosts,
                roles=arg_roles,
                exclude_hosts=arg_exclude_hosts,
                *args, **kwargs)

        if state.output.status:
            print("\nDone.")
    except SystemExit:
        raise
    except KeyboardInterrupt:
        if state.output.status:
            sys.stderr.write("\nStopped.\n")
        sys.exit(1)
    except:
        sys.excepthook(*sys.exc_info())
        sys.exit(1)
    finally:
        disconnect_all()
    sys.exit(0)