예제 #1
0
 def get_branch_name(self) -> str:
     # pylint: disable=broad-except
     reponame = "waiting..."
     with raise_context():
         repo = self.get_repo()
         with raise_context():
             reponame = repo.head.object.hexsha
         repo_branch = self.target_branch or 'ERROR'
         if repo.head.is_detached and repo_branch.replace('tags/', '') in repo.tags:
             return repo_branch
         reponame = repo.active_branch.name
     return reponame
예제 #2
0
    def _make_operations(self, operation: Callable) -> Any:
        '''
        Handle VCS operations and sync data from project.

        :param operation: function that should be hdandled.
        :return: tuple with repo-object and fetch-results
        '''
        self._set_status("SYNC")
        try:
            with transaction.atomic():
                result = self._operate(operation)
                self.proj.status = "OK"
                self._update_tasks(self._get_playbook_path(result[0]))
                self._set_project_modules()
                self._handle_yaml(self._load_yaml() or dict())
                self._update_slave_inventories(self.proj.slave_inventory.all())
                self.proj.save()
        except Exception as err:
            logger.debug(traceback.format_exc())
            self.message('Sync error: {}'.format(err), 'error')
            self._set_status("ERROR")
            raise
        else:
            with raise_context(verbose=True):
                self.handler_class(self, result).trigger_execution()
            return result
예제 #3
0
 def prefetch(self, queryset_func_name, view, queryset):
     with raise_context():
         queryset = self.filter_by_func(
             queryset, f'{queryset_func_name}_related',
             self.filter_model_fields(
                 view, self.fields_fetch_map[queryset_func_name]))
     return queryset
예제 #4
0
    def make_update(self, env: ENV_VARS_TYPE) -> Tuple[git.Repo, Any]:
        try:
            repo = self._get_or_create_repo(env)
        except git.InvalidGitRepositoryError:
            logger.info('Convert project [{}] to GIT.'.format(self.proj.id))
            repo = git.Repo.init(self.path)
            repo.create_remote('origin', self.proj.repository)
            with repo.git.custom_environment(**env):
                kwargs = self.options.get("FETCH_KWARGS", dict())
                origin = repo.remote('origin')
                logger.debug('Fetch remote brances for project [{}].'.format(self.proj.id))
                origin.fetch(**kwargs)
                if not list(origin.refs):
                    config_writer = repo.config_writer()
                    config_writer.set_value("user", "email", self.proj.owner.email).release()
                    user_name = self.proj.owner.username
                    if self.proj.owner.last_name and self.proj.owner.first_name:  # nocv
                        user_name = '{u.fist_name} {u.last_name}'.format(u=self.proj.owner)
                    config_writer.set_value("user", "name", user_name).release()
                    repo.git.add(A=True)
                    repo.git.commit(m='Create project from Polemarch.')
                    logger.debug('Push project [{}] as master.'.format(self.proj.id))
                    repo.git.push('--set-upstream', 'origin', 'master')

        results = repo, self.vcs_update(repo, env)
        with raise_context():
            repo.git.checkout(self.target_branch)
        return results
예제 #5
0
파일: tests.py 프로젝트: iffanux/vstutils
 def test_executors(self):
     dir_name = os.path.dirname(__file__)
     cmd = utils.UnhandledExecutor(stderr=utils.UnhandledExecutor.DEVNULL)
     self.assertEqual('yes', cmd.execute('echo yes'.split(' '), dir_name))
     cmd = utils.Executor(stderr=utils.Executor.DEVNULL)
     self.assertEqual('yes', cmd.execute('echo yes'.split(' '), dir_name))
     cmd = utils.Executor()
     with utils.raise_context():
         cmd.execute('bash -c "python0.0 --version"'.split(' '), dir_name)
예제 #6
0
 def execute(self, cmd: Iterable[Text], cwd: Text):
     pm_ansible_path = ' '.join(self.pm_ansible())
     new_cmd = list()
     for one_cmd in cmd:
         if isinstance(one_cmd, six.string_types):
             with raise_context():
                 one_cmd = one_cmd.decode('utf-8')
         new_cmd.append(one_cmd)
     self.history.raw_args = " ".join(new_cmd).replace(pm_ansible_path, '').lstrip()
     return super(Executor, self).execute(new_cmd, cwd)
예제 #7
0
 def make_clone(self, env: ENV_VARS_TYPE) -> Tuple[git.Repo, None]:
     kw = dict(**self.options.get("CLONE_KWARGS", dict()))
     if self.target_branch:
         kw['branch'] = self.target_branch.replace('tags/', '')
     repo = self.vsc_clone(self.proj.repository, self.path, env=env, **kw)
     with raise_context():
         self.proj.variables.update_or_create(
             key='repo_branch', defaults=dict(value=repo.active_branch.name)
         )
     return repo, None
예제 #8
0
 def __call__(self, value, serializer_field=None):
     if not self.has_pillow:
         warnings.warn(self.warning_msg, ImportWarning)
         return
     super().__call__(value)
     should_resize_image = False
     with raise_context():
         should_resize_image = serializer_field.context[
             'request'].headers.get('Auto-Resize-Image', None) == 'true'
     self.validate(value, should_resize_image)
