~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Martin Pool
  • Date: 2005-06-10 07:13:33 UTC
  • Revision ID: mbp@sourcefrog.net-20050610071333-23ae2f973a1eb0f5
doc

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
 
 
19
def commit(branch, message,
 
20
           timestamp=None,
 
21
           timezone=None,
 
22
           committer=None,
 
23
           verbose=True,
 
24
           specific_files=None,
 
25
           rev_id=None):
 
26
    """Commit working copy as a new revision.
 
27
 
 
28
    The basic approach is to add all the file texts into the
 
29
    store, then the inventory, then make a new revision pointing
 
30
    to that inventory and store that.
 
31
 
 
32
    This is not quite safe if the working copy changes during the
 
33
    commit; for the moment that is simply not allowed.  A better
 
34
    approach is to make a temporary copy of the files before
 
35
    computing their hashes, and then add those hashes in turn to
 
36
    the inventory.  This should mean at least that there are no
 
37
    broken hash pointers.  There is no way we can get a snapshot
 
38
    of the whole directory at an instant.  This would also have to
 
39
    be robust against files disappearing, moving, etc.  So the
 
40
    whole thing is a bit hard.
 
41
 
 
42
    timestamp -- if not None, seconds-since-epoch for a
 
43
         postdated/predated commit.
 
44
 
 
45
    specific_files
 
46
        If true, commit only those files.
 
47
 
 
48
    rev_id
 
49
        If set, use this as the new revision id.
 
50
        Useful for test or import commands that need to tightly
 
51
        control what revisions are assigned.  If you duplicate
 
52
        a revision id that exists elsewhere it is your own fault.
 
53
        If null (default), a time/random revision id is generated.
 
54
    """
 
55
 
 
56
    import time, tempfile
 
57
 
 
58
    from osutils import local_time_offset, username
 
59
    
 
60
    from branch import gen_file_id
 
61
    from errors import BzrError
 
62
    from revision import Revision
 
63
    from trace import mutter, note
 
64
 
 
65
    branch.lock_write()
 
66
 
 
67
    try:
 
68
        # First walk over the working inventory; and both update that
 
69
        # and also build a new revision inventory.  The revision
 
70
        # inventory needs to hold the text-id, sha1 and size of the
 
71
        # actual file versions committed in the revision.  (These are
 
72
        # not present in the working inventory.)  We also need to
 
73
        # detect missing/deleted files, and remove them from the
 
74
        # working inventory.
 
75
 
 
76
        work_tree = branch.working_tree()
 
77
        work_inv = work_tree.inventory
 
78
        basis = branch.basis_tree()
 
79
        basis_inv = basis.inventory
 
80
 
 
81
        if verbose:
 
82
            note('looking for changes...')
 
83
 
 
84
        missing_ids, new_inv = _gather_commit(branch,
 
85
                                              work_tree,
 
86
                                              work_inv,
 
87
                                              basis_inv,
 
88
                                              specific_files,
 
89
                                              verbose)
 
90
 
 
91
        for file_id in missing_ids:
 
92
            # Any files that have been deleted are now removed from the
 
93
            # working inventory.  Files that were not selected for commit
 
94
            # are left as they were in the working inventory and ommitted
 
95
            # from the revision inventory.
 
96
 
 
97
            # have to do this later so we don't mess up the iterator.
 
98
            # since parents may be removed before their children we
 
99
            # have to test.
 
100
 
 
101
            # FIXME: There's probably a better way to do this; perhaps
 
102
            # the workingtree should know how to filter itbranch.
 
103
            if work_inv.has_id(file_id):
 
104
                del work_inv[file_id]
 
105
 
 
106
 
 
107
        if rev_id is None:
 
108
            rev_id = _gen_revision_id(time.time())
 
109
        inv_id = rev_id
 
110
 
 
111
        inv_tmp = tempfile.TemporaryFile()
 
112
        new_inv.write_xml(inv_tmp)
 
113
        inv_tmp.seek(0)
 
114
        branch.inventory_store.add(inv_tmp, inv_id)
 
115
        mutter('new inventory_id is {%s}' % inv_id)
 
116
 
 
117
        branch._write_inventory(work_inv)
 
118
 
 
119
        if timestamp == None:
 
120
            timestamp = time.time()
 
121
 
 
122
        if committer == None:
 
123
            committer = username()
 
124
 
 
125
        if timezone == None:
 
126
            timezone = local_time_offset()
 
127
 
 
128
        mutter("building commit log message")
 
129
        rev = Revision(timestamp=timestamp,
 
130
                       timezone=timezone,
 
131
                       committer=committer,
 
132
                       precursor = branch.last_patch(),
 
133
                       message = message,
 
134
                       inventory_id=inv_id,
 
135
                       revision_id=rev_id)
 
136
 
 
137
        rev_tmp = tempfile.TemporaryFile()
 
138
        rev.write_xml(rev_tmp)
 
139
        rev_tmp.seek(0)
 
140
        branch.revision_store.add(rev_tmp, rev_id)
 
141
        mutter("new revision_id is {%s}" % rev_id)
 
142
 
 
143
        ## XXX: Everything up to here can simply be orphaned if we abort
 
144
        ## the commit; it will leave junk files behind but that doesn't
 
145
        ## matter.
 
