Merge branch 'pack-protocol' into plastic

carlosmn · carlosmn · commit 50ae7e9e006e · 2012-06-18T11:54:56.000+02:00
diff --git a/LibGit2Sharp.Tests/LibGit2Sharp.Tests.csproj b/LibGit2Sharp.Tests/LibGit2Sharp.Tests.csproj
@@ -88,6 +88,7 @@
     <Compile Include="TreeDefinitionFixture.cs" />
     <Compile Include="TreeFixture.cs" />
     <Compile Include="TupleFixture.cs" />
+    <Compile Include="RefspecFixture.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\LibGit2Sharp\LibGit2Sharp.csproj">
diff --git a/LibGit2Sharp.Tests/RefspecFixture.cs b/LibGit2Sharp.Tests/RefspecFixture.cs
@@ -0,0 +1,41 @@
+using System;
+using System.Linq;
+using LibGit2Sharp.Tests.TestHelpers;
+using Xunit;
+using Xunit.Extensions;
+
+namespace LibGit2Sharp.Tests
+{
+    public class RefspecFixture
+    {
+        [Theory]
+        [InlineData("refs/heads/master:refs/remotes/origin/master", false, "refs/heads/master", "refs/remotes/origin/master")]
+        [InlineData("+refs/heads/master:refs/remotes/origin/master", true, "refs/heads/master", "refs/remotes/origin/master")]
+        public void CanParseRefspecs(string spec, bool force, string left, string right)
+        {
+            var refspec = new Refspec(spec);
+            Assert.True(refspec.Src.Equals(left));
+            Assert.True(refspec.Dst.Equals(right));
+            Assert.True(refspec.Force == force);
+        }
+
+
+        [Fact]
+        public void CanMatchNonWildcards()
+        {
+            var refspec = new Refspec("refs/heads/master:refs/heads/master");
+            Assert.True(refspec.Matches("refs/heads/master"));
+        }
+
+        [Theory]
+        [InlineData("refs/heads/master")]
+        [InlineData("refs/heads/development")]
+        [InlineData("refs/heads/some/branch")]
+        public void CanMatchWildcards(string refname)
+        {
+            var refspec = new Refspec("refs/heads/*");
+            Assert.True(refspec.Matches(refname));
+        }
+    }
+}
+
diff --git a/LibGit2Sharp/Core/Compat/StreamExtensions.cs b/LibGit2Sharp/Core/Compat/StreamExtensions.cs
@@ -0,0 +1,19 @@
+using System;
+using System.IO;
+
+namespace LibGit2Sharp
+{
+    public static class StreamExtensions
+    {
+        public static void CopyTo(this Stream from, Stream to)
+        {
+            int len = Math.Min(65535, (int)(from.Length - from.Position));
+            var buff = new byte[len];
+            int n;
+            do {
+                n = from.Read(buff, 0, len);
+                to.Write(buff, 0, n);
+            } while (n != 0);
+        }
+    }
+}
diff --git a/LibGit2Sharp/GitProtocolException.cs b/LibGit2Sharp/GitProtocolException.cs
@@ -0,0 +1,21 @@
+using System;
+namespace LibGit2Sharp
+{
+    public class GitProtocolException : Exception
+    {
+        public GitProtocolException()
+        {
+        }
+
+        public GitProtocolException(string message)
+            : base(message)
+        {
+        }
+
+        public GitProtocolException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+    }
+}
+
diff --git a/LibGit2Sharp/GitTransport.cs b/LibGit2Sharp/GitTransport.cs
@@ -0,0 +1,60 @@
+using System;
+using System.IO;
+using System.Net.Sockets;
+using System.Collections.Generic;
+using System.Text;
+
+namespace LibGit2Sharp
+{
+    public class GitTransport : ITransport
+    {
+        Uri uri = null;
+        bool connected;
+        Stream stream;
+
+        public GitTransport(string url)
+        {
+            var uribld = new UriBuilder(url);
+            if (!uribld.Scheme.Equals("git"))
+                throw new ArgumentException("This transport is only valid for git://");
+
+            if (uribld.Port == -1)
+                uribld.Port = 9418;
+
+            uri = uribld.Uri;
+            connected = false;
+        }
+
+        byte[] GenRequest(Uri uri)
+        {
+            var tmp = string.Format("git-upload-pack {0}\0host={1}\0", uri.AbsolutePath, uri.Host);
+            return Encoding.UTF8.GetBytes(string.Format("{0:x4}{1}", tmp.Length, tmp));
+        }
+        // Connect to the remote host asking for the specified repository
+        public void Connect()
+        {
+            var req = GenRequest(uri);
+            var tcp = new TcpClient(uri.Host, uri.Port);
+            stream = tcp.GetStream();
+            stream.Write(req, 0, req.Length);
+            connected = true;
+        }
+
+        public Stream GetStream()
+        {
+            return stream;
+        }
+
+        public bool Connected()
+        {
+            return connected;
+        }
+
+        public void NegotiationStep(Stream stream)
+        {
+            /* The raw protocol doesn't need anything else */
+            stream.CopyTo(this.stream);
+        }
+    }
+}
+
diff --git a/LibGit2Sharp/ITransport.cs b/LibGit2Sharp/ITransport.cs
@@ -0,0 +1,21 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+
+namespace LibGit2Sharp
+{
+    public interface ITransport
+    {
+        void Connect();
+        bool Connected();
+        Stream GetStream();
+        /// <summary>
+        /// Send the contents of <param name="stream"> as part of a negotiation
+        /// step. This is necessary because some transports (notably the smart
+        /// HTTP transport) needs to send data in packets instead of a stream,
+        /// so each negotiation step needs to be handled on its own.
+        /// </summary>
+        void NegotiationStep(Stream stream);
+    }
+}
+
diff --git a/LibGit2Sharp/LibGit2Sharp.csproj b/LibGit2Sharp/LibGit2Sharp.csproj
@@ -164,6 +164,13 @@
     <Compile Include="Core\Handles\StreamingIndexerSafeHandle.cs" />
     <Compile Include="Indexer.cs" />
     <Compile Include="ObjectDatabaseExtensions.cs" />
