own code

discoverer.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import ConfigParser
import argparse
import os
import logging
import sys
import gitlab
import threading

from utils import exc, utils
from utils import connector
from utils.connector import Connector


class Discoverer():
    base_path = os.path.abspath(os.path.dirname(__file__))
    env = None
    repo_manager = None
    gl = None
    group = None
    project = None
    deploy_key = None
    labels = []

    issues = []
    projects = []

    def __init__(self, env='darmstadt-staging', repo_manager=None, group=None):
        if logging is None:
            logging.basicConfig(level=logging.INFO,
                                format='%(asctime)-15s %(levelname)5s %(filename)s:%(funcName)s:%(lineno)s %(message)s')

        self.gl = Connector().instance
        self.repo_manager = repo_manager
        self.group = group
        self.env = env
        self.__get_config()

        if self.repo_manager is None:
            self.__get_repo_manager()

        if self.group is None:
            self.__get_vnf_group()

    def __get_repo_manager(self):
        self.repo_manager = self.gl.projects.get(self.config.get(self.env, 'organizer_repo', None))

    def __get_vnf_group(self):
        self.group = self.gl.groups.search(self.config.get(self.env, 'vnf_group', None))[0]

    def __get_config(self):
        self.config = ConfigParser.ConfigParser()
        try:
            self.config.read(os.path.join(self.base_path, '..', '.gitlabconfig'))
            logging.debug('Using environment [{}]'.format(self.env))

            self.labels = self.config.get(self.env, 'labels', None).replace(' ', '').split(',')
            logging.debug('Using labels: {}'.format(self.labels))

            self.protected_projects = self.config.get(self.env, 'protected_projects', None).replace(' ', '').split(',')
            logging.debug('Protected projects: {}'.format(self.protected_projects))

        except ConfigParser.NoOptionError as exc:
            utils.exit_on_error('Error parsing config file: {}.'.format(exc))
        except IOError as exc:
            utils.exit_on_error('Could not read config file.')

    def __connect(self):
        """
        Get instance of the connection singleton object.

        :return: Gitlab object
        """

        try:
            self.gl = connector.Connector().instance

        except (gitlab.exceptions.GitlabAuthenticationError, gitlab.exceptions.GitlabConnectionError) as exc:
            utils.exit_on_error(exc)

    def get_issues(self, labels=[]):
        issues = []

        page = 1
        per_page=20
        while True:
            next_list = self.repo_manager.issues.list(per_page=per_page, page=page, labels=labels)
            if not next_list:
                break
            issues.extend(next_list)
            if per_page > len(next_list):
                break
            page += 1
        return issues

    def get_projects(self):
        raw_projects = [ ]

        page = 1
        per_page=20
        while True:
            next_list = self.group.projects.list(per_page=per_page, page=page)
            if not next_list:
                break
            raw_projects.extend(next_list)
            if per_page > len(next_list):
                break
            page += 1

        projects = []
        for p in raw_projects:
            if p.name not in self.protected_projects:
                projects.append(p)

        return projects

    def go(self):
        self.issues = self.get_issues()
        self.projects = self.get_projects()

        # return { 'issues': self.issues, 'projects': self.projects}

def main():
    logging.basicConfig(level=logging.INFO,
                        format='%(asctime)-15s %(levelname)5s %(filename)s:%(funcName)s:%(lineno)s %(message)s')


if __name__ == '__main__':
    main()