示例#1
0
		internal PullResult(FetchResult fetchResult, string fetchedFrom, MergeCommandResult
			 mergeResult)
		{
			this.fetchResult = fetchResult;
			this.fetchedFrom = fetchedFrom;
			this.mergeResult = mergeResult;
		}
示例#2
0
		internal PullResult(FetchResult fetchResult, string fetchedFrom, RebaseResult rebaseResult
			)
		{
			this.fetchResult = fetchResult;
			this.fetchedFrom = fetchedFrom;
			this.mergeResult = null;
			this.rebaseResult = rebaseResult;
		}
示例#3
0
        /// <exception cref="NGit.Errors.TransportException"></exception>
        private void DeleteStaleTrackingRefs(FetchResult result, RevWalk walk)
        {
            Repository db = transport.local;

            foreach (Ref @ref in db.GetAllRefs().Values)
            {
                string refname = @ref.GetName();
                foreach (RefSpec spec in toFetch)
                {
                    if (spec.MatchDestination(refname))
                    {
                        RefSpec s = spec.ExpandFromDestination(refname);
                        if (result.GetAdvertisedRef(s.GetSource()) == null)
                        {
                            DeleteTrackingRef(result, db, walk, s, @ref);
                        }
                    }
                }
            }
        }
示例#4
0
        /// <exception cref="NGit.Errors.TransportException"></exception>
        private void DeleteTrackingRef(FetchResult result, Repository db, RevWalk walk, RefSpec
                                       spec, Ref localRef)
        {
            string name = localRef.GetName();

            try
            {
                TrackingRefUpdate u = new TrackingRefUpdate(db, name, spec.GetSource(), true, ObjectId
                                                            .ZeroId, "deleted");
                result.Add(u);
                if (transport.IsDryRun())
                {
                    return;
                }
                u.Delete(walk);
                switch (u.GetResult())
                {
                case RefUpdate.Result.NEW:
                case RefUpdate.Result.NO_CHANGE:
                case RefUpdate.Result.FAST_FORWARD:
                case RefUpdate.Result.FORCED:
                {
                    break;
                }

                default:
                {
                    throw new TransportException(transport.GetURI(), MessageFormat.Format(JGitText.Get
                                                                                              ().cannotDeleteStaleTrackingRef2, name, u.GetResult().ToString()));
                }
                }
            }
            catch (IOException e)
            {
                throw new TransportException(transport.GetURI(), MessageFormat.Format(JGitText.Get
                                                                                          ().cannotDeleteStaleTrackingRef, name), e);
            }
        }
示例#5
0
        /// <exception cref="System.IO.IOException"></exception>
        private void UpdateFETCH_HEAD(FetchResult result)
        {
            FilePath meta = transport.local.Directory;

            if (meta == null)
            {
                return;
            }
            LockFile Lock = new LockFile(new FilePath(meta, "FETCH_HEAD"), transport.local.FileSystem
                                         );

            try
            {
                if (Lock.Lock())
                {
                    TextWriter w = new OutputStreamWriter(Lock.GetOutputStream());
                    try
                    {
                        foreach (FetchHeadRecord h in fetchHeadUpdates)
                        {
                            h.Write(w);
                            result.Add(h);
                        }
                    }
                    finally
                    {
                        w.Close();
                    }
                    Lock.Commit();
                }
            }
            finally
            {
                Lock.Unlock();
            }
        }
