Esempio n. 1
0
    def update_repo(self):
        from versioncontrol.manager import Manager, LockRepo
        from versioncontrol.models import BuildCache
        
        do_update = True
        try:
            b = BuildCache.objects.get(component=self.pofile.component,
                                       release=self.pofile.release)
        except:
            b = BuildCache.objects.create(component=self.pofile.component,
                                          release=self.pofile.release)
        else:
            updategap = getattr(settings,'FILE_UPDATE_GAP',900)
            diff = dt.now() - b.updated
            diffm = (diff.seconds/60)
            if b.is_locked or updategap == 0 or diff.seconds < updategap:
                logger.debug("No need to update. Last updated %s. %s minutes ago. Current lock %s." % (
                                                                            b.updated,
                                                                            diffm,
                                                                            b.is_locked))
                do_update = False
            else:
                logger.debug("Updating. Last updated %s. %s minutes ago." % (b.updated,
                                                                             diffm))
                b.lock()

        if do_update:
            try:
                man = Manager(self.pofile.release.project,
                                   self.pofile.release,
                                   self.pofile.component,
                                   self.pofile.language)            
                with LockRepo(self.pofile.release.project.slug,
                              self.pofile.release.slug,
                              self.pofile.component.slug,
                              self.pofile.language.code) as lock:        
                    man.refresh()
            except Exception, e:
                logger.error(e)
                raise
            finally:
Esempio n. 2
0
    def runTest(self):
        man = Manager(self.project,
                      self.release,
                      self.component,
                      self.language,
                      self.log)

        """ perform checkout """
        # perform build
        rev = man.build()

        # check if the file was added
        pofiles = POFile.objects.filter(component=self.component,
                                  release=self.release,
                                  language=self.language)
        
        # the repo should contain one file only
        self.assertEquals(pofiles.count(),1)
        
        """ perform commit """
        # modify the file
        f = open(pofiles[0].file,"a")
        f.write("test")
        f.close()
        
        # perform commit
        revc = man.commit(None, None, "test")
        self.assertEquals(revc, (rev + 1))
        
        # POT creation
        potman = POTUpdater(self.project, self.release, self.component,self.log)        
        potman.build()
        
        potfiles = POTFile.objects.filter(component=self.component)
        
        self.assertEquals(potfiles.count(),1)
        self.assertEquals(potfiles[0].total,5) # 5 messages
        self.assertEquals(potfiles[0].updated,'2009-09-21 09:47+0200')
Esempio n. 3
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
Esempio n. 4
0
                logger.error(e)
                raise
            if canbuild:
                locks.append(b)
                for team in project.teams.all():
                    
                    if (POFile.objects.filter(release=release,
                                          component=component,
                                          language=team.language).count()) == 0:
                        logger.debug("New language %s" % team.language)
                        new_team = True
                    else:
                        logger.debug("Rebuild language %s" % team.language)
                        new_team = False
                    
                    repo = Manager(project, release, component, team.language, logfile)
                    try:
                        b.setrev(repo.build())
#                        send_pm(user, subject=_('Build of %(component)s on release %(release)s for team %(team)s completed.')
#                                        % {'component': component.name,
#                                           'release': release.name,
#                                           'team': team.language.name})
                    except lock.LockException, l:
                        repo.notify_callback(l)
                        logger.error(l)
                        send_pm(user, _("Project locked"), message=_('Project locked for %(team)s. Try again in a few minutes. If the problem persist contact the administrator.') % {
                                            'team': team.language.name})
                    except Exception, e:
                        repo.notify_callback(e)
                        logger.error(e)
                        send_pm(user, _('Error building team %(team)s.') % {'team': team.language.name}, _('Reason: %(error)s') % {'error': e.args} )
Esempio n. 5
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