~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

Committer: Johan Walles
Date: 2009-05-07 05:08:46 UTC
mfrom: (4342 +trunk)
mto: This revision was merged to the branch mainline in revision 4343.
Revision ID: johan.walles@gmail.com-20090507050846-nkwvcyauf1eh653q

Merge from upstream.

Show diffs side-by-side

added added

removed removed

bzrlib/branch.py

845

raise errors.NoSuchRevision(self, revno)

846

return history[revno - 1]

847

848

@needs_write_lock

848

849

def pull(self, source, overwrite=False, stop_revision=None,

849

possible_transports=None, _override_hook_target=None):

850

possible_transports=None, *args, **kwargs):

850

851

"""Mirror source into this branch.

851

852

853

This branch is considered to be 'local', having low latency.

853

854

855

:returns: PullResult instance

855

856

"""

856

raise NotImplementedError(self.pull)

857

return InterBranch.get(source, self).pull(overwrite=overwrite,

858

stop_revision=stop_revision,

859

possible_transports=possible_transports, *args, **kwargs)

857

860

858

861

def push(self, target, overwrite=False, stop_revision=None, *args,

859

862

**kwargs):

2177

2180

"""See Branch.basis_tree."""

2178

2181

return self.repository.revision_tree(self.last_revision())

2179

2182

2180

@needs_write_lock

2181

def pull(self, source, overwrite=False, stop_revision=None,

2182

_hook_master=None, run_hooks=True, possible_transports=None,

2183

_override_hook_target=None):

2184

"""See Branch.pull.

2185

2186

:param _hook_master: Private parameter - set the branch to

2187

be supplied as the master to pull hooks.

2188

:param run_hooks: Private parameter - if false, this branch

2189

is being called because it's the master of the primary branch,

2190

so it should not run its hooks.

2191

:param _override_hook_target: Private parameter - set the branch to be

2192

supplied as the target_branch to pull hooks.

2193

"""

2194

result = PullResult()

2195

result.source_branch = source

2196

if _override_hook_target is None:

2197

result.target_branch = self

2198

else:

2199

result.target_branch = _override_hook_target

2200

source.lock_read()

2201

try:

2202

# We assume that during 'pull' the local repository is closer than

2203

# the remote one.

2204

source.update_references(self)

2205

graph = self.repository.get_graph(source.repository)

2206

result.old_revno, result.old_revid = self.last_revision_info()

2207

self.update_revisions(source, stop_revision, overwrite=overwrite,

2208

graph=graph)

2209

result.tag_conflicts = source.tags.merge_to(self.tags, overwrite)

2210

result.new_revno, result.new_revid = self.last_revision_info()

2211

if _hook_master:

2212

result.master_branch = _hook_master

2213

result.local_branch = result.target_branch

2214

else:

2215

result.master_branch = result.target_branch

2216

result.local_branch = None

2217

if run_hooks:

2218

for hook in Branch.hooks['post_pull']:

2219

hook(result)

2220

finally:

2221

source.unlock()

2222

return result

2223

2224

2183

def _get_parent_location(self):

2225

2184

_locs = ['parent', 'pull', 'x-pull']

2226

2185

for l in _locs:

2275

2234

It has support for a master_branch which is the data for bound branches.

2276

2235

"""

2277

2236

2278

@needs_write_lock

2279

def pull(self, source, overwrite=False, stop_revision=None,

2280

run_hooks=True, possible_transports=None,

2281

_override_hook_target=None):

2282

"""Pull from source into self, updating my master if any.

2283

2284

:param run_hooks: Private parameter - if false, this branch

2285

is being called because it's the master of the primary branch,

2286

so it should not run its hooks.

2287

"""

2288

bound_location = self.get_bound_location()

2289

master_branch = None

2290

if bound_location and source.base != bound_location:

2291

# not pulling from master, so we need to update master.

2292

master_branch = self.get_master_branch(possible_transports)

2293

master_branch.lock_write()

2294

try:

2295

if master_branch:

2296

# pull from source into master.

2297

master_branch.pull(source, overwrite, stop_revision,

2298

run_hooks=False)

2299

return super(BzrBranch5, self).pull(source, overwrite,

2300

stop_revision, _hook_master=master_branch,

2301

run_hooks=run_hooks,

2302

_override_hook_target=_override_hook_target)

2303

finally:

2304

if master_branch:

2305

master_branch.unlock()

2306

2307

2237

def get_bound_location(self):

2308

2238

try:

2309

2239

return self._transport.get_bytes('bound')[:-1]

2941

2871

"""Return a tuple with the Branch formats to use when testing."""

2942

2872

raise NotImplementedError(self._get_branch_formats_to_test)

2943

2873

2874

def pull(self, overwrite=False, stop_revision=None,

2875

possible_transports=None, local=False):

2876

"""Mirror source into target branch.