示例#6
0
        /// <exception cref="System.NotSupportedException"></exception>
        /// <exception cref="NGit.Errors.TransportException"></exception>
        private void ExecuteImp(ProgressMonitor monitor, FetchResult result)
        {
            conn = transport.OpenFetch();
            try
            {
                result.SetAdvertisedRefs(transport.GetURI(), conn.GetRefsMap());
                ICollection <Ref> matched = new HashSet <Ref>();
                foreach (RefSpec spec in toFetch)
                {
                    if (spec.GetSource() == null)
                    {
                        throw new TransportException(MessageFormat.Format(JGitText.Get().sourceRefNotSpecifiedForRefspec
                                                                          , spec));
                    }
                    if (spec.IsWildcard())
                    {
                        ExpandWildcard(spec, matched);
                    }
                    else
                    {
                        ExpandSingle(spec, matched);
                    }
                }
                ICollection <Ref> additionalTags = Sharpen.Collections.EmptyList <Ref>();
                TagOpt            tagopt         = transport.GetTagOpt();
                if (tagopt == TagOpt.AUTO_FOLLOW)
                {
                    additionalTags = ExpandAutoFollowTags();
                }
                else
                {
                    if (tagopt == TagOpt.FETCH_TAGS)
                    {
                        ExpandFetchTags();
                    }
                }
                bool includedTags;
                if (!askFor.IsEmpty() && !AskForIsComplete())
                {
                    FetchObjects(monitor);
                    includedTags = conn.DidFetchIncludeTags();
                    // Connection was used for object transfer. If we
                    // do another fetch we must open a new connection.
                    //
                    CloseConnection(result);
                }
                else
                {
                    includedTags = false;
                }
                if (tagopt == TagOpt.AUTO_FOLLOW && !additionalTags.IsEmpty())
                {
                    // There are more tags that we want to follow, but
                    // not all were asked for on the initial request.
                    //
                    Sharpen.Collections.AddAll(have, askFor.Keys);
                    askFor.Clear();
                    foreach (Ref r in additionalTags)
                    {
                        ObjectId id = r.GetPeeledObjectId();
                        if (id == null || transport.local.HasObject(id))
                        {
                            WantTag(r);
                        }
                    }
                    if (!askFor.IsEmpty() && (!includedTags || !AskForIsComplete()))
                    {
                        ReopenConnection();
                        if (!askFor.IsEmpty())
                        {
                            FetchObjects(monitor);
                        }
                    }
                }
            }
            finally
            {
                CloseConnection(result);
            }
            RevWalk walk = new RevWalk(transport.local);

            try
            {
                if (transport.IsRemoveDeletedRefs())
                {
                    DeleteStaleTrackingRefs(result, walk);
                }
                foreach (TrackingRefUpdate u in localUpdates)
                {
                    try
                    {
                        u.Update(walk);
                        result.Add(u);
                    }
                    catch (IOException err)
                    {
                        throw new TransportException(MessageFormat.Format(JGitText.Get().failureUpdatingTrackingRef
                                                                          , u.GetLocalName(), err.Message), err);
                    }
                }
            }
            finally
            {
                walk.Release();
            }
            if (!fetchHeadUpdates.IsEmpty())
            {
                try
                {
                    UpdateFETCH_HEAD(result);
                }
                catch (IOException err)
                {
                    throw new TransportException(MessageFormat.Format(JGitText.Get().failureUpdatingFETCH_HEAD
                                                                      , err.Message), err);
                }
            }
        }
示例#7
0
 /// <exception cref="System.IO.IOException"></exception>
 private void UpdateFETCH_HEAD(FetchResult result)
 {
     FilePath meta = transport.local.Directory;
     if (meta == null)
     {
         return;
     }
     LockFile Lock = new LockFile(new FilePath(meta, "FETCH_HEAD"), transport.local.FileSystem
         );
     try
     {
         if (Lock.Lock())
         {
             TextWriter w = new OutputStreamWriter(Lock.GetOutputStream());
             try
             {
                 foreach (FetchHeadRecord h in fetchHeadUpdates)
                 {
                     h.Write(w);
                     result.Add(h);
                 }
             }
             finally
             {
                 w.Close();
             }
             Lock.Commit();
         }
     }
     finally
     {
         Lock.Unlock();
     }
 }
