/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

More work on roundtrip push support.

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, timestamp=None, timezone=None,
20
 
           committer=None,
21
 
           verbose=True,
22
 
           specific_files=None,
23
 
           rev_id=None):
24
 
    """Commit working copy as a new revision.
25
 
 
26
 
    The basic approach is to add all the file texts into the
27
 
    store, then the inventory, then make a new revision pointing
28
 
    to that inventory and store that.
29
 
 
30
 
    This is not quite safe if the working copy changes during the
31
 
    commit; for the moment that is simply not allowed.  A better
32
 
    approach is to make a temporary copy of the files before
33
 
    computing their hashes, and then add those hashes in turn to
34
 
    the inventory.  This should mean at least that there are no
35
 
    broken hash pointers.  There is no way we can get a snapshot
36
 
    of the whole directory at an instant.  This would also have to
37
 
    be robust against files disappearing, moving, etc.  So the
38
 
    whole thing is a bit hard.
39
 
 
40
 
    timestamp -- if not None, seconds-since-epoch for a
41
 
         postdated/predated commit.
42
 
 
43
 
    specific_files
44
 
        If true, commit only those files.
45
 
 
46
 
    rev_id
47
 
        If set, use this as the new revision id.
48
 
        Useful for test or import commands that need to tightly
49
 
        control what revisions are assigned.  If you duplicate
50
 
        a revision id that exists elsewhere it is your own fault.
51
 
        If null (default), a time/random revision id is generated.
52
 
    """
53
 
 
54
 
    import os, time, tempfile
55
 
 
56
 
    from inventory import Inventory
57
 
    from osutils import isdir, isfile, sha_string, quotefn, \
58
 
         local_time_offset, username, kind_marker, is_inside_any
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._need_writelock()
66
 
 
67
 
    # First walk over the working inventory; and both update that
68
 
    # and also build a new revision inventory.  The revision
69
 
    # inventory needs to hold the text-id, sha1 and size of the
70
 
    # actual file versions committed in the revision.  (These are
71
 
    # not present in the working inventory.)  We also need to
72
 
    # detect missing/deleted files, and remove them from the
73
 
    # working inventory.
74
 
 
75
 
    work_tree = branch.working_tree()
76
 
    work_inv = work_tree.inventory
77
 
    inv = Inventory()
78
 
    basis = branch.basis_tree()
79
 
    basis_inv = basis.inventory
80
 
    missing_ids = []
81
 
 
82
 
    if verbose:
83
 
        note('looking for changes...')
84
 
        
85
 
    for path, entry in work_inv.iter_entries():
86
 
        ## TODO: Check that the file kind has not changed from the previous
87
 
        ## revision of this file (if any).
88
 
 
89
 
        entry = entry.copy()
90
 
 
91
 
        p = branch.abspath(path)
92
 
        file_id = entry.file_id
93
 
        mutter('commit prep file %s, id %r ' % (p, file_id))
94
 
 
95
 
        if specific_files and not is_inside_any(specific_files, path):
96
 
            if basis_inv.has_id(file_id):
97
 
                # carry over with previous state
98
 
                inv.add(basis_inv[file_id].copy())
99
 
            else:
100
 
                # omit this from committed inventory
101
 
                pass
102
 
            continue
103
 
 
104
 
        if not work_tree.has_id(file_id):
105
 
            if verbose:
106
 
                print('deleted %s%s' % (path, kind_marker(entry.kind)))
107
 
            mutter("    file is missing, removing from inventory")
108
 
            missing_ids.append(file_id)
109
 
            continue
110
 
 
111
 
        inv.add(entry)
112
 
 
113
 
        if basis_inv.has_id(file_id):
114
 
            old_kind = basis_inv[file_id].kind
115
 
            if old_kind != entry.kind:
116
 
                raise BzrError("entry %r changed kind from %r to %r"
117
 
                        % (file_id, old_kind, entry.kind))
118
 
 
119
 
        if entry.kind == 'directory':
120
 
            if not isdir(p):
121
 
                raise BzrError("%s is entered as directory but not a directory"
122
 
                               % quotefn(p))
123
 
        elif entry.kind == 'file':
124
 
            if not isfile(p):
125
 
                raise BzrError("%s is entered as file but is not a file" % quotefn(p))
126
 
 
127
 
            new_sha1 = work_tree.get_file_sha1(file_id)
