source: tailor/vcpx/svn.py @ 61

Revision 61, 10.0 KB checked in by lele@…, 9 years ago (diff)

Fix a cut'n'paste gypso
Line 
1#! /usr/bin/python
2# -*- mode: python; coding: utf-8 -*-
3# :Progetto: vcpx -- Subversion details
4# :Creato:   ven 18 giu 2004 15:00:52 CEST
5# :Autore:   Lele Gaifax <lele@nautilus.homeip.net>
6#
7
8"""
9This module contains supporting classes for Subversion.
10"""
11
12__docformat__ = 'reStructuredText'
13
14from shwrap import SystemCommand
15from source import UpdatableSourceWorkingDir, ChangesetApplicationFailure
16from target import SyncronizableTargetWorkingDir, TargetInitializationFailure
17
18
19class SvnUpdate(SystemCommand):
20    COMMAND = "svn update --revision %(revision)s %(entry)s"
21
22
23class SvnInfo(SystemCommand):
24    COMMAND = "LANG= svn info %(entry)s"
25
26    def __call__(self, output=None, dry_run=False, **kwargs):
27        output = SystemCommand.__call__(self, output=True,
28                                        dry_run=dry_run,
29                                        **kwargs)
30        res = {}
31        for l in output:
32            l = l[:-1]
33            if l:
34                key, value = l.split(':', 1)
35                res[key] = value[1:]
36        return res
37
38                 
39class SvnPropGet(SystemCommand):
40    COMMAND = "svn propget %(property)s %(entry)s"
41
42   
43class SvnPropSet(SystemCommand):
44    COMMAND = "svn propset --quiet %(property)s %(value)s %(entry)s"
45
46
47class SvnLog(SystemCommand):
48    COMMAND = "svn log %(quiet)s %(xml)s --revision %(startrev)s:%(endrev)s %(entry)s 2>&1"
49   
50    def __call__(self, output=None, dry_run=False, **kwargs):
51        quiet = kwargs.get('quiet', True)
52        if quiet == True:
53            kwargs['quiet'] = '--quiet'
54        elif quiet == False:
55            kwargs['quiet'] = ''
56           
57        xml = kwargs.get('xml', False)
58        if xml:
59            kwargs['xml'] = '--xml'
60            output = True
61        else:
62            kwargs['xml'] = ''
63
64        startrev = kwargs.get('startrev')
65        if not startrev:
66            kwargs['startrev'] = 'BASE'
67
68        endrev = kwargs.get('endrev')
69        if not endrev:
70            kwargs['endrev'] = 'HEAD'
71
72        output = SystemCommand.__call__(self, output=output,
73                                        dry_run=dry_run, **kwargs)
74
75        if xml:
76            # parse the output and return the result
77            pass
78
79        return output
80
81
82class SvnCommit(SystemCommand):
83    COMMAND = "svn commit --quiet --file %(logfile)s %(entries)s"
84
85    def __call__(self, output=None, dry_run=False, **kwargs):
86        logfile = kwargs.get('logfile')
87        if not logfile:
88            from tempfile import NamedTemporaryFile
89
90            log = NamedTemporaryFile(bufsize=0)
91            logmessage = kwargs.get('logmessage')
92            if logmessage:
93                print >>log, logmessage
94           
95            kwargs['logfile'] = log.name
96       
97        return SystemCommand.__call__(self, output=output,
98                                      dry_run=dry_run, **kwargs)
99
100
101class SvnAdd(SystemCommand):
102    COMMAND = "svn add --quiet --no-auto-props --non-recursive %(entry)s"
103
104       
105class SvnRemove(SystemCommand):
106    COMMAND = "svn remove --quiet --force %(entry)s"
107
108
109class SvnMv(SystemCommand):
110    COMMAND = "svn mv --quiet %(old)s %(new)s"
111
112   
113class SvnCheckout(SystemCommand):
114    COMMAND = "svn co --revision %(revision)s %(repository)s %(wc)s"
115
116   
117class SvnWorkingDir(UpdatableSourceWorkingDir, SyncronizableTargetWorkingDir):
118
119    ## UpdatableSourceWorkingDir
120
121    def _getUpstreamChangesets(self, root, sincerev=None):
122        if sincerev:
123            sincerev = int(sincerev)
124        else:
125            sincerev = 0
126           
127        svnlog = SvnLog(working_dir=root)
128        log = svnlog(quiet='--verbose', output=True, xml=True,
129                     startrev=sincerev+1, entry='.')
130       
131        if svnlog.exit_status:
132            errmsg = log.getvalue()
133            # XXX
134            if 'No such revision' in errmsg:
135                return []
136            else:
137                raise 'XXX: svn log error: %s' % errmsg
138       
139        return self.__parseSvnLog(log)
140
141    def __parseSvnLog(self, log):
142        """Return an object representation of the ``svn log`` thru HEAD."""
143
144        from xml.sax import parseString
145        from xml.sax.handler import ContentHandler
146        from changes import ChangesetEntry, Changeset
147        from datetime import datetime
148       
149        class SvnXMLLogHandler(ContentHandler):
150            def __init__(self):
151                self.changesets = []
152                self.current = None
153                self.current_field = []
154
155            def startElement(self, name, attributes):
156                if name == 'logentry':
157                    self.current = {}
158                    self.current['revision'] = attributes['revision']
159                    self.current['entries'] = []
160                elif name in ['author', 'date', 'msg']:
161                    self.current_field = []
162                elif name == 'path':
163                    self.current_field = []
164                    if attributes.has_key('copyfrom-path'):
165                        self.current_path_action = (
166                            attributes['action'],
167                            attributes['copyfrom-path'][1:], # make it relative
168                            attributes['copyfrom-rev'])
169                    else:
170                        self.current_path_action = attributes['action']
171
172            def endElement(self, name):
173                if name == 'logentry':
174                    # Sort the paths to make tests easier
175                    self.current['entries'].sort()
176                    svndate = self.current['date']
177                    # 2004-04-16T17:12:48.000000Z
178                    y,m,d = map(int, svndate[:10].split('-'))
179                    hh,mm,ss = map(int, svndate[11:19].split(':'))
180                    ms = int(svndate[20:-1])
181                    timestamp = datetime(y, m, d, hh, mm, ss, ms)
182                    self.changesets.append(Changeset(self.current['revision'],
183                                                     timestamp,
184                                                     self.current['author'],
185                                                     self.current['msg'],
186                                                     self.current['entries']))
187                    self.current = None
188                elif name in ['author', 'date', 'msg']:
189                    self.current[name] = ''.join(self.current_field)
190                elif name == 'path':
191                    entry = ChangesetEntry(''.join(self.current_field)[1:])
192                    if type(self.current_path_action) == type( () ):
193                        entry.action_kind = entry.RENAMED
194                        entry.old_name = self.current_path_action[1]
195                    else:
196                        entry.action_kind = self.current_path_action
197
198                    self.current['entries'].append(entry)
199
200            def characters(self, data):
201                self.current_field.append(data)
202
203       
204        handler = SvnXMLLogHandler()
205        parseString(log.getvalue(), handler)
206        return handler.changesets
207   
208    def _applyChangeset(self, root, changeset, logger=None):
209        svnup = SvnUpdate(working_dir=root)
210        out = svnup(output=True, entry='.', revision=changeset.revision)
211       
212        if svnup.exit_status:
213            raise ChangesetApplicationFailure(
214                "'svn update' returned status %s" % svnup.exit_status)
215           
216        result = []
217        for line in out:
218            if len(line)>2 and line[0] == 'C' and line[1] == ' ':
219                logger.warn("Conflict after 'svn update': '%s'" % line)
220                result.append(line[2:-1])
221           
222        return result
223       
224    def _checkoutUpstreamRevision(self, basedir, repository, module, revision,
225                                  logger=None):
226        """
227        Concretely do the checkout of the upstream revision.
228        """
229       
230        from os.path import join, exists
231       
232        wdir = join(basedir, module)
233
234        if not exists(wdir):
235            svnco = SvnCheckout(working_dir=basedir)
236            svnco(output=True, repository=repository,
237                  wc=module, revision=revision)
238            if svnco.exit_status:
239                raise TargetInitializationFailure(
240                    "'svn checkout' returned status %s" % svnco.exit_status)
241
242        actual = SvnInfo(working_dir=wdir)(entry='.')['Revision']
243
244        if logger: logger.info("working copy up to svn revision %s",
245                               actual)
246       
247        return actual
248   
249    ## SyncronizableTargetWorkingDir
250
251    def _addEntry(self, root, entry):
252        """
253        Add a new entry, maybe registering the directory as well.
254        """
255
256        from os.path import split, join, exists
257
258        basedir = split(entry)[0]
259        if basedir and not exists(join(basedir, '.svn')):
260            self._addEntry(root, basedir)
261
262        c = SvnAdd(working_dir=root)
263        c(entry=entry)
264
265    def _commit(self,root, date, author, remark, changelog=None, entries=None):
266        """
267        Commit the changeset.
268        """
269
270        c = SvnCommit(working_dir=root)
271       
272        logmessage = remark + '\n'
273        if changelog:
274            logmessage = logmessage + changelog + '\n'
275           
276        if entries:
277            entries = ' '.join(entries)
278        else:
279            entries = '.'
280           
281        c(logmessage=logmessage, entries=entries)
282       
283    def _removeEntry(self, root, entry):
284        """
285        Remove an entry.
286        """
287
288        c = SvnRemove(working_dir=root)
289        c(entry=entry)
290
291    def _renameEntry(self, root, oldentry, newentry):
292        """
293        Rename an entry.
294        """
295
296        c = SvnMv(working_dir=root)
297        c(old=oldentry, new=newentry)
298
299    def _initializeWorkingDir(self, root, module, addentry=None):
300        """
301        Add the given directory to an already existing svn working tree.
302        """
303
304        from os.path import exists, join
305
306        if not exists(join(root, '.svn')):
307            raise TargetInitializationFailure("'%s' should already be under SVN" % root)
308
309        SyncronizableTargetWorkingDir._initializeWorkingDir(self, root, module,
310                                                            SvnAdd)
Note: See TracBrowser for help on using the repository browser.