示例#8
0
 /// <exception cref="System.NotSupportedException"></exception>
 /// <exception cref="NGit.Errors.TransportException"></exception>
 private void ExecuteImp(ProgressMonitor monitor, FetchResult result)
 {
     conn = transport.OpenFetch();
     try
     {
         result.SetAdvertisedRefs(transport.GetURI(), conn.GetRefsMap());
         ICollection<Ref> matched = new HashSet<Ref>();
         foreach (RefSpec spec in toFetch)
         {
             if (spec.GetSource() == null)
             {
                 throw new TransportException(MessageFormat.Format(JGitText.Get().sourceRefNotSpecifiedForRefspec
                     , spec));
             }
             if (spec.IsWildcard())
             {
                 ExpandWildcard(spec, matched);
             }
             else
             {
                 ExpandSingle(spec, matched);
             }
         }
         ICollection<Ref> additionalTags = Sharpen.Collections.EmptyList<Ref>();
         TagOpt tagopt = transport.GetTagOpt();
         if (tagopt == TagOpt.AUTO_FOLLOW)
         {
             additionalTags = ExpandAutoFollowTags();
         }
         else
         {
             if (tagopt == TagOpt.FETCH_TAGS)
             {
                 ExpandFetchTags();
             }
         }
         bool includedTags;
         if (!askFor.IsEmpty() && !AskForIsComplete())
         {
             FetchObjects(monitor);
             includedTags = conn.DidFetchIncludeTags();
             // Connection was used for object transfer. If we
             // do another fetch we must open a new connection.
             //
             CloseConnection(result);
         }
         else
         {
             includedTags = false;
         }
         if (tagopt == TagOpt.AUTO_FOLLOW && !additionalTags.IsEmpty())
         {
             // There are more tags that we want to follow, but
             // not all were asked for on the initial request.
             //
             Sharpen.Collections.AddAll(have, askFor.Keys);
             askFor.Clear();
             foreach (Ref r in additionalTags)
             {
                 ObjectId id = r.GetPeeledObjectId();
                 if (id == null)
                 {
                     id = r.GetObjectId();
                 }
                 if (transport.local.HasObject(id))
                 {
                     WantTag(r);
                 }
             }
             if (!askFor.IsEmpty() && (!includedTags || !AskForIsComplete()))
             {
                 ReopenConnection();
                 if (!askFor.IsEmpty())
                 {
                     FetchObjects(monitor);
                 }
             }
         }
     }
     finally
     {
         CloseConnection(result);
     }
     RevWalk walk = new RevWalk(transport.local);
     try
     {
         if (monitor is BatchingProgressMonitor)
         {
             ((BatchingProgressMonitor)monitor).SetDelayStart(250, TimeUnit.MILLISECONDS);
         }
         monitor.BeginTask(JGitText.Get().updatingReferences, localUpdates.Count);
         if (transport.IsRemoveDeletedRefs())
         {
             DeleteStaleTrackingRefs(result, walk);
         }
         foreach (TrackingRefUpdate u in localUpdates)
         {
             try
             {
                 monitor.Update(1);
                 u.Update(walk);
                 result.Add(u);
             }
             catch (IOException err)
             {
                 throw new TransportException(MessageFormat.Format(JGitText.Get().failureUpdatingTrackingRef
                     , u.GetLocalName(), err.Message), err);
             }
         }
         monitor.EndTask();
     }
     finally
     {
         walk.Release();
     }
     if (!fetchHeadUpdates.IsEmpty())
     {
         try
         {
             UpdateFETCH_HEAD(result);
         }
         catch (IOException err)
         {
             throw new TransportException(MessageFormat.Format(JGitText.Get().failureUpdatingFETCH_HEAD
                 , err.Message), err);
         }
     }
 }