128
 
 
129
 
            old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
130
 
            if (old_ie
131
 
                and old_ie.text_sha1 == new_sha1):
132
 
                ## assert content == basis.get_file(file_id).read()
133
 
                entry.text_id = old_ie.text_id
134
 
                entry.text_sha1 = new_sha1
135
 
                entry.text_size = old_ie.text_size
136
 
                mutter('    unchanged from previous text_id {%s}' %
137
 
                       entry.text_id)
138
 
            else:
139
 
                content = file(p, 'rb').read()
140
 
 
141
 
                entry.text_sha1 = sha_string(content)
142
 
                entry.text_size = len(content)
143
 
 
144
 
                entry.text_id = gen_file_id(entry.name)
145
 
                branch.text_store.add(content, entry.text_id)
146
 
                mutter('    stored with text_id {%s}' % entry.text_id)
147
 
                if verbose:
148
 
                    if not old_ie:
149
 
                        print('added %s' % path)
150
 
                    elif (old_ie.name == entry.name
151
 
                          and old_ie.parent_id == entry.parent_id):
152
 
                        print('modified %s' % path)
153
 
                    else:
154
 
                        print('renamed %s' % path)
155
 
 
156
 
 
157
 
    for file_id in missing_ids:
158
 
        # Any files that have been deleted are now removed from the
159
 
        # working inventory.  Files that were not selected for commit
160
 
        # are left as they were in the working inventory and ommitted
161
 
        # from the revision inventory.
162
 
        
163
 
        # have to do this later so we don't mess up the iterator.
164
 
        # since parents may be removed before their children we
165
 
        # have to test.
166
 
 
167
 
        # FIXME: There's probably a better way to do this; perhaps
168
 
        # the workingtree should know how to filter itbranch.
169
 
        if work_inv.has_id(file_id):
170
 
            del work_inv[file_id]
171
 
 
172
 
 
173
 
    if rev_id is None:
174
 
        rev_id = _gen_revision_id(time.time())
175
 
    inv_id = rev_id
176
 
 
177
 
    inv_tmp = tempfile.TemporaryFile()
178
 
    inv.write_xml(inv_tmp)
179
 
    inv_tmp.seek(0)
180
 
    branch.inventory_store.add(inv_tmp, inv_id)
181
 
    mutter('new inventory_id is {%s}' % inv_id)
182
 
 
183
 
    branch._write_inventory(work_inv)
184
 
 
185
 
    if timestamp == None:
186
 
        timestamp = time.time()
187
 
 
188
 
    if committer == None:
189
 
        committer = username()
190
 
 
191
 
    if timezone == None:
192
 
        timezone = local_time_offset()
193
 
 
194
 
    mutter("building commit log message")
195
 
    rev = Revision(timestamp=timestamp,
196
 
                   timezone=timezone,
197
 
                   committer=committer,
198
 
                   precursor = branch.last_patch(),
199
 
                   message = message,
200
 
                   inventory_id=inv_id,
201
 
                   revision_id=rev_id)
202
 
 
203
 
    rev_tmp = tempfile.TemporaryFile()
204
 
    rev.write_xml(rev_tmp)
205
 
    rev_tmp.seek(0)
206
 
    branch.revision_store.add(rev_tmp, rev_id)
207
 
    mutter("new revision_id is {%s}" % rev_id)
208
 
 
209
 
    ## XXX: Everything up to here can simply be orphaned if we abort
210
 
    ## the commit; it will leave junk files behind but that doesn't
211
 
    ## matter.
212
 
 
213
 
    ## TODO: Read back the just-generated changeset, and make sure it
214
 
    ## applies and recreates the right state.
215
 
 
216
 
    ## TODO: Also calculate and store the inventory SHA1
217
 
    mutter("committing patch r%d" % (branch.revno() + 1))
218
 
 
219
 
    branch.append_revision(rev_id)
220
 
 
221
 
    if verbose:
222
 
        note("commited r%d" % branch.revno())
223
 
 
224
 
 
225
 
 
226
 
def _gen_revision_id(when):
227
 
    """Return new revision-id."""
228
 
    from binascii import hexlify
229
 
    from osutils import rand_bytes, compact_date, user_email
230
 
 
231
 
    s = '%s-%s-' % (user_email(), compact_date(when))
232
 
    s += hexlify(rand_bytes(8))
233
 
    return s
234
 
 
235