Exemplo n.º 1
0
    def handle(self, *args, **options):

        self.stdout.write('Started.\n')
        logger.info("Start")
        t_start = time.time() 

        potonly = options['potonly']
        
        BOT_USERNAME = getattr(settings, 'BOT_USERNAME', 'bot')
        BOT_USER = User.objects.get(username=BOT_USERNAME)

        projects = Project.objects.filter(enabled=True, read_only=False)
        
        b = None
        failedProjects = []
        try:
            for project in projects:
                teams = project.teams.all()
                for release in project.releases.filter(enabled=True, read_only=False):
                    for component in project.components.all():

                        try:
                            b = BuildCache.objects.get(component=component, release=release)
                            if b.is_locked:
                                logger.info("%s - %s is locked" % (release, component))
                                break
                        except:
                            b = BuildCache.objects.create(component=component,
                                                      release=release)
                        
                        b.lock()

                        try:
                            if not potonly:
                                for team in teams:
                                    if project.slug in failedProjects:
                                        self.stdout.write("Project %s skipped because previous fails\n" % project.slug)
                                        logger.info("Project %s skipped because previous fails" % project.slug)
                                        break
                                    
                                    logger.info("Refresh project %s, release %s, component %s, team %s" % (project.name,
                                                                                                          release.name,
                                                                                                          component.name,
                                                                                                          team.language.name))
                                    man = Manager(project, release, component, team.language, user=BOT_USER)
                                    
                                    try:
                                        logger.debug('Create lock')
                                        with LockRepo(project.slug,
                                                      release.slug,
                                                      component.slug,
                                                      team.language.code) as lock:
                                            logger.debug('Refresh')
                                            man.revert()
                                            man.refresh()
                                        logger.debug('Process Stats')
                                        man.update_stats(False)
                                    except Exception, e:
                                        failedProjects.append(project.slug)
                                        logger.error(e)
                                        traceback.print_exc(file=sys.stdout)
                                    finally:
                                        del man
                                    
                            if component.potlocation:
                                logger.info("Processing POT")
                                repo = POTUpdater(project, release, component)
                                try:
                                    repo.update_stats(True)
                                except Exception, e:
                                    logger.error(e)
                                    traceback.print_exc(file=sys.stdout)
                                finally:
                                    del repo
Exemplo n.º 2
0
    def do_handle(self, *args, **options):
        global notification, potnotification
                
        self.stdout.write('Started.\n')
        logger.info("Start")
        t_start = time.time() 

        init_env()
        
        dorefresh = not options['statsonly']

        BOT_USERNAME = getattr(settings, 'BOT_USERNAME', 'bot')
        BOT_USER = User.objects.get(username=BOT_USERNAME)
            
        pre_save.connect(update_callback, sender=POFile)
        rsp = None
        projects = Project.objects.filter(enabled=True, read_only=False)
        b = None
        try:
            failedProjects = []
            for project in projects:
                teams = project.teams.all()
                for release in project.releases.filter(enabled=True, read_only=False):
                    for component in project.components.all():
                        b = None
                        try:
                            b = BuildCache.objects.get(component=component, release=release)
                            if b.is_locked:
                                logger.info("Project %s - Component %s - Release %s is LOCKED" % (project.name,
                                                                                                  component.name,
                                                                                                  release.name))
                                break
                            else:
                                b.lock()
                        except BuildCache.DoesNotExist:
                            b = BuildCache.objects.create(component=component,
                                                      release=release)
                            b.lock()
                        except Exception, e:
                            b = None
                            logger.error(e)
                            traceback.print_exc(file=sys.stdout)
                        if b:
                            for team in teams:
                                if project.slug in failedProjects:
                                    self.stdout.write("Project %s skipped because previous fails\n" % project.slug)
                                    logger.info("Project %s skipped because previous fails" % project.slug)
                                    break
                                                                    
                                logger.info("Update project %s, release %s, component %s, team %s" % (project.name,
                                                                                                      release.name,
                                                                                                      component.name,
                                                                                                      team.language.name))
                                man = Manager(project, release, component, team.language, user=BOT_USER)
                                try:
                                    with LockRepo(project.slug,
                                                  release.slug,
                                                  component.slug,
                                                  team.language.code) as lock:        
                                        if dorefresh:
                                            man.revert()
                                            b.setrev(man.refresh())
                                        man.update_stats(False)
                                except Exception, e:
                                    failedProjects.append(project.slug)
                                    logger.error(e)
                                    traceback.print_exc(file=sys.stdout)
                                finally:
                                    del man