示例#9
0
        /// <exception cref="NGit.Errors.TransportException"></exception>
        private void DeleteTrackingRef(FetchResult result, Repository db, RevWalk walk, RefSpec
			 spec, Ref localRef)
        {
            string name = localRef.GetName();
            try
            {
                TrackingRefUpdate u = new TrackingRefUpdate(db, name, spec.GetSource(), true, ObjectId
                    .ZeroId, "deleted");
                result.Add(u);
                if (transport.IsDryRun())
                {
                    return;
                }
                u.Delete(walk);
                switch (u.GetResult())
                {
                    case RefUpdate.Result.NEW:
                    case RefUpdate.Result.NO_CHANGE:
                    case RefUpdate.Result.FAST_FORWARD:
                    case RefUpdate.Result.FORCED:
                    {
                        break;
                    }

                    default:
                    {
                        throw new TransportException(transport.GetURI(), MessageFormat.Format(JGitText.Get
                            ().cannotDeleteStaleTrackingRef2, name, u.GetResult().ToString()));
                    }
                }
            }
            catch (IOException e)
            {
                throw new TransportException(transport.GetURI(), MessageFormat.Format(JGitText.Get
                    ().cannotDeleteStaleTrackingRef, name), e);
            }
        }
示例#10
0
 private void CloseConnection(FetchResult result)
 {
     if (conn != null)
     {
         conn.Close();
         result.AddMessages(conn.GetMessages());
         conn = null;
     }
 }
示例#11
0
 /// <exception cref="System.NotSupportedException"></exception>
 /// <exception cref="NGit.Errors.TransportException"></exception>
 internal virtual void Execute(ProgressMonitor monitor, FetchResult result)
 {
     askFor.Clear();
     localUpdates.Clear();
     fetchHeadUpdates.Clear();
     packLocks.Clear();
     try
     {
         ExecuteImp(monitor, result);
     }
     finally
     {
         try
         {
             foreach (PackLock Lock in packLocks)
             {
                 Lock.Unlock();
             }
         }
         catch (IOException e)
         {
             throw new TransportException(e.Message, e);
         }
     }
 }
示例#12
0
		private void DeleteTrackingRef(FetchResult result, BatchRefUpdate batch, RefSpec 
			spec, Ref localRef)
		{
			if (localRef.GetObjectId() == null)
			{
				return;
			}
			TrackingRefUpdate update = new TrackingRefUpdate(true, spec.GetSource(), localRef
				.GetName(), localRef.GetObjectId(), ObjectId.ZeroId);
			result.Add(update);
			batch.AddCommand(update.AsReceiveCommand());
		}
示例#13
0
		/// <exception cref="System.IO.IOException"></exception>
		private void DeleteStaleTrackingRefs(FetchResult result, BatchRefUpdate batch)
		{
			foreach (Ref @ref in LocalRefs().Values)
			{
				string refname = @ref.GetName();
				foreach (RefSpec spec in toFetch)
				{
					if (spec.MatchDestination(refname))
					{
						RefSpec s = spec.ExpandFromDestination(refname);
						if (result.GetAdvertisedRef(s.GetSource()) == null)
						{
							DeleteTrackingRef(result, batch, s, @ref);
						}
					}
				}
			}
		}
