Changeset 336 in tailor


Ignore:
Timestamp:
05/25/05 23:44:33 (8 years ago)
Author:
lele@…
Hash name:
20050525214433-97f81-dccdfb7f9b951b1fb4ef5908d36ca059b3fd5ba5
Message:

Save both last applied revision and pending changesets into the state file
Using the interactive session, tailor now saves not only the last applied
source revision but also the remaining not yet applied changesets in the
state file.

This has various advantages: a) it's handy and faster caching the info
on disk and b) most important, this fixes some CVS annoyance when the
update step does not terminate correctly due to any error while
applying an upstream changeset.

Location:
vcpx
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • vcpx/changes.py

    r335 r336  
    3131    CONFLICT = 'CONFLICT' 
    3232     
    33     __slots__ = ('name', 'old_name', 
    34                  'old_revision', 'new_revision', 
    35                  'action_kind', 'status', 'unidiff') 
    36  
    3733    def __init__(self, name): 
    3834        self.name = name 

  • vcpx/session.py

    r334 r336  
    6363         
    6464        self.state_file = None 
    65          
    6665        self.logfile = None 
    6766        self.logger = None 
    … …  
    6968        self.__processArgs() 
    7069 
     70        # Persistent 
     71         
     72        self.changesets = None 
     73        self.source_revision = None 
     74         
    7175    def __processArgs(self): 
    7276        """ 
    … …  
    9498        self.stdout.write(what) 
    9599         
    96  
    97     ## Interactive commands 
    98  
     100     
    99101    def emptyline(self): 
    100102        """Override the default impl of reexecuting last command.""" 
    … …  
    111113        return line 
    112114         
     115    ## Interactive commands 
     116 
    113117    def do_exit(self, arg): 
    114118        """ 
    … …  
    349353        self.__log('Current target module: %s\n' % self.target_module) 
    350354 
    351     def readSourceRevision(self): 
    352         """Read the source revision from the state file.""" 
     355    def loadStateFile(self): 
     356        """ 
     357        Read the source revision and pending changesets from the state file. 
     358        """ 
     359 
     360        from cPickle import load 
    353361 
    354362        try: 
    355363            sf = open(self.state_file) 
    356             revision = sf.read() 
     364            self.source_revision, self.changesets = load(sf) 
    357365            sf.close() 
     366 
     367            self.__log('Source revision: %s\n' % self.source_revision) 
     368            if self.changesets: 
     369                self.__log('Pending changesets: %d\n' % len(self.changesets)) 
    358370        except IOError: 
    359             revision = None 
    360  
    361         return revision 
    362              
    363     def saveSourceRevision(self, revision): 
    364         """Write current source revision in the state file.""" 
    365  
     371            self.source_revision = None 
     372            self.changesets = None 
     373 
     374    def writeStateFile(self): 
     375        """ 
     376        Write current source revision and pending changesets in the state file. 
     377        """ 
     378 
     379        from cPickle import dump 
     380         
    366381        sf = open(self.state_file, 'w') 
    367         sf.write(revision) 
     382        dump((self.source_revision, self.changesets), sf) 
    368383        sf.close() 
    369          
     384 
    370385    def do_state_file(self, arg): 
    371386        """ 
    … …  
    380395 
    381396        from os.path import isabs, abspath, expanduser 
    382  
     397        from cPickle import load 
     398         
    383399        if arg: 
    384400            arg = expanduser(arg) 
    … …  
    388404        if arg and self.state_file <> arg: 
    389405            self.state_file = arg 
    390                  
     406             
    391407        self.__log('Current state file: %s\n' % self.state_file) 
     408 
     409        self.loadStateFile() 
    392410 
    393411    def do_bootstrap(self, arg): 
    … …  
    406424            self.__err('Need a state_file to proceed!\n') 
    407425            return 
    408          
     426 
     427        if self.source_revision is not None: 
     428            self.__err('Already bootstrapped!') 
     429             
    409430        if self.sub_directory: 
    410431            subdir = self.sub_directory 
    … …  
    422443 
    423444        try: 
    424             actual = dwd.checkoutUpstreamRevision(self.current_directory, 
    425                                                   self.source_repository, 
    426                                                   self.source_module, 
    427                                                   revision, 
    428                                                   subdir=subdir, 
    429                                                   logger=self.logger) 
    430             self.saveSourceRevision(actual) 
     445            self.source_revision = dwd.checkoutUpstreamRevision( 
     446                self.current_directory, self.source_repository, 
     447                self.source_module, revision, 
     448                subdir=subdir, logger=self.logger) 
    431449        except Exception, exc: 
    432450            self.__err('Checkout failed: %s, %s' % (exc.__doc__, exc)) 
    … …  
    434452                self.logger.exception('Checkout failed') 
    435453 
     454        self.writeStateFile() 
     455         
    436456        try: 
    437457            dwd.initializeNewWorkingDir(self.current_directory, 
    … …  
    439459                                        self.target_module, 
    440460                                        self.sub_directory, 
    441                                         actual) 
     461                                        self.source_revision) 
    442462        except Exception, exc: 
    443463            self.__err('Working copy initialization failed: %s, %s' % 
    … …  
    460480        """ 
    461481 
    462         self.stdout.write("Changeset %s:\n%s\n" % (changeset.revision, 
    463                                                    changeset.log)) 
     482        self.stdout.write("\nChangeset %s:\n%s\n" % (changeset.revision, 
     483                                                     changeset.log)) 
    464484 
    465485        while 1: 
    … …  
    488508        """ 
    489509 
    490         self.saveSourceRevision(changeset.revision) 
     510        self.source_revision = changeset.revision 
     511        self.changesets.remove(changeset) 
    491512 
    492513    def do_update(self, arg): 
    … …  
    510531            return 
    511532                 
    512         source_revision = self.readSourceRevision() 
    513         if not source_revision: 
     533        if self.source_revision is None: 
    514534            self.__err("Not yet bootstrapped!\n") 
    515535            return 
    … …  
    524544        repodir = join(self.current_directory, subdir) 
    525545        dwd = DualWorkingDir(self.source_kind, self.target_kind) 
    526         changesets = dwd.getUpstreamChangesets(repodir, 
    527                                                self.source_repository, 
    528                                                self.source_module, 
    529                                                source_revision) 
    530         nchanges = len(changesets) 
    531         if nchanges: 
    532             self.__log('Collected %d upstream changesets\n' % nchanges) 
    533  
    534             if arg: 
    535                 applyable = self.willApply 
    536                 try: 
    537                     howmany = min(int(arg), nchanges) 
    538                     changesets = changesets[:howmany] 
    539                     self.__log('Applying first %d of them\n' % howmany) 
    540                 except ValueError: 
    541                     if arg.lower() == 'ask': 
    542                         applyable = self.shouldApply 
    543  
     546 
     547        # If we have no pending changesets, ask the upstream server 
     548        # about new changes 
     549         
     550        if not self.changesets: 
    544551            try: 
    545                 last, conflicts = dwd.applyUpstreamChangesets( 
    546                     repodir, self.source_module, changesets, 
    547                     applyable=applyable, applied=self.applied, 
    548                     logger=self.logger) # , delayed_commit=single_commit) 
    549             except StopIteration, KeyboardInterrupt: 
     552                self.changesets = dwd.getUpstreamChangesets( 
     553                                           repodir, 
     554                                           self.source_repository, 
     555                                           self.source_module, 
     556                                           self.source_revision) 
     557            except KeyboardInterrupt: 
    550558                if self.logger: 
    551559                    self.logger.warning("Stopped by user") 
    … …  
    553561            except: 
    554562                if self.logger: 
    555                     self.logger.exception('Upstream change application ' 
    556                                           'failed') 
    557                 self.__err('Stopping after upstream change application ' 
    558                            'failure.') 
     563                    self.logger.exception('Unable to collect upstream changes') 
     564                self.__err('Unable to collect upstream changes') 
    559565                return 
    560  
    561             if last: 
    562                 self.__log("Update completed, now at revision '%s'" % 
    563                            self.readSourceRevision()) 
     566             
     567        nchanges = len(self.changesets) 
     568        if nchanges: 
     569            if arg: 
     570                applyable = self.willApply 
     571                try: 
     572                    howmany = min(int(arg), nchanges) 
     573                    changesets = self.changesets[:howmany] 
     574                except ValueError: 
     575                    changesets = self.changesets[:] 
     576                    if arg.lower() == 'ask': 
     577                        applyable = self.shouldApply 
     578 
     579            self.__log('Applying %d changesets (out of %d)\n' % 
     580                       (len(changesets), nchanges)) 
     581 
     582            last = None 
     583            try: 
     584                try: 
     585                    last, conflicts = dwd.applyUpstreamChangesets( 
     586                        repodir, self.source_module, changesets, 
     587                        applyable=applyable, applied=self.applied, 
     588                        logger=self.logger) # , delayed_commit=single_commit) 
     589                except StopIteration, KeyboardInterrupt: 
     590                    if self.logger: 
     591                        self.logger.warning("Stopped by user") 
     592                    return 
     593                except: 
     594                    if self.logger: 
     595                        self.logger.exception('Upstream change application ' 
     596                                              'failed') 
     597                    self.__err('Stopping after upstream change application ' 
     598                               'failure.') 
     599                    return 
     600            finally: 
     601                self.writeStateFile() 
     602                 
     603                if self.changesets: 
     604                    self.__log("There are still %d pending changesets, " 
     605                               "now at revision '%s'\n" % 
     606                               (len(self.changesets), self.source_revision)) 
     607                else: 
     608                    self.__log("Update completed, now at revision '%s'\n" % 
     609                               self.source_revision) 
    564610        else: 
    565611            self.__log("Update completed with no upstream changes") 
Note: See TracChangeset for help on using the changeset viewer.