public SideBandInputStream(PacketLineIn aPckIn, Stream aIns, ProgressMonitor aProgress)
 {
     pckIn = aPckIn;
     ins = aIns;
     monitor = aProgress;
     currentTask = "";
 }

 public SideBandInputStream(PacketLineIn aPckIn, Stream aIns, ProgressMonitor aProgress)
 {
     pckIn = aPckIn;
     ins = aIns;
     monitor = aProgress;
     currentTask = string.Empty;
     progressBuffer = string.Empty;
 }

		internal AggregatedProgressMonitor (ProgressMonitor leaderMonitor, CancellationTokenSource cancelSource, params ProgressMonitor[] followerMonitors)
		{
			CancellationTokenSource = cancelSource ?? new CancellationTokenSource ();
			this.leaderMonitor = leaderMonitor;
			AddFollowerMonitor (leaderMonitor, MonitorAction.All);
			foreach (ProgressMonitor mon in followerMonitors)
				AddFollowerMonitor (mon);
		}

		internal AggregatedProgressMonitor (ProgressMonitor masterMonitor, CancellationTokenSource cancelSource, params ProgressMonitor[] slaveMonitors)
		{
			CancellationTokenSource = cancelSource ?? new CancellationTokenSource ();
			this.masterMonitor = masterMonitor;
			AddSlaveMonitor (masterMonitor, MonitorAction.All);
			foreach (ProgressMonitor mon in slaveMonitors)
				AddSlaveMonitor (mon);
		}

        public ComputeRelativeTimesProgressMonitor(ProgressMonitor next, Action<string> writer = null)
        {
            if (writer == null)
                writer = s => Debug.WriteLine(s);

            this.next = next;
            this.writer = writer;
        }

		public SideBandInputStream(Stream @in, ProgressMonitor progress)
		{
			rawIn = @in;
			pckIn = new PacketLineIn(rawIn);
			monitor = progress;
			currentTask = string.Empty;
			progressBuffer = string.Empty;
		}

        internal virtual void execute(ProgressMonitor monitor, FetchResult result)
        {
            _askFor.Clear();
            _localUpdates.Clear();
            _fetchHeadUpdates.Clear();
            _packLocks.Clear();

            try
            {
                executeImp(monitor, result);
            }
            finally
            {
                foreach (PackLock @lock in _packLocks)
                {
                    @lock.Unlock();
                }
            }
        }

        public PushResult execute(ProgressMonitor monitor)
        {
            monitor.BeginTask(PROGRESS_OPENING_CONNECTION, -1);
            connection = transport.openPush();
            try
            {
                monitor.EndTask();

                Dictionary<string, RemoteRefUpdate> preprocessed = prepareRemoteUpdates();
                if (transport.DryRun)
                    modifyUpdatesForDryRun();
                else if (preprocessed.Count != 0)
                    connection.Push(monitor, preprocessed);
            }
            finally
            {
                connection.Close();
            }
            if (!transport.DryRun)
                updateTrackingRefs();
            return prepareOperationResult();
        }

        private void WriteCommands(IEnumerable<RemoteRefUpdate> refUpdates, ProgressMonitor monitor)
        {
            string capabilities = EnableCapabilities();
            foreach (RemoteRefUpdate rru in refUpdates)
            {
                if (!_capableDeleteRefs && rru.IsDelete)
                {
                    rru.Status = RemoteRefUpdate.UpdateStatus.REJECTED_NODELETE;
                    continue;
                }

                var sb = new StringBuilder();
                Ref advertisedRef = GetRef(rru.RemoteName);
                ObjectId oldId = (advertisedRef == null ? ObjectId.ZeroId : advertisedRef.ObjectId);
                sb.Append(oldId.Name);
                sb.Append(' ');
                sb.Append(rru.NewObjectId.Name);
                sb.Append(' ');
                sb.Append(rru.RemoteName);
                if (!_sentCommand)
                {
                    _sentCommand = true;
                    sb.Append(capabilities);
                }

                pckOut.WriteString(sb.ToString());
                rru.Status = RemoteRefUpdate.UpdateStatus.AWAITING_REPORT;
                if (!rru.IsDelete)
                    _shouldWritePack = true;
            }

            if (monitor.IsCancelled)
                throw new TransportException(uri, "push cancelled");
            pckOut.End();
            outNeedsEnd = false;
        }

 public void Push(ProgressMonitor monitor, IDictionary<string, RemoteRefUpdate> refUpdates)
 {
     markStartedOperation();
     doPush(monitor, refUpdates);
 }

        public PushResult push(ProgressMonitor monitor, ICollection<RemoteRefUpdate> toPush)
        {
            if (toPush == null || toPush.Count == 0)
            {
                try
                {
                    toPush = findRemoteRefUpdatesFor(_pushSpecs);
                }
                catch (IOException e)
                {
                    throw new TransportException("Problem with resolving push ref specs locally: " + e.Message, e);
                }

                if (toPush.Count == 0)
                {
                    throw new TransportException("Nothing to push");
                }
            }

            var pushProcess = new PushProcess(this, toPush);
            return pushProcess.execute(monitor);
        }

        ///	<summary>
        /// Perform push operation between local and remote repository - set remote
        /// refs appropriately, send needed objects and update local tracking refs.
        /// <para />
        /// When <seealso cref="Transport.DryRun"/> is true, result of this operation is
        /// just estimation of real operation result, no real action is performed.
        /// </summary>
        /// <param name="monitor">
        /// Progress monitor used for feedback about operation.
        /// </param>
        /// <returns> result of push operation with complete status description. </returns>
        /// <exception cref="NotSupportedException">
        /// When push operation is not supported by provided transport.
        /// </exception>
        /// <exception cref="TransportException">
        /// When some error occurred during operation, like I/O, protocol
        /// error, or local database consistency error.
        /// </exception>
        public PushResult execute(ProgressMonitor monitor)
        {
            if (monitor == null)
                throw new ArgumentNullException("monitor");

            monitor.BeginTask(PROGRESS_OPENING_CONNECTION, ProgressMonitor.UNKNOWN);
            _connection = _transport.openPush();

            try
            {
                monitor.EndTask();

                IDictionary<string, RemoteRefUpdate> preprocessed = PrepareRemoteUpdates();
                if (_transport.DryRun)
                {
                    ModifyUpdatesForDryRun();
                }
                else if (preprocessed.Count != 0)
                {
                    _connection.Push(monitor, preprocessed);
                }
            }
            finally
            {
                _connection.Close();
            }

            if (!_transport.DryRun)
            {
                UpdateTrackingRefs();
            }

            return PrepareOperationResult();
        }

		public FilteredProgressMonitor (ProgressMonitor targetMonitor)
			: this (targetMonitor, MonitorAction.WriteLog | MonitorAction.ReportError | MonitorAction.ReportWarning | MonitorAction.ReportSuccess | MonitorAction.Cancel | MonitorAction.SlaveCancel)
		{
		}

 public void Fetch(ProgressMonitor monitor, ICollection<Ref> want, IList<ObjectId> have)
 {
     markStartedOperation();
     doFetch(monitor, want, have);
 }

 private void ResolveDeltas(ProgressMonitor progress)
 {
     progress.BeginTask(PROGRESS_RESOLVE_DELTA, _deltaCount);
     int last = _entryCount;
     for (int i = 0; i < last; i++)
     {
         int before = _entryCount;
         ResolveDeltas(_entries[i]);
         progress.Update(_entryCount - before);
         if (progress.IsCancelled)
         {
             throw new IOException("Download cancelled during indexing");
         }
     }
     progress.EndTask();
 }

 public void DownloadPack(ProgressMonitor monitor)
 {
     Stream s = _connection.open("pack/" + PackName);
     IndexPack ip = IndexPack.Create(_local, s);
     ip.setFixThin(false);
     ip.setObjectChecker(_objCheck);
     ip.index(monitor);
     PackLock keep = ip.renameAndOpenPack(_lockMessage);
     if (keep != null)
     {
         _packLocks.Add(keep);
     }
 }

            public void OpenIndex(ProgressMonitor pm)
            {
                if (Index != null) return;

                try
                {
                    Index = PackIndex.Open(TmpIdx);
                    return;
                }
                catch (FileNotFoundException)
                {

                }

                Stream s = _connection.open("pack/" + _idxName);
                pm.BeginTask("Get " + _idxName.Slice(0, 12) + "..idx", s.Length < 0 ? -1 : (int)(s.Length / 1024));
                try
                {
                    var fos = new FileStream(TmpIdx.ToString(), System.IO.FileMode.Open, FileAccess.ReadWrite);
                    try
                    {
                        var buf = new byte[2048];
                        int cnt;
                        while (!pm.IsCancelled && (cnt = s.Read(buf, 0, buf.Length)) >= 0)
                        {
                            fos.Write(buf, 0, cnt);
                            pm.Update(cnt / 1024);
                        }
                    }
                    finally
                    {
                        fos.Close();
                    }
                }
                catch (IOException)
                {
                    TmpIdx.Delete();
                    throw;
                }
                finally
                {
                    s.Close();
                }
                pm.EndTask();

                if (pm.IsCancelled)
                {
                    TmpIdx.Delete();
                    return;
                }

                try
                {
                    Index = PackIndex.Open(TmpIdx);
                }
                catch (IOException)
                {
                    TmpIdx.Delete();
                    throw;
                }
            }

 /// <summary>
 /// Implementation of <see cref="Fetch"/>
 /// without checking for multiple fetch.
 /// </summary>
 /// <param name="monitor">as in <see cref="Fetch"/></param>
 /// <param name="want">as in <see cref="Fetch"/></param>
 /// <param name="have">as in <see cref="Fetch"/></param>
 protected abstract void doFetch(ProgressMonitor monitor, ICollection<Ref> want, IList<ObjectId> have);

        private void writePack(IDictionary<string, RemoteRefUpdate> refUpdates, ProgressMonitor monitor)
        {
            PackWriter writer = new PackWriter(local, monitor);
            List<ObjectId> remoteObjects = new List<ObjectId>(Refs.Count);
            List<ObjectId> newObjects = new List<ObjectId>(refUpdates.Count);

            foreach (Ref r in Refs)
                remoteObjects.Add(r.ObjectId);

            remoteObjects.AddRange(additionalHaves);
            foreach (RemoteRefUpdate r in refUpdates.Values)
            {
                if (!ObjectId.ZeroId.Equals(r.NewObjectId))
                    newObjects.Add(r.NewObjectId);
            }

            writer.Thin = _thinPack;
            writer.DeltaBaseAsOffset = _capableOfsDelta;
            writer.preparePack(newObjects, remoteObjects);
            writer.writePack(stream);
        }

 public Stream sideband(ProgressMonitor pm)
 {
     return new SideBandInputStream(this, ins, pm);
 }