2877

2878

The target branch is considered to be 'local', having low latency.

2879

2880

:returns: PullResult instance

2881

"""

2882

raise NotImplementedError(self.pull)

2883

2944

2884

def update_revisions(self, stop_revision=None, overwrite=False,

2945

2885

graph=None):

2946

2886

"""Pull in new perfect-fit revisions.

3014

2954

finally:

3015

2955

self.source.unlock()

3016

2956

2957

def pull(self, overwrite=False, stop_revision=None,

2958

possible_transports=None, _hook_master=None, run_hooks=True,

2959

_override_hook_target=None, local=False):

2960

"""See Branch.pull.

2961

2962

:param _hook_master: Private parameter - set the branch to

2963

be supplied as the master to pull hooks.

2964

:param run_hooks: Private parameter - if false, this branch

2965

is being called because it's the master of the primary branch,

2966

so it should not run its hooks.

2967

:param _override_hook_target: Private parameter - set the branch to be

2968

supplied as the target_branch to pull hooks.

2969

:param local: Only update the local branch, and not the bound branch.

2970

"""

2971

# This type of branch can't be bound.

2972

if local:

2973

raise errors.LocalRequiresBoundBranch()

2974

result = PullResult()

2975

result.source_branch = self.source

2976

if _override_hook_target is None:

2977

result.target_branch = self.target

2978

else:

2979

result.target_branch = _override_hook_target

2980

self.source.lock_read()

2981

try:

2982

# We assume that during 'pull' the target repository is closer than

2983

# the source one.

2984

self.source.update_references(self.target)

2985

graph = self.target.repository.get_graph(self.source.repository)

2986

# TODO: Branch formats should have a flag that indicates

2987

# that revno's are expensive, and pull() should honor that flag.

2988

# -- JRV20090506

2989

result.old_revno, result.old_revid = \

2990

self.target.last_revision_info()

2991

self.target.update_revisions(self.source, stop_revision,

2992

overwrite=overwrite, graph=graph)

2993

# TODO: The old revid should be specified when merging tags,

2994

# so a tags implementation that versions tags can only

2995

# pull in the most recent changes. -- JRV20090506

2996

result.tag_conflicts = self.source.tags.merge_to(self.target.tags,

2997

overwrite)

2998

result.new_revno, result.new_revid = self.target.last_revision_info()

2999

if _hook_master:

3000

result.master_branch = _hook_master

3001

result.local_branch = result.target_branch

3002

else:

3003

result.master_branch = result.target_branch

3004

result.local_branch = None

3005

if run_hooks:

3006

for hook in Branch.hooks['post_pull']:

3007

hook(result)

3008

finally:

3009

self.source.unlock()

3010

return result

3011

3017

3012

def push(self, overwrite=False, stop_revision=None,

3018

3013

_override_hook_source_branch=None):

3019

3014

"""See InterBranch.push.

3035

3030

_override_hook_source_branch=_override_hook_source_branch)

3036

3031

finally:

3037

3032

self.source.unlock()

3033

return result

3038

3034

3039

3035

def _push_with_bound_branches(self, overwrite, stop_revision,

3040

3036

_override_hook_source_branch=None):

3086

3082

return True

3087

3083

3088

3084

3085

class InterToBranch5(GenericInterBranch):

3086

3087

@staticmethod

3088

def _get_branch_formats_to_test():

3089

return BranchFormat._default_format, BzrBranchFormat5()

3090

3091

def pull(self, overwrite=False, stop_revision=None,

3092

possible_transports=None, run_hooks=True,

3093

_override_hook_target=None, local=False):

3094

"""Pull from source into self, updating my master if any.

3095

3096

:param run_hooks: Private parameter - if false, this branch

3097

is being called because it's the master of the primary branch,

3098

so it should not run its hooks.

3099

"""

3100

bound_location = self.target.get_bound_location()

3101

if local and not bound_location:

3102

raise errors.LocalRequiresBoundBranch()

3103

master_branch = None

3104

if not local and bound_location and self.source.base != bound_location:

3105

# not pulling from master, so we need to update master.

3106

master_branch = self.target.get_master_branch(possible_transports)

3107

master_branch.lock_write()

3108

try:

3109

if master_branch:

3110

# pull from source into master.

3111

master_branch.pull(self.source, overwrite, stop_revision,

3112

run_hooks=False)

3113

return super(InterToBranch5, self).pull(overwrite,

3114

stop_revision, _hook_master=master_branch,

3115

run_hooks=run_hooks,

3116

_override_hook_target=_override_hook_target)

3117

finally:

3118

if master_branch:

3119

master_branch.unlock()

3120

3121

3089

3122

InterBranch.register_optimiser(GenericInterBranch)

3123

InterBranch.register_optimiser(InterToBranch5)

Older »