示例#14
0
		/// <exception cref="System.NotSupportedException"></exception>
		/// <exception cref="NGit.Errors.TransportException"></exception>
		private void ExecuteImp(ProgressMonitor monitor, FetchResult result)
		{
			conn = transport.OpenFetch();
			try
			{
				result.SetAdvertisedRefs(transport.GetURI(), conn.GetRefsMap());
				ICollection<Ref> matched = new HashSet<Ref>();
				foreach (RefSpec spec in toFetch)
				{
					if (spec.GetSource() == null)
					{
						throw new TransportException(MessageFormat.Format(JGitText.Get().sourceRefNotSpecifiedForRefspec
							, spec));
					}
					if (spec.IsWildcard())
					{
						ExpandWildcard(spec, matched);
					}
					else
					{
						ExpandSingle(spec, matched);
					}
				}
				ICollection<Ref> additionalTags = Sharpen.Collections.EmptyList<Ref>();
				TagOpt tagopt = transport.GetTagOpt();
				if (tagopt == TagOpt.AUTO_FOLLOW)
				{
					additionalTags = ExpandAutoFollowTags();
				}
				else
				{
					if (tagopt == TagOpt.FETCH_TAGS)
					{
						ExpandFetchTags();
					}
				}
				bool includedTags;
				if (!askFor.IsEmpty() && !AskForIsComplete())
				{
					FetchObjects(monitor);
					includedTags = conn.DidFetchIncludeTags();
					// Connection was used for object transfer. If we
					// do another fetch we must open a new connection.
					//
					CloseConnection(result);
				}
				else
				{
					includedTags = false;
				}
				if (tagopt == TagOpt.AUTO_FOLLOW && !additionalTags.IsEmpty())
				{
					// There are more tags that we want to follow, but
					// not all were asked for on the initial request.
					//
					Sharpen.Collections.AddAll(have, askFor.Keys);
					askFor.Clear();
					foreach (Ref r in additionalTags)
					{
						ObjectId id = r.GetPeeledObjectId();
						if (id == null)
						{
							id = r.GetObjectId();
						}
						if (transport.local.HasObject(id))
						{
							WantTag(r);
						}
					}
					if (!askFor.IsEmpty() && (!includedTags || !AskForIsComplete()))
					{
						ReopenConnection();
						if (!askFor.IsEmpty())
						{
							FetchObjects(monitor);
						}
					}
				}
			}
			finally
			{
				CloseConnection(result);
			}
			BatchRefUpdate batch = transport.local.RefDatabase.NewBatchUpdate().SetAllowNonFastForwards
				(true).SetRefLogMessage("fetch", true);
			RevWalk walk = new RevWalk(transport.local);
			try
			{
				if (monitor is BatchingProgressMonitor)
				{
					((BatchingProgressMonitor)monitor).SetDelayStart(250, TimeUnit.MILLISECONDS);
				}
				if (transport.IsRemoveDeletedRefs())
				{
					DeleteStaleTrackingRefs(result, batch);
				}
				foreach (TrackingRefUpdate u in localUpdates)
				{
					result.Add(u);
					batch.AddCommand(u.AsReceiveCommand());
				}
				foreach (ReceiveCommand cmd in batch.GetCommands())
				{
					cmd.UpdateType(walk);
					if (cmd.GetType() == ReceiveCommand.Type.UPDATE_NONFASTFORWARD && cmd is TrackingRefUpdate.Command
						 && !((TrackingRefUpdate.Command)cmd).CanForceUpdate())
					{
						cmd.SetResult(ReceiveCommand.Result.REJECTED_NONFASTFORWARD);
					}
				}
				if (transport.IsDryRun())
				{
					foreach (ReceiveCommand cmd_1 in batch.GetCommands())
					{
						if (cmd_1.GetResult() == ReceiveCommand.Result.NOT_ATTEMPTED)
						{
							cmd_1.SetResult(ReceiveCommand.Result.OK);
						}
					}
				}
				else
				{
					batch.Execute(walk, monitor);
				}
			}
			catch (IOException err)
			{
				throw new TransportException(MessageFormat.Format(JGitText.Get().failureUpdatingTrackingRef
					, GetFirstFailedRefName(batch), err.Message), err);
			}
			finally
			{
				walk.Release();
			}
			if (!fetchHeadUpdates.IsEmpty())
			{
				try
				{
					UpdateFETCH_HEAD(result);
				}
				catch (IOException err)
				{
					throw new TransportException(MessageFormat.Format(JGitText.Get().failureUpdatingFETCH_HEAD
						, err.Message), err);
				}
			}
		}
