Esempio n. 1
0
 /// <exception cref="NGit.Errors.TransportException"></exception>
 public ForkLocalPushConnection(TransportLocal _enclosing)
     : base(_enclosing)
 {
     this._enclosing = _enclosing;
     MessageWriter msg = new MessageWriter();
     this.SetMessageWriter(msg);
     this.receivePack = this._enclosing.Spawn(this._enclosing.GetOptionReceivePack());
     InputStream rpErr = this.receivePack.GetErrorStream();
     this.errorReaderThread = new StreamCopyThread(rpErr, msg.GetRawStream());
     this.errorReaderThread.Start();
     InputStream rpIn = this.receivePack.GetInputStream();
     OutputStream rpOut = this.receivePack.GetOutputStream();
     rpIn = new BufferedInputStream(rpIn);
     rpOut = new SafeBufferedOutputStream(rpOut);
     this.Init(rpIn, rpOut);
     this.ReadAdvertisedRefs();
 }
Esempio n. 2
0
		/// <exception cref="System.IO.IOException"></exception>
		private static void Write(FilePath[] files, PackWriter pw)
		{
			long begin = files[0].GetParentFile().LastModified();
			NullProgressMonitor m = NullProgressMonitor.INSTANCE;
			OutputStream @out;
			@out = new SafeBufferedOutputStream(new FileOutputStream(files[0]));
			try
			{
				pw.WritePack(m, m, @out);
			}
			finally
			{
				@out.Close();
			}
			@out = new SafeBufferedOutputStream(new FileOutputStream(files[1]));
			try
			{
				pw.WriteIndex(@out);
			}
			finally
			{
				@out.Close();
			}
			Touch(begin, files[0].GetParentFile());
		}
Esempio n. 3
0
		/// <exception cref="NGit.Errors.TransportException"></exception>
		private void Sendpack(IList<RemoteRefUpdate> updates, ProgressMonitor monitor)
		{
			string pathPack = null;
			string pathIdx = null;
			PackWriter writer = new PackWriter(transport.GetPackConfig(), local.NewObjectReader
				());
			try
			{
				ICollection<ObjectId> need = new HashSet<ObjectId>();
				ICollection<ObjectId> have = new HashSet<ObjectId>();
				foreach (RemoteRefUpdate r in updates)
				{
					need.AddItem(r.GetNewObjectId());
				}
				foreach (Ref r_1 in GetRefs())
				{
					have.AddItem(r_1.GetObjectId());
					if (r_1.GetPeeledObjectId() != null)
					{
						have.AddItem(r_1.GetPeeledObjectId());
					}
				}
				writer.PreparePack(monitor, need, have);
				// We don't have to continue further if the pack will
				// be an empty pack, as the remote has all objects it
				// needs to complete this change.
				//
				if (writer.GetObjectCount() == 0)
				{
					return;
				}
				packNames = new LinkedHashMap<string, string>();
				foreach (string n in dest.GetPackNames())
				{
					packNames.Put(n, n);
				}
				string @base = "pack-" + writer.ComputeName().Name;
				string packName = @base + ".pack";
				pathPack = "pack/" + packName;
				pathIdx = "pack/" + @base + ".idx";
				if (Sharpen.Collections.Remove(packNames, packName) != null)
				{
					// The remote already contains this pack. We should
					// remove the index before overwriting to prevent bad
					// offsets from appearing to clients.
					//
					dest.WriteInfoPacks(packNames.Keys);
					dest.DeleteFile(pathIdx);
				}
				// Write the pack file, then the index, as readers look the
				// other direction (index, then pack file).
				//
				string wt = "Put " + Sharpen.Runtime.Substring(@base, 0, 12);
				OutputStream os = dest.WriteFile(pathPack, monitor, wt + "..pack");
				try
				{
					os = new SafeBufferedOutputStream(os);
					writer.WritePack(monitor, monitor, os);
				}
				finally
				{
					os.Close();
				}
				os = dest.WriteFile(pathIdx, monitor, wt + "..idx");
				try
				{
					os = new SafeBufferedOutputStream(os);
					writer.WriteIndex(os);
				}
				finally
				{
					os.Close();
				}
				// Record the pack at the start of the pack info list. This
				// way clients are likely to consult the newest pack first,
				// and discover the most recent objects there.
				//
				AList<string> infoPacks = new AList<string>();
				infoPacks.AddItem(packName);
				Sharpen.Collections.AddAll(infoPacks, packNames.Keys);
				dest.WriteInfoPacks(infoPacks);
			}
			catch (IOException err)
			{
				SafeDelete(pathIdx);
				SafeDelete(pathPack);
				throw new TransportException(uri, JGitText.Get().cannotStoreObjects, err);
			}
			finally
			{
				writer.Release();
			}
		}