+    <Compile Include="PktParser.cs" />
+    <Compile Include="Pkt.cs" />
+    <Compile Include="ITransport.cs" />
+    <Compile Include="GitTransport.cs" />
+    <Compile Include="Refspec.cs" />
+    <Compile Include="GitProtocolException.cs" />
+    <Compile Include="Core\Compat\StreamExtensions.cs" />
   </ItemGroup>
   <ItemGroup>
     <CodeAnalysisDictionary Include="CustomDictionary.xml" />
diff --git a/LibGit2Sharp/Pkt.cs b/LibGit2Sharp/Pkt.cs
@@ -0,0 +1,112 @@
+using System;
+using System.IO;
+using System.Text;
+
+namespace LibGit2Sharp
+{
+    public class Pkt
+    {
+        static public Pkt Parse(BinaryReader reader)
+        {
+            var buf = reader.ReadBytes(4);
+            int len = Int32.Parse(Encoding.ASCII.GetString(buf), System.Globalization.NumberStyles.HexNumber);
+            if (len == 0)
+                return new PktFlush();
+
+            len -= 4;
+
+            return NewPkt(reader, len);
+        }
+
+        /*
+         * We can't seek on a NetworkStream, which means that we can't use
+         * reader.PeekChar() to see if we got an error (which starts with
+         * "ERR " instead of a hash) so we need this new function that chooses
+         * which type to create
+         */
+        public static Pkt NewPkt(BinaryReader reader, int len)
+        {
+            var pref = Encoding.ASCII.GetString(reader.ReadBytes(3));
+            len -= 3;
+            if (pref.Equals("ERR")) {
+                return new PktError(reader, len);
+            } else if (pref.Equals("NAK")) {
+                return new PktNak(reader, len);
+            } else if (pref.Equals("ACK")) {
+                return new PktAck(reader, len);
+            }
+
+            return new PktRef(reader, len, pref);
+        }
+    }
+
+
+    public class PktRef : Pkt
+    {
+        public readonly ObjectId Id;
+        public readonly string Name;
+        public readonly string CapString;
+
+        public PktRef(BinaryReader reader, int len, string pre)
+        {
+            int toread = 40 - pre.Length;
+            var hash = Encoding.ASCII.GetString(reader.ReadBytes(toread));
+            len -= toread; /* The hash */
+            ObjectId.TryParse(pre + hash, out Id);
+            reader.ReadByte(); /* Skip the SP */
+            len -= 1; /* The SP */
+
+            /* Each line SHOULD end with LF, but unfortunately we can't rely on it being there */
+            var tmp = Encoding.UTF8.GetString(reader.ReadBytes(len));
+            if (tmp.EndsWith("\n"))
+                tmp = tmp.Remove(tmp.Length - 1);
+
+            /*
+             * The server's capabilities are sent as "HEAD" NUL "cap1 cap2". In
+             * C it works just fine, but C# knows that the string doesn't stop
+             * at the first NUL, so we need to split it out explicitly.
+             */
+            var nul = tmp.IndexOf('\0');
+            if (nul == -1) {
+                Name = tmp;
+            } else {
+                var parts = tmp.Split('\0');
+                Name = parts[0];
+                CapString = parts[1];
+            }
+        }
+    }
+
+    public class PktError : Pkt
+    {
+        public readonly string Error;
+
+        public PktError(BinaryReader reader, int len)
+        {
+            /* NewPkt() has already removed "ERR" from the stream, remove SP */
+            reader.ReadByte();
+            Error = Encoding.UTF8.GetString(reader.ReadBytes(len));
+        }
+    }
+
+    public class PktAck : Pkt
+    {
+        public PktAck(BinaryReader reader, int len)
+        {
+            reader.ReadBytes(len);
+        }
+    }
+
+    public class PktNak : Pkt
+    {
+        public PktNak(BinaryReader reader, int len)
+        {
+            reader.ReadBytes(len);
+        }
+    }
+
+    public class PktFlush : Pkt
+    {
+    }
+}
+
diff --git a/LibGit2Sharp/PktParser.cs b/LibGit2Sharp/PktParser.cs
@@ -0,0 +1,26 @@
+using System;
+using System.IO;
+using System.Text;
+
+namespace LibGit2Sharp
+{
+    public class PktParser
+    {
+        private BinaryReader reader;
+        public PktParser(Stream stream) : this(new BinaryReader(stream))
+        {
+        }
+
+        public PktParser(BinaryReader reader)
+        {
+            this.reader = reader;
+        }
+
+
+        public Pkt Next()
+        {
+            return Pkt.Parse(reader);
+        }
+    }
+}
+
diff --git a/LibGit2Sharp/Refspec.cs b/LibGit2Sharp/Refspec.cs
@@ -0,0 +1,50 @@
+using System;
+namespace LibGit2Sharp
+{
+    public class Refspec
+    {
+        public string Src { get; private set; }
+        public string Dst { get; private set; }
+        public bool Force { get; private set; }
+        bool wildcard;
+
+        public Refspec(string str)
+        {
+            if (string.IsNullOrEmpty(str))
+            {
+                Src = "";
+                Dst = "";
+                return;
+            }
+
+            if (str[0] == '+') {
+                Force = true;
+                str = str.Remove(0, 1);
+            } else {
+                Force = false;
+            }
+
+            var parts = str.Split(':');
+            Src = parts[0];
+            wildcard = Src.EndsWith("*");
+            if (parts.Length > 1) {
+                Dst = parts[1];
+                if (wildcard && !Dst.EndsWith("*"))
+                    throw new ArgumentException("Left side has wildcard, but right one doesn't");
+                if (!wildcard && Dst.EndsWith("*"))
+                throw new ArgumentException("Right side has wildcard, but left side doesn't");
+            }
+        }
+
+        public bool Matches(string str)
+        {
+            /* If it's not a wildcard, then it's a straight string match */
+            if (!wildcard)
+                return Src.Equals(str);
+
+            var prefix = Src.Remove(Src.Length - 1);
+            return str.StartsWith(prefix);
+        }
+    }
+}
+
diff --git a/LibGit2Sharp/Remote.cs b/LibGit2Sharp/Remote.cs