示例#15
0
 /// <exception cref="NGit.Errors.TransportException"></exception>
 private void DeleteStaleTrackingRefs(FetchResult result, RevWalk walk)
 {
     Repository db = transport.local;
     foreach (Ref @ref in db.GetAllRefs().Values)
     {
         string refname = @ref.GetName();
         foreach (RefSpec spec in toFetch)
         {
             if (spec.MatchDestination(refname))
             {
                 RefSpec s = spec.ExpandFromDestination(refname);
                 if (result.GetAdvertisedRef(s.GetSource()) == null)
                 {
                     DeleteTrackingRef(result, db, walk, s, @ref);
                 }
             }
         }
     }
 }
示例#16
0
        /// <summary>Fetch objects and refs from the remote repository to the local one.</summary>
        /// <remarks>
        /// Fetch objects and refs from the remote repository to the local one.
        /// <p>
        /// This is a utility function providing standard fetch behavior. Local
        /// tracking refs associated with the remote repository are automatically
        /// updated if this transport was created from a
        /// <see cref="RemoteConfig">RemoteConfig</see>
        /// with
        /// fetch RefSpecs defined.
        /// </remarks>
        /// <param name="monitor">
        /// progress monitor to inform the user about our processing
        /// activity. Must not be null. Use
        /// <see cref="NGit.NullProgressMonitor">NGit.NullProgressMonitor</see>
        /// if
        /// progress updates are not interesting or necessary.
        /// </param>
        /// <param name="toFetch">
        /// specification of refs to fetch locally. May be null or the
        /// empty collection to use the specifications from the
        /// RemoteConfig. Source for each RefSpec can't be null.
        /// </param>
        /// <returns>information describing the tracking refs updated.</returns>
        /// <exception cref="System.NotSupportedException">
        /// this transport implementation does not support fetching
        /// objects.
        /// </exception>
        /// <exception cref="NGit.Errors.TransportException">
        /// the remote connection could not be established or object
        /// copying (if necessary) failed or update specification was
        /// incorrect.
        /// </exception>
        public virtual FetchResult Fetch(ProgressMonitor monitor, ICollection<RefSpec> toFetch
			)
        {
            if (toFetch == null || toFetch.IsEmpty())
            {
                // If the caller did not ask for anything use the defaults.
                //
                if (fetch.IsEmpty())
                {
                    throw new TransportException(JGitText.Get().nothingToFetch);
                }
                toFetch = fetch;
            }
            else
            {
                if (!fetch.IsEmpty())
                {
                    // If the caller asked for something specific without giving
                    // us the local tracking branch see if we can update any of
                    // the local tracking branches without incurring additional
                    // object transfer overheads.
                    //
                    ICollection<RefSpec> tmp = new AList<RefSpec>(toFetch);
                    foreach (RefSpec requested in toFetch)
                    {
                        string reqSrc = requested.GetSource();
                        foreach (RefSpec configured in fetch)
                        {
                            string cfgSrc = configured.GetSource();
                            string cfgDst = configured.GetDestination();
                            if (cfgSrc.Equals(reqSrc) && cfgDst != null)
                            {
                                tmp.AddItem(configured);
                                break;
                            }
                        }
                    }
                    toFetch = tmp;
                }
            }
            FetchResult result = new FetchResult();
            new FetchProcess(this, toFetch).Execute(monitor, result);
            return result;
        }