예제 #9
0
 def _update_submodules(self, repo):
     for sm in repo.submodules:
         # Calling git directly for own submodules
         # since using relative path is not working in gitpython
         # see https://github.com/gitpython-developers/GitPython/issues/730
         with raise_context():
             if sm.url[0:3] == '../':
                 sm_path = sm.name
                 repo.git.submodule('init', sm_path)
                 repo.git.submodule('update', sm_path)
             else:
                 sm.update(init=True)
예제 #10
0
 def _get_or_create_repo(self, env: ENV_VARS_TYPE) -> git.Repo:
     try:
         repo = self.get_repo()
         branch = self.target_branch
         with raise_context():
             repo.git.checkout(branch)
         is_not_detached = not repo.head.is_detached
         if branch and is_not_detached and repo.active_branch.name != branch:
             self.delete()
             raise git.NoSuchPathError
     except git.NoSuchPathError:
         repo = self.make_clone(env)[0]
     return repo
예제 #11
0
    def _get_playbook_path(self, repo: Any = None) -> Iterable[pathlib.Path]:
        path_list_additional = []
        additional_pb_pattern = None

        with raise_context():
            additional_pb_pattern = self.proj.variables.get(
                key='playbook_path').value

        if additional_pb_pattern and (pathlib.Path(self.path) /
                                      additional_pb_pattern).exists():
            path_list_additional = self.search_files(
                repo, additional_pb_pattern + '/*.yml')

        return chain(self.search_files(repo, '*.yml'), path_list_additional)
예제 #12
0
 def _update_submodules(self, repo: git.Repo):
     logger.debug('Update GIT submodules in project [{}]'.format(self.proj.id))
     for sm in repo.submodules:
         # Calling git directly for own submodules
         # since using relative path is not working in gitpython
         # see https://github.com/gitpython-developers/GitPython/issues/730
         with raise_context():
             logger.debug('Update module "{}" in project [{}].'.format(sm.name, self.proj.id))
             if sm.url[0:3] == '../':
                 sm_path = sm.name
                 repo.git.submodule('init', sm_path)
                 repo.git.submodule('update', sm_path)
             else:
                 sm.update(init=True)
예제 #13
0
 def dir_prepare_git(self, src: Text, work_dir: Text, revision: Text):
     # pylint: disable=no-member
     import git
     repo = git.Repo.clone_from(
         url=src + "/.git",
         to_path=work_dir,
         **self.project.repo_handlers.opts(self.project.type).get('PREP_KWARGS', {})
     )
     repo.git.checkout(revision or self.project.branch)
     for sm in repo.submodules:
         # Calling git directly for own submodules
         # since using relative path is not working in gitpython
         # see https://github.com/gitpython-developers/GitPython/issues/730
         with raise_context():
             if sm.url[0:3] == '../':
                 repo_parent_url, _ = os.path.split(repo.remotes.origin.url)
                 actual_url = os.path.join(repo_parent_url, sm.name)
                 with sm.config_writer() as writer:
                     writer.set('url', actual_url)
             sm.update(init=True)
예제 #14
0
파일: tests.py 프로젝트: iffanux/vstutils
    def test_raise_context(self):
        class SomeEx(KeyError):
            pass

        @utils.exception_with_traceback()
        def ex_method(ex=Exception('Valid ex')):
            raise ex

        with self.assertRaises(SomeEx) as exc:
            ex_method(SomeEx())

        self.assertTrue(getattr(exc.exception, 'traceback', False))
        with utils.raise_context(TypeError):
            ex_method(SomeEx())

        @utils.raise_context(SomeEx, exclude=Exception)
        def ex_method(ex=Exception('Valid ex')):
            raise ex

        ex_method(SomeEx())
        with self.assertRaises(Exception):
            ex_method()
예제 #15
0
파일: vcs.py 프로젝트: zhourudong/polemarch
 def get_branch_name(self):
     # pylint: disable=broad-except
     with raise_context():
         return self.get_repo().active_branch.name
     return "waiting..."
예제 #16
0
 def tearDown(self):
     super(HooksTestCase, self).tearDown()
     for script in self.scripts:
         with raise_context():
             os.remove(script)
예제 #17
0
파일: projects.py 프로젝트: teazj/polemarch
 def _read(self, file):
     data = file.read()
     with raise_context():
         data = data.decode('utf-8')
     return data
예제 #18
0
 def execute(self, when, message):
     for hook in self.when(when):
         with raise_context():
             hook.run(when, message)
예제 #19
0
파일: vcs.py 프로젝트: walllam/polemarch
 def make_update(self, env):
     repo = self._get_or_create_repo(env)
     resutls = repo, self.vcs_update(repo, env)
     with raise_context():
         repo.git.checkout(self.target_branch)
     return resutls
예제 #20
0
파일: utils.py 프로젝트: xtha/polemarch
 def line_handler(self, proc, line):
     # pylint: disable=unused-argument
     if line is not None:
         with raise_context():
             self.write_output(line)
예제 #21
0
 def execute(self, when: Text, message: Any) -> NoReturn:
     for hook in self.when(when):
         with raise_context():
             hook.run(when, message)
예제 #22
0
파일: manual.py 프로젝트: wladtk/polemarch
 def generate_file(self, name: Text):
     with open(os.path.join(self.path, name), 'w', encoding='utf-8') as fd:
         with raise_context():
             fd.write(get_render('polemarch/{}'.format(name), settings.MANUAL_PROJECT_VARS))