Esempio n. 4
0
 /// <exception cref="NGit.Errors.TransportException"></exception>
 public TcpPushConnection(TransportGitAnon _enclosing)
     : base(_enclosing)
 {
     this._enclosing = _enclosing;
     this.sock = this._enclosing.OpenConnection();
     try
     {
         InputStream sIn = this.sock.GetInputStream();
         OutputStream sOut = this.sock.GetOutputStream();
         sIn = new BufferedInputStream(sIn);
         sOut = new SafeBufferedOutputStream(sOut);
         this.Init(sIn, sOut);
         this._enclosing.Service("git-receive-pack", this.pckOut);
     }
     catch (IOException err)
     {
         this.Close();
         throw new TransportException(this.uri, JGitText.Get().remoteHungUpUnexpectedly, err
             );
     }
     this.ReadAdvertisedRefs();
 }
Esempio n. 5
0
		public virtual void TestAbbreviateIsActuallyUnique()
		{
			// This test is far more difficult. We have to manually craft
			// an input that contains collisions at a particular prefix,
			// but this is computationally difficult. Instead we force an
			// index file to have what we want.
			//
			ObjectId id = Id("9d5b926ed164e8ee88d3b8b1e525d699adda01ba");
			byte[] idBuf = ToByteArray(id);
			IList<PackedObjectInfo> objects = new AList<PackedObjectInfo>();
			for (int i = 0; i < 256; i++)
			{
				idBuf[9] = unchecked((byte)i);
				objects.AddItem(new PackedObjectInfo(ObjectId.FromRaw(idBuf)));
			}
			string packName = "pack-" + id.Name;
			FilePath packDir = new FilePath(((ObjectDirectory)db.ObjectDatabase).GetDirectory
				(), "pack");
			FilePath idxFile = new FilePath(packDir, packName + ".idx");
			FilePath packFile = new FilePath(packDir, packName + ".pack");
			FileUtils.Mkdir(packDir, true);
			OutputStream dst = new SafeBufferedOutputStream(new FileOutputStream(idxFile));
			try
			{
				PackIndexWriter writer = new PackIndexWriterV2(dst);
				writer.Write(objects, new byte[Constants.OBJECT_ID_LENGTH]);
			}
			finally
			{
				dst.Close();
			}
			new FileOutputStream(packFile).Close();
			NUnit.Framework.Assert.AreEqual(id.Abbreviate(20), reader.Abbreviate(id, 2));
			AbbreviatedObjectId abbrev8 = id.Abbreviate(8);
			ICollection<ObjectId> matches = reader.Resolve(abbrev8);
			NUnit.Framework.Assert.IsNotNull(matches);
			NUnit.Framework.Assert.AreEqual(objects.Count, matches.Count);
			foreach (PackedObjectInfo info in objects)
			{
				NUnit.Framework.Assert.IsTrue(matches.Contains(info), "contains " + info.Name);
			}
			try
			{
				db.Resolve(abbrev8.Name);
				NUnit.Framework.Assert.Fail("did not throw AmbiguousObjectException");
			}
			catch (AmbiguousObjectException err)
			{
				NUnit.Framework.Assert.AreEqual(abbrev8, err.GetAbbreviatedObjectId());
				matches = err.GetCandidates();
				NUnit.Framework.Assert.IsNotNull(matches);
				NUnit.Framework.Assert.AreEqual(objects.Count, matches.Count);
				foreach (PackedObjectInfo info_1 in objects)
				{
					NUnit.Framework.Assert.IsTrue(matches.Contains(info_1), "contains " + info_1.Name
						);
				}
			}
			NUnit.Framework.Assert.AreEqual(id, db.Resolve(id.Abbreviate(20).Name));
		}