~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Martin Pool
  • Date: 2005-06-28 05:33:40 UTC
  • Revision ID: mbp@sourcefrog.net-20050628053340-ea73b03fbcde9c46
- Remove XMLMixin class in favour of simple pack_xml, unpack_xml functions
  called as needed.  

- Avoid importing xml and ElementTree library unless needed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
53
53
        If null (default), a time/random revision id is generated.
54
54
    """
55
55
 
56
 
    import os, time, tempfile
57
 
 
58
 
    from inventory import Inventory
 
56
    import time, tempfile
 
57
 
 
58
    from bzrlib.osutils import local_time_offset, username
 
59
    from bzrlib.branch import gen_file_id
 
60
    from bzrlib.errors import BzrError
 
61
    from bzrlib.revision import Revision, RevisionReference
 
62
    from bzrlib.trace import mutter, note
 
63
    from bzrlib.xml import pack_xml
 
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
        pack_xml(new_inv, 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
        # We could also just sha hash the inv_tmp file
 
118
        # however, in the case that branch.inventory_store.add()
 
119
        # ever actually does anything special
 
120
        inv_sha1 = branch.get_inventory_sha1(inv_id)
 
121
 
 
122
        branch._write_inventory(work_inv)
 
123
 
 
124
        if timestamp == None:
 
125
            timestamp = time.time()
 
126
 
 
127
        if committer == None:
 
128
            committer = username()
 
129
 
 
130
        if timezone == None:
 
131
            timezone = local_time_offset()
 
132
 
 
133
        mutter("building commit log message")
 
134
        rev = Revision(timestamp=timestamp,
 
135
                       timezone=timezone,
 
136
                       committer=committer,
 
137
                       message = message,
 
138
                       inventory_id=inv_id,
 
139
                       inventory_sha1=inv_sha1,
 
140
                       revision_id=rev_id)
 
141
 
 
142
        precursor_id = branch.last_patch()
 
143
        if precursor_id:
 
144
            precursor_sha1 = branch.get_revision_sha1(precursor_id)
 
145
            rev.parents = [RevisionReference(precursor_id, precursor_sha1)]
 
146
 
 
147
        rev_tmp = tempfile.TemporaryFile()
 
148
        pack_xml(rev, rev_tmp)
 
149
        rev_tmp.seek(0)
 
150
        branch.revision_store.add(rev_tmp, rev_id)
 
151
        mutter("new revision_id is {%s}" % rev_id)
 
152
 
 
153
        ## XXX: Everything up to here can simply be orphaned if we abort
 
154
        ## the commit; it will leave junk files behind but that doesn't
 
155
        ## matter.
 
156
 
 
157
        ## TODO: Read back the just-generated changeset, and make sure it
 
158
        ## applies and recreates the right state.
 
159
 
 
160
        ## TODO: Also calculate and store the inventory SHA1
 
161
        mutter("committing patch r%d" % (branch.revno() + 1))
 
162
 
 
163
        branch.append_revision(rev_id)
 
164
 
 
165
        if verbose:
 
166
            note("commited r%d" % branch.revno())
 
167
    finally:
 
168
        branch.unlock()
 
169
 
 
170
 
 
171
 
 
172
def _gen_revision_id(when):
 
173
    """Return new revision-id."""
 
174
    from binascii import hexlify
 
175
    from osutils import rand_bytes, compact_date, user_email
 
176
 
 
177
    s = '%s-%s-' % (user_email(), compact_date(when))
 
178
    s += hexlify(rand_bytes(8))
 
179
    return s
 
180
 
 
181
 
 
182
def _gather_commit(branch, work_tree, work_inv, basis_inv, specific_files,
 
183
                   verbose):
 
184
    """Build inventory preparatory to commit.
 
185
 
 
186
    This adds any changed files into the text store, and sets their
 
187
    test-id, sha and size in the returned inventory appropriately.
 
188
 
 
189
    missing_ids
 
190
        Modified to hold a list of files that have been deleted from
 
191
        the working directory; these should be removed from the
 
192
        working inventory.
 
