~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Martin Pool
  • Date: 2005-05-17 06:56:16 UTC
  • Revision ID: mbp@sourcefrog.net-20050517065616-6f23381d6184a8aa
- add space for un-merged patches

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 os, time, tempfile
 
57
 
 
58
    from inventory import Inventory
 
59
    from osutils import isdir, isfile, sha_string, quotefn, \
 
60
         local_time_offset, username, kind_marker, is_inside_any
 
61
    
 
62
    from branch import gen_file_id
 
63
    from errors import BzrError
 
64
    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
 
79
    inv = Inventory()
 
80
    basis = branch.basis_tree()
 
81
    basis_inv = basis.inventory
 
82
    missing_ids = []
 
83
 
 
84
    if verbose:
 
85
        note('looking for changes...')
 
86
        
 
87
    for path, entry in work_inv.iter_entries():
 
88
        ## TODO: Check that the file kind has not changed from the previous
 
89
        ## revision of this file (if any).
 
90
 
 
91
        entry = entry.copy()
 
92
 
 
93
        p = branch.abspath(path)
 
94
        file_id = entry.file_id
 
95
        mutter('commit prep file %s, id %r ' % (p, file_id))
 
96
 
 
97
        if specific_files and not is_inside_any(specific_files, path):
 
98
            if basis_inv.has_id(file_id):
 
99
                # carry over with previous state
 
100
                inv.add(basis_inv[file_id].copy())
 
101
            else:
 
102
                # omit this from committed inventory
 
103
                pass
 
104
            continue
 
105
 
 
106
        if not work_tree.has_id(file_id):
 
107
            if verbose:
 
108
                print('deleted %s%s' % (path, kind_marker(entry.kind)))
 
109
            mutter("    file is missing, removing from inventory")
 
110
            missing_ids.append(file_id)
 
111
            continue
 
112
 
 
113
        inv.add(entry)
 
114
 
 
115
        if basis_inv.has_id(file_id):
 
116
            old_kind = basis_inv[file_id].kind
 
117
            if old_kind != entry.kind:
 
118
                raise BzrError("entry %r changed kind from %r to %r"
 
119
                        % (file_id, old_kind, entry.kind))
 
120
 
 
121
        if entry.kind == 'directory':
 
122
            if not isdir(p):
 
123
                raise BzrError("%s is entered as directory but not a directory"
 
124
                               % quotefn(p))
 
125
        elif entry.kind == 'file':
 
126
            if not isfile(p):
 
127
                raise BzrError("%s is entered as file but is not a file" % quotefn(p))
 
128
 
 
129
            new_sha1 = work_tree.get_file_sha1(file_id)
 
130
 
 
131
            old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
 
132
            if (old_ie
 
133
                and old_ie.text_sha1 == new_sha1):
 
134
                ## assert content == basis.get_file(file_id).read()
 
135
                entry.text_id = old_ie.text_id
 
136
                entry.text_sha1 = new_sha1
 
137
                entry.text_size = old_ie.text_size
 
138
                mutter('    unchanged from previous text_id {%s}' %
 
139
                       entry.text_id)
 
140
            else:
 
141
                content = file(p, 'rb').read()
 
142
 
 
143
                # calculate the sha again, just in case the file contents
 
144
                # changed since we updated the cache
 
145
                entry.text_sha1 = sha_string(content)
 
146
                entry.text_size = len(content)
 
147
 
 
148
                entry.text_id = gen_file_id(entry.name)
 
149
                branch.text_store.add(content, entry.text_id)
 
150
                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
 
238
 
 
239