146
 
 
147
        ## TODO: Read back the just-generated changeset, and make sure it
 
148
        ## applies and recreates the right state.
 
149
 
 
150
        ## TODO: Also calculate and store the inventory SHA1
 
151
        mutter("committing patch r%d" % (branch.revno() + 1))
 
152
 
 
153
        branch.append_revision(rev_id)
 
154
 
 
155
        if verbose:
 
156
            note("commited r%d" % branch.revno())
 
157
    finally:
 
158
        branch.unlock()
 
159
 
 
160
 
 
161
 
 
162
def _gen_revision_id(when):
 
163
    """Return new revision-id."""
 
164
    from binascii import hexlify
 
165
    from osutils import rand_bytes, compact_date, user_email
 
166
 
 
167
    s = '%s-%s-' % (user_email(), compact_date(when))
 
168
    s += hexlify(rand_bytes(8))
 
169
    return s
 
170
 
 
171
 
 
172
def _gather_commit(branch, work_tree, work_inv, basis_inv, specific_files,
 
173
                   verbose):
 
174
    """Build inventory preparatory to commit.
 
175
 
 
176
    This adds any changed files into the text store, and sets their
 
177
    test-id, sha and size in the returned inventory appropriately.
 
178
 
 
179
    missing_ids
 
180
        Modified to hold a list of files that have been deleted from
 
181
        the working directory; these should be removed from the
 
182
        working inventory.
 
183
    """
 
184
    from bzrlib.inventory import Inventory
 
185
    from osutils import isdir, isfile, sha_string, quotefn, \
 
186
         local_time_offset, username, kind_marker, is_inside_any
 
187
    
 
188
    from branch import gen_file_id
 
189
    from errors import BzrError
 
190
    from revision import Revision
 
191
    from bzrlib.trace import mutter, note
 
192
 
 
193
    inv = Inventory()
 
194
    missing_ids = []
 
195
    
 
196
    for path, entry in work_inv.iter_entries():
 
197
        ## TODO: Check that the file kind has not changed from the previous
 
198
        ## revision of this file (if any).
 
199
 
 
200
        p = branch.abspath(path)
 
201
        file_id = entry.file_id
 
202
        mutter('commit prep file %s, id %r ' % (p, file_id))
 
203
 
 
204
        if specific_files and not is_inside_any(specific_files, path):
 
205
            if basis_inv.has_id(file_id):
 
206
                # carry over with previous state
 
207
                inv.add(basis_inv[file_id].copy())
 
208
            else:
 
209
                # omit this from committed inventory
 
210
                pass
 
211
            continue
 
212
 
 
213
        if not work_tree.has_id(file_id):
 
214
            if verbose:
 
215
                print('deleted %s%s' % (path, kind_marker(entry.kind)))
 
216
            mutter("    file is missing, removing from inventory")
 
217
            missing_ids.append(file_id)
 
218
            continue
 
219
 
 
220
        # this is present in the new inventory; may be new, modified or
 
221
        # unchanged.
 
222
        old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
 
223
        
 
224
        entry = entry.copy()
 
225
        inv.add(entry)
 
226
 
 
227
        if old_ie:
 
228
            old_kind = old_ie.kind
 
229
            if old_kind != entry.kind:
 
230
                raise BzrError("entry %r changed kind from %r to %r"
 
231
                        % (file_id, old_kind, entry.kind))
 
232
 
 
233
        if entry.kind == 'directory':
 
234
            if not isdir(p):
 
235
                raise BzrError("%s is entered as directory but not a directory"
 
236
                               % quotefn(p))
 
237
        elif entry.kind == 'file':
 
238
            if not isfile(p):
 
239
                raise BzrError("%s is entered as file but is not a file" % quotefn(p))
 
240
 
 
241
            new_sha1 = work_tree.get_file_sha1(file_id)
 
242
 
 
243
            if (old_ie
 
244
                and old_ie.text_sha1 == new_sha1):
 
245
                ## assert content == basis.get_file(file_id).read()
 
246
                entry.text_id = old_ie.text_id
 
247
                entry.text_sha1 = new_sha1
 
248
                entry.text_size = old_ie.text_size
 
249
                mutter('    unchanged from previous text_id {%s}' %
 
250
                       entry.text_id)
 
251
            else:
 
252
                content = file(p, 'rb').read()
 
253
 
 
254
                # calculate the sha again, just in case the file contents
 
255
                # changed since we updated the cache
 
256
                entry.text_sha1 = sha_string(content)
 
257
                entry.text_size = len(content)
 
258
 
 
259
                entry.text_id = gen_file_id(entry.name)
 
260
                branch.text_store.add(content, entry.text_id)
 
261
                mutter('    stored with text_id {%s}' % entry.text_id)
 
262
 
 
263
        if verbose:
 
264
            marked = path + kind_marker(entry.kind)
 
265
            if not old_ie:
 
266
                print 'added', marked
 
267
            elif old_ie == entry:
 
268
                pass                    # unchanged
 
269
            elif (old_ie.name == entry.name
 
270
                  and old_ie.parent_id == entry.parent_id):
 
271
                print 'modified', marked
 
272
            else:
 
273
                print 'renamed', marked
 
274
                        
 
275
    return missing_ids, inv
 
276
 
 
277