~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Martin Pool
  • Date: 2005-04-15 01:31:21 UTC
  • Revision ID: mbp@sourcefrog.net-20050415013121-b18f1be12a735066
- Doc cleanups from Magnus Therning

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.lock('w')
68
 
 
69
 
    try:
70
 
        # First walk over the working inventory; and both update that
71
 
        # and also build a new revision inventory.  The revision
72
 
        # inventory needs to hold the text-id, sha1 and size of the
73
 
        # actual file versions committed in the revision.  (These are
74
 
        # not present in the working inventory.)  We also need to
75
 
        # detect missing/deleted files, and remove them from the
76
 
        # working inventory.
77
 
 
78
 
        work_tree = branch.working_tree()
79
 
        work_inv = work_tree.inventory
80
 
        inv = Inventory()
81
 
        basis = branch.basis_tree()
82
 
        basis_inv = basis.inventory
83
 
        missing_ids = []
84
 
 
85
 
        if verbose:
86
 
            note('looking for changes...')
87
 
 
88
 
        for path, entry in work_inv.iter_entries():
89
 
            ## TODO: Check that the file kind has not changed from the previous
90
 
            ## revision of this file (if any).
91
 
 
92
 
            entry = entry.copy()
93
 
 
94
 
            p = branch.abspath(path)
95
 
            file_id = entry.file_id
96
 
            mutter('commit prep file %s, id %r ' % (p, file_id))
97
 
 
98
 
            if specific_files and not is_inside_any(specific_files, path):
99
 
                if basis_inv.has_id(file_id):
100
 
                    # carry over with previous state
101
 
                    inv.add(basis_inv[file_id].copy())
102
 
                else:
103
 
                    # omit this from committed inventory
104
 
                    pass
105
 
                continue
106
 
 
107
 
            if not work_tree.has_id(file_id):
108
 
                if verbose:
109
 
                    print('deleted %s%s' % (path, kind_marker(entry.kind)))
110
 
                mutter("    file is missing, removing from inventory")
111
 
                missing_ids.append(file_id)
112
 
                continue
113
 
 
114
 
            inv.add(entry)
115
 
 
116
 
            if basis_inv.has_id(file_id):
117
 
                old_kind = basis_inv[file_id].kind
118
 
                if old_kind != entry.kind:
119
 
                    raise BzrError("entry %r changed kind from %r to %r"
120
 
                            % (file_id, old_kind, entry.kind))
121
 
 
122
 
            if entry.kind == 'directory':
123
 
                if not isdir(p):
124
 
                    raise BzrError("%s is entered as directory but not a directory"
125
 
                                   % quotefn(p))
126
 
            elif entry.kind == 'file':
127
 
                if not isfile(p):
128
 
                    raise BzrError("%s is entered as file but is not a file" % quotefn(p))
129
 
 
130
 
                new_sha1 = work_tree.get_file_sha1(file_id)
131
 
 
132
 
                old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
133
 
                if (old_ie
134
 
                    and old_ie.text_sha1 == new_sha1):
135
 
                    ## assert content == basis.get_file(file_id).read()
136
 
                    entry.text_id = old_ie.text_id
137
 
                    entry.text_sha1 = new_sha1
138
 
                    entry.text_size = old_ie.text_size
139
 
                    mutter('    unchanged from previous text_id {%s}' %
140
 
                           entry.text_id)
141
 
                else:
142
 
                    content = file(p, 'rb').read()
143
 
 
144
 
                    # calculate the sha again, just in case the file contents
145
 
                    # changed since we updated the cache
146
 
                    entry.text_sha1 = sha_string(content)
147
 
                    entry.text_size = len(content)
148
 
 
149
 
                    entry.text_id = gen_file_id(entry.name)
150
 
                    branch.text_store.add(content, entry.text_id)
151
 
                    mutter('    stored with text_id {%s}' % entry.text_id)
152
 
                    if verbose:
153
 
                        if not old_ie:
154
 
                            print('added %s' % path)
155
 
                        elif (old_ie.name == entry.name
156
 
                              and old_ie.parent_id == entry.parent_id):
157
 
                            print('modified %s' % path)
158
 
                        else:
159
 
                            print('renamed %s' % path)
160
 
 
161
 
 
162
 
        for file_id in missing_ids:
163
 
            # Any files that have been deleted are now removed from the
164
 
            # working inventory.  Files that were not selected for commit
165
 
            # are left as they were in the working inventory and ommitted
166
 
            # from the revision inventory.
167
 
 
168
 
            # have to do this later so we don't mess up the iterator.
169
 
            # since parents may be removed before their children we
170
 
            # have to test.
171
 
 
172
 
            # FIXME: There's probably a better way to do this; perhaps
173
 
            # the workingtree should know how to filter itbranch.
174
 
            if work_inv.has_id(file_id):
175
 
                del work_inv[file_id]
176
 
 
177
 
 
178
 
        if rev_id is None:
179
 
            rev_id = _gen_revision_id(time.time())
180
 
        inv_id = rev_id
181
 
 
182
 
        inv_tmp = tempfile.TemporaryFile()
183
 
        inv.write_xml(inv_tmp)
184
 
        inv_tmp.seek(0)
185
 
        branch.inventory_store.add(inv_tmp, inv_id)
186
 
        mutter('new inventory_id is {%s}' % inv_id)
187
 
 
188
 
        branch._write_inventory(work_inv)
189
 
 
190
 
        if timestamp == None:
191
 
            timestamp = time.time()
192
 
 
193
 
        if committer == None:
194
 
            committer = username()
195
 
 
196
 
        if timezone == None:
197
 
            timezone = local_time_offset()
198
 
 
199
 
        mutter("building commit log message")
200
 
        rev = Revision(timestamp=timestamp,
201
 
                       timezone=timezone,
202
 
                       committer=committer,
203
 
                       precursor = branch.last_patch(),
204
 
                       message = message,
205
 
                       inventory_id=inv_id,
206
 
                       revision_id=rev_id)
207
 
 
208
 
        rev_tmp = tempfile.TemporaryFile()
209
 
        rev.write_xml(rev_tmp)
210
 
        rev_tmp.seek(0)
211
 
        branch.revision_store.add(rev_tmp, rev_id)
212
 
        mutter("new revision_id is {%s}" % rev_id)
213
 
 
214
 
        ## XXX: Everything up to here can simply be orphaned if we abort
215
 
        ## the commit; it will leave junk files behind but that doesn't
216
 
        ## matter.
217
 
 
218
 
        ## TODO: Read back the just-generated changeset, and make sure it
219
 
        ## applies and recreates the right state.
220
 
 
221
 
        ## TODO: Also calculate and store the inventory SHA1
222
 
        mutter("committing patch r%d" % (branch.revno() + 1))
223
 
 
224
 
        branch.append_revision(rev_id)
225
 
 
226
 
        if verbose:
227
 
            note("commited r%d" % branch.revno())
228
 
    finally:
229
 
        branch.unlock()
230
 
 
231
 
 
232
 
 
233
 
def _gen_revision_id(when):
234
 
    """Return new revision-id."""
235
 
    from binascii import hexlify
236
 
    from osutils import rand_bytes, compact_date, user_email
237
 
 
238
 
    s = '%s-%s-' % (user_email(), compact_date(when))
239
 
    s += hexlify(rand_bytes(8))
240
 
    return s
241
 
 
242