示例#17
0
        /// <exception cref="System.NotSupportedException"></exception>
        /// <exception cref="NGit.Errors.TransportException"></exception>
        private void ExecuteImp(ProgressMonitor monitor, FetchResult result)
        {
            conn = transport.OpenFetch();
            try
            {
                result.SetAdvertisedRefs(transport.GetURI(), conn.GetRefsMap());
                ICollection <Ref> matched = new HashSet <Ref>();
                foreach (RefSpec spec in toFetch)
                {
                    if (spec.GetSource() == null)
                    {
                        throw new TransportException(MessageFormat.Format(JGitText.Get().sourceRefNotSpecifiedForRefspec
                                                                          , spec));
                    }
                    if (spec.IsWildcard())
                    {
                        ExpandWildcard(spec, matched);
                    }
                    else
                    {
                        ExpandSingle(spec, matched);
                    }
                }
                ICollection <Ref> additionalTags = Sharpen.Collections.EmptyList <Ref>();
                TagOpt            tagopt         = transport.GetTagOpt();
                if (tagopt == TagOpt.AUTO_FOLLOW)
                {
                    additionalTags = ExpandAutoFollowTags();
                }
                else
                {
                    if (tagopt == TagOpt.FETCH_TAGS)
                    {
                        ExpandFetchTags();
                    }
                }
                bool includedTags;
                if (!askFor.IsEmpty() && !AskForIsComplete())
                {
                    FetchObjects(monitor);
                    includedTags = conn.DidFetchIncludeTags();
                    // Connection was used for object transfer. If we
                    // do another fetch we must open a new connection.
                    //
                    CloseConnection(result);
                }
                else
                {
                    includedTags = false;
                }
                if (tagopt == TagOpt.AUTO_FOLLOW && !additionalTags.IsEmpty())
                {
                    // There are more tags that we want to follow, but
                    // not all were asked for on the initial request.
                    //
                    Sharpen.Collections.AddAll(have, askFor.Keys);
                    askFor.Clear();
                    foreach (Ref r in additionalTags)
                    {
                        ObjectId id = r.GetPeeledObjectId();
                        if (id == null)
                        {
                            id = r.GetObjectId();
                        }
                        if (transport.local.HasObject(id))
                        {
                            WantTag(r);
                        }
                    }
                    if (!askFor.IsEmpty() && (!includedTags || !AskForIsComplete()))
                    {
                        ReopenConnection();
                        if (!askFor.IsEmpty())
                        {
                            FetchObjects(monitor);
                        }
                    }
                }
            }
            finally
            {
                CloseConnection(result);
            }
            BatchRefUpdate batch = transport.local.RefDatabase.NewBatchUpdate().SetAllowNonFastForwards
                                       (true).SetRefLogMessage("fetch", true);
            RevWalk walk = new RevWalk(transport.local);

            try
            {
                if (monitor is BatchingProgressMonitor)
                {
                    ((BatchingProgressMonitor)monitor).SetDelayStart(250, TimeUnit.MILLISECONDS);
                }
                if (transport.IsRemoveDeletedRefs())
                {
                    DeleteStaleTrackingRefs(result, batch);
                }
                foreach (TrackingRefUpdate u in localUpdates)
                {
                    result.Add(u);
                    batch.AddCommand(u.AsReceiveCommand());
                }
                foreach (ReceiveCommand cmd in batch.GetCommands())
                {
                    cmd.UpdateType(walk);
                    if (cmd.GetType() == ReceiveCommand.Type.UPDATE_NONFASTFORWARD && cmd is TrackingRefUpdate.Command &&
                        !((TrackingRefUpdate.Command)cmd).CanForceUpdate())
                    {
                        cmd.SetResult(ReceiveCommand.Result.REJECTED_NONFASTFORWARD);
                    }
                }
                if (transport.IsDryRun())
                {
                    foreach (ReceiveCommand cmd_1 in batch.GetCommands())
                    {
                        if (cmd_1.GetResult() == ReceiveCommand.Result.NOT_ATTEMPTED)
                        {
                            cmd_1.SetResult(ReceiveCommand.Result.OK);
                        }
                    }
                }
                else
                {
                    batch.Execute(walk, monitor);
                }
            }
            catch (IOException err)
            {
                throw new TransportException(MessageFormat.Format(JGitText.Get().failureUpdatingTrackingRef
                                                                  , GetFirstFailedRefName(batch), err.Message), err);
            }
            finally
            {
                walk.Release();
            }
            if (!fetchHeadUpdates.IsEmpty())
            {
                try
                {
                    UpdateFETCH_HEAD(result);
                }
                catch (IOException err)
                {
                    throw new TransportException(MessageFormat.Format(JGitText.Get().failureUpdatingFETCH_HEAD
                                                                      , err.Message), err);
                }
            }
        }