193
    """
 
194
    from bzrlib.inventory import Inventory
59
195
    from osutils import isdir, isfile, sha_string, quotefn, \
60
196
         local_time_offset, username, kind_marker, is_inside_any
61
197
    
62
198
    from branch import gen_file_id
63
199
    from errors import BzrError
64
200
    from revision import Revision
65
 
    from trace import mutter, note
66
 
 
67
 
    branch._need_writelock()
68
 
 
69
 
    # First walk over the working inventory; and both update that
70
 
    # and also build a new revision inventory.  The revision
71
 
    # inventory needs to hold the text-id, sha1 and size of the
72
 
    # actual file versions committed in the revision.  (These are
73
 
    # not present in the working inventory.)  We also need to
74
 
    # detect missing/deleted files, and remove them from the
75
 
    # working inventory.
76
 
 
77
 
    work_tree = branch.working_tree()
78
 
    work_inv = work_tree.inventory
 
201
    from bzrlib.trace import mutter, note
 
202
 
79
203
    inv = Inventory()
80
 
    basis = branch.basis_tree()
81
 
    basis_inv = basis.inventory
82
204
    missing_ids = []
83
 
 
84
 
    if verbose:
85
 
        note('looking for changes...')
86
 
        
 
205
    
87
206
    for path, entry in work_inv.iter_entries():
88
207
        ## TODO: Check that the file kind has not changed from the previous
89
208
        ## revision of this file (if any).
90
209
 
91
 
        entry = entry.copy()
92
 
 
93
210
        p = branch.abspath(path)
94
211
        file_id = entry.file_id
95
212
        mutter('commit prep file %s, id %r ' % (p, file_id))
110
227
            missing_ids.append(file_id)
111
228
            continue
112
229
 
 
230
        # this is present in the new inventory; may be new, modified or
 
231
        # unchanged.
 
232
        old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
 
233
        
 
234
        entry = entry.copy()
113
235
        inv.add(entry)
114
236
 
115
 
        if basis_inv.has_id(file_id):
116
 
            old_kind = basis_inv[file_id].kind
 
237
        if old_ie:
 
238
            old_kind = old_ie.kind
117
239
            if old_kind != entry.kind:
118
240
                raise BzrError("entry %r changed kind from %r to %r"
119
241
                        % (file_id, old_kind, entry.kind))
128
250
 
129
251
            new_sha1 = work_tree.get_file_sha1(file_id)
130
252
 
131
 
            old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
132
253
            if (old_ie
133
254
                and old_ie.text_sha1 == new_sha1):
134
255
                ## assert content == basis.get_file(file_id).read()
148
269
                entry.text_id = gen_file_id(entry.name)
149
270
                branch.text_store.add(content, entry.text_id)
150
271
                mutter('    stored with text_id {%s}' % entry.text_id)
151
 
                if verbose:
152
 
                    if not old_ie:
153
 
                        print('added %s' % path)
154
 
                    elif (old_ie.name == entry.name
155
 
                          and old_ie.parent_id == entry.parent_id):
156
 
                        print('modified %s' % path)
157
 
                    else:
158
 
                        print('renamed %s' % path)
159
 
 
160
 
 
161
 
    for file_id in missing_ids:
162
 
        # Any files that have been deleted are now removed from the
163
 
        # working inventory.  Files that were not selected for commit
164
 
        # are left as they were in the working inventory and ommitted
165
 
        # from the revision inventory.
166
 
        
167
 
        # have to do this later so we don't mess up the iterator.
168
 
        # since parents may be removed before their children we
169
 
        # have to test.
170
 
 
171
 
        # FIXME: There's probably a better way to do this; perhaps
172
 
        # the workingtree should know how to filter itbranch.
173
 
        if work_inv.has_id(file_id):
174
 
            del work_inv[file_id]
175
 
 
176
 
 
177
 
    if rev_id is None:
178
 
        rev_id = _gen_revision_id(time.time())
179
 
    inv_id = rev_id
180
 
 
181
 
    inv_tmp = tempfile.TemporaryFile()
182
 
    inv.write_xml(inv_tmp)
183
 
    inv_tmp.seek(0)
184
 
    branch.inventory_store.add(inv_tmp, inv_id)
185
 
    mutter('new inventory_id is {%s}' % inv_id)
186
 
 
187
 
    branch._write_inventory(work_inv)
188
 
 
189
 
    if timestamp == None:
190
 
        timestamp = time.time()
191
 
 
192
 
    if committer == None:
193
 
        committer = username()
194
 
 
195
 
    if timezone == None:
196
 
        timezone = local_time_offset()
197
 
 
198
 
    mutter("building commit log message")
199
 
    rev = Revision(timestamp=timestamp,
200
 
                   timezone=timezone,
201
 
                   committer=committer,
202
 
                   precursor = branch.last_patch(),
203
 
                   message = message,
204
 
                   inventory_id=inv_id,
205
 
                   revision_id=rev_id)
206
 
 
207
 
    rev_tmp = tempfile.TemporaryFile()
208
 
    rev.write_xml(rev_tmp)
209
 
    rev_tmp.seek(0)
210
 
    branch.revision_store.add(rev_tmp, rev_id)
211
 
    mutter("new revision_id is {%s}" % rev_id)
212
 
 
213
 
    ## XXX: Everything up to here can simply be orphaned if we abort
214
 
    ## the commit; it will leave junk files behind but that doesn't
215
 
    ## matter.
216
 
 
217
 
    ## TODO: Read back the just-generated changeset, and make sure it
218
 
    ## applies and recreates the right state.
219
 
 
220
 
    ## TODO: Also calculate and store the inventory SHA1
221
 
    mutter("committing patch r%d" % (branch.revno() + 1))
222
 
 
223
 
    branch.append_revision(rev_id)
224
 
 
225
 
    if verbose:
226
 
        note("commited r%d" % branch.revno())
227
 
 
228
 
 
229
 
 
230
 
def _gen_revision_id(when):
231
 
    """Return new revision-id."""
232
 
    from binascii import hexlify
233
 
    from osutils import rand_bytes, compact_date, user_email
234
 
 
235
 
    s = '%s-%s-' % (user_email(), compact_date(when))
236
 
    s += hexlify(rand_bytes(8))
237
 
    return s
 
272
 
 
273
        if verbose:
 
274
            marked = path + kind_marker(entry.kind)
 
275
            if not old_ie:
 
276
                print 'added', marked
 
277
            elif old_ie == entry:
 
278
                pass                    # unchanged
 
279
            elif (old_ie.name == entry.name
 
280
                  and old_ie.parent_id == entry.parent_id):
 
281
                print 'modified', marked
 
282
            else:
 
283
                print 'renamed', marked
 
284
                        
 
285
    return missing_ids, inv
238
286
 
239
287