private void executeImp(ProgressMonitor monitor, FetchResult result)
{
_connection = _transport.openFetch();
try
{
result.SetAdvertisedRefs(_transport.Uri, _connection.RefsMap);
HashSet<Ref> matched = new HashSet<Ref>();
foreach (RefSpec spec in _toFetch)
{
if (spec.Source == null)
throw new TransportException("Source ref not specified for refspec: " + spec);
if (spec.Wildcard)
{
expandWildcard(spec, matched);
}
else
{
expandSingle(spec, matched);
}
}
ICollection<Ref> additionalTags = new Collection<Ref>();
TagOpt tagopt = _transport.TagOpt;
if (tagopt == TagOpt.AUTO_FOLLOW)
{
additionalTags = expandAutoFollowTags();
}
else if (tagopt == TagOpt.FETCH_TAGS)
{
expandFetchTags();
}
bool includedTags;
if (_askFor.Count != 0 && !askForIsComplete())
{
fetchObjects(monitor);
includedTags = _connection.DidFetchIncludeTags;
// Connection was used for object transfer. If we
// do another fetch we must open a new connection.
//
closeConnection();
}
else
{
includedTags = false;
}
if (tagopt == TagOpt.AUTO_FOLLOW && additionalTags.Count != 0)
{
// There are more tags that we want to follow, but
// not all were asked for on the initial request.
foreach(ObjectId key in _askFor.Keys)
{
_have.Add(key);
}
_askFor.Clear();
foreach (Ref r in additionalTags)
{
ObjectId id = r.PeeledObjectId;
if (id == null || _transport.Local.HasObject(id))
{
wantTag(r);
}
}
if (_askFor.Count != 0 && (!includedTags || !askForIsComplete()))
{
reopenConnection();
if (_askFor.Count != 0)
{
fetchObjects(monitor);
}
}
}
}
finally
{
closeConnection();
}
RevWalk.RevWalk walk = new RevWalk.RevWalk(_transport.Local);
if (_transport.RemoveDeletedRefs)
{
deleteStaleTrackingRefs(result, walk);
}
foreach (TrackingRefUpdate u in _localUpdates)
{
try
{
u.Update(walk);
result.Add(u);
}
catch (IOException err)
{
throw new TransportException("Failure updating tracking ref " + u.LocalName + ": " + err.Message, err);
}
}
if (_fetchHeadUpdates.Count != 0)
{
try
{
updateFETCH_HEAD(result);
}
catch (IOException err)
{
throw new TransportException("Failure updating FETCH_HEAD: " + err.Message, err);
}
}
}
private void updateFETCH_HEAD(FetchResult result)
{
LockFile @lock = new LockFile(new FileInfo(Path.Combine(_transport.Local.Directory.FullName, "FETCH_HEAD")));
try
{
if (@lock.Lock())
{
StreamWriter w = new StreamWriter(@lock.GetOutputStream());
try
{
foreach (FetchHeadRecord h in _fetchHeadUpdates)
{
h.Write(w);
result.Add(h);
}
}
finally
{
w.Close();
}
@lock.Commit();
}
}
finally
{
@lock.Unlock();
}
}
private void deleteTrackingRef(FetchResult result, Repository db, RevWalk.RevWalk walk, RefSpec spec, Ref localRef)
{
string name = localRef.Name;
try
{
TrackingRefUpdate u = new TrackingRefUpdate(db, name, spec.Source, true, ObjectId.ZeroId, "deleted");
result.Add(u);
if (_transport.DryRun)
{
return;
}
u.Delete(walk);
switch (u.Result)
{
case RefUpdate.RefUpdateResult.New:
case RefUpdate.RefUpdateResult.NoChange:
case RefUpdate.RefUpdateResult.FastForward:
case RefUpdate.RefUpdateResult.Forced:
break;
default:
throw new TransportException(_transport.Uri, "Cannot delete stale tracking ref " + name + ": " + u.Result.ToString());
}
}
catch (System.IO.IOException e)
{
throw new TransportException(_transport.Uri, "Cannot delete stale tracking ref " + name, e);
}
}
