~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Martin Pool
  • Date: 2005-05-13 00:57:32 UTC
  • Revision ID: mbp@sourcefrog.net-20050513005732-26b0a3042cbb57d1
- more notes on tagging

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