Merge branch 'go-hello-world' into 'master'

Add hello-world Go executable and gitaly-proto 0.5.0

Closes gitaly#186

See merge request !127

go/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go

+// Code generated by protoc-gen-go.
+// source: github.com/golang/protobuf/ptypes/any/any.proto
+// DO NOT EDIT!
+
+/*
+Package any is a generated protocol buffer package.
+
+It is generated from these files:
+	github.com/golang/protobuf/ptypes/any/any.proto
+
+It has these top-level messages:
+	Any
+*/
+package any
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// `Any` contains an arbitrary serialized protocol buffer message along with a
+// URL that describes the type of the serialized message.
+//
+// Protobuf library provides support to pack/unpack Any values in the form
+// of utility functions or additional generated methods of the Any type.
+//
+// Example 1: Pack and unpack a message in C++.
+//
+//     Foo foo = ...;
+//     Any any;
+//     any.PackFrom(foo);
+//     ...
+//     if (any.UnpackTo(&foo)) {
+//       ...
+//     }
+//
+// Example 2: Pack and unpack a message in Java.
+//
+//     Foo foo = ...;
+//     Any any = Any.pack(foo);
+//     ...
+//     if (any.is(Foo.class)) {
+//       foo = any.unpack(Foo.class);
+//     }
+//
+//  Example 3: Pack and unpack a message in Python.
+//
+//     foo = Foo(...)
+//     any = Any()
+//     any.Pack(foo)
+//     ...
+//     if any.Is(Foo.DESCRIPTOR):
+//       any.Unpack(foo)
+//       ...
+//
+// The pack methods provided by protobuf library will by default use
+// 'type.googleapis.com/full.type.name' as the type URL and the unpack
+// methods only use the fully qualified type name after the last '/'
+// in the type URL, for example "foo.bar.com/x/y.z" will yield type
+// name "y.z".
+//
+//
+// JSON
+// ====
+// The JSON representation of an `Any` value uses the regular
+// representation of the deserialized, embedded message, with an
+// additional field `@type` which contains the type URL. Example:
+//
+//     package google.profile;
+//     message Person {
+//       string first_name = 1;
+//       string last_name = 2;
+//     }
+//
+//     {
+//       "@type": "type.googleapis.com/google.profile.Person",
+//       "firstName": <string>,
+//       "lastName": <string>
+//     }
+//
+// If the embedded message type is well-known and has a custom JSON
+// representation, that representation will be embedded adding a field
+// `value` which holds the custom JSON in addition to the `@type`
+// field. Example (for message [google.protobuf.Duration][]):
+//
+//     {
+//       "@type": "type.googleapis.com/google.protobuf.Duration",
+//       "value": "1.212s"
+//     }
+//
+type Any struct {
+	// A URL/resource name whose content describes the type of the
+	// serialized protocol buffer message.
+	//
+	// For URLs which use the scheme `http`, `https`, or no scheme, the
+	// following restrictions and interpretations apply:
+	//
+	// * If no scheme is provided, `https` is assumed.
+	// * The last segment of the URL's path must represent the fully
+	//   qualified name of the type (as in `path/google.protobuf.Duration`).
+	//   The name should be in a canonical form (e.g., leading "." is
+	//   not accepted).
+	// * An HTTP GET on the URL must yield a [google.protobuf.Type][]
+	//   value in binary format, or produce an error.
+	// * Applications are allowed to cache lookup results based on the
+	//   URL, or have them precompiled into a binary to avoid any
+	//   lookup. Therefore, binary compatibility needs to be preserved
+	//   on changes to types. (Use versioned type names to manage
+	//   breaking changes.)
+	//
+	// Schemes other than `http`, `https` (or the empty scheme) might be
+	// used with implementation specific semantics.
+	//
+	TypeUrl string `protobuf:"bytes,1,opt,name=type_url,json=typeUrl" json:"type_url,omitempty"`
+	// Must be a valid serialized protocol buffer of the above specified type.
+	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (m *Any) Reset()                    { *m = Any{} }
+func (m *Any) String() string            { return proto.CompactTextString(m) }
+func (*Any) ProtoMessage()               {}
+func (*Any) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+func (*Any) XXX_WellKnownType() string   { return "Any" }
+
+func init() {
+	proto.RegisterType((*Any)(nil), "google.protobuf.Any")
+}
+
+func init() { proto.RegisterFile("github.com/golang/protobuf/ptypes/any/any.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 187 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xd2, 0x4f, 0xcf, 0x2c, 0xc9,
+	0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc, 0x4b, 0xd7, 0x2f, 0x28,
+	0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0x28, 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x4f, 0xcc,
+	0xab, 0x04, 0x61, 0x3d, 0xb0, 0xb8, 0x10, 0x7f, 0x7a, 0x7e, 0x7e, 0x7a, 0x4e, 0xaa, 0x1e, 0x4c,
+	0x95, 0x92, 0x19, 0x17, 0xb3, 0x63, 0x5e, 0xa5, 0x90, 0x24, 0x17, 0x07, 0x48, 0x79, 0x7c, 0x69,
+	0x51, 0x8e, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x67, 0x10, 0x3b, 0x88, 0x1f, 0x5a, 0x94, 0x23, 0x24,
+	0xc2, 0xc5, 0x5a, 0x96, 0x98, 0x53, 0x9a, 0x2a, 0xc1, 0xa4, 0xc0, 0xa8, 0xc1, 0x13, 0x04, 0xe1,
+	0x38, 0x15, 0x71, 0x09, 0x27, 0xe7, 0xe7, 0xea, 0xa1, 0x19, 0xe7, 0xc4, 0xe1, 0x98, 0x57, 0x19,
+	0x00, 0xe2, 0x04, 0x30, 0x46, 0xa9, 0x12, 0xe5, 0xb8, 0x05, 0x8c, 0x8c, 0x8b, 0x98, 0x98, 0xdd,
+	0x03, 0x9c, 0x56, 0x31, 0xc9, 0xb9, 0x43, 0x4c, 0x0b, 0x80, 0xaa, 0xd2, 0x0b, 0x4f, 0xcd, 0xc9,
+	0xf1, 0xce, 0xcb, 0x2f, 0xcf, 0x0b, 0x01, 0xa9, 0x4e, 0x62, 0x03, 0x6b, 0x37, 0x06, 0x04, 0x00,
+	0x00, 0xff, 0xff, 0xc6, 0x4d, 0x03, 0x23, 0xf6, 0x00, 0x00, 0x00,
+}

go/vendor/github.com/golang/protobuf/ptypes/any/any.proto

+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option go_package = "github.com/golang/protobuf/ptypes/any";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "AnyProto";
+option java_multiple_files = true;
+option java_generate_equals_and_hash = true;
+option objc_class_prefix = "GPB";
+
+// `Any` contains an arbitrary serialized protocol buffer message along with a
+// URL that describes the type of the serialized message.
+//
+// Protobuf library provides support to pack/unpack Any values in the form
+// of utility functions or additional generated methods of the Any type.
+//
+// Example 1: Pack and unpack a message in C++.
+//
+//     Foo foo = ...;
+//     Any any;
+//     any.PackFrom(foo);
+//     ...
+//     if (any.UnpackTo(&foo)) {
+//       ...
+//     }
+//
+// Example 2: Pack and unpack a message in Java.
+//
+//     Foo foo = ...;
+//     Any any = Any.pack(foo);
+//     ...
+//     if (any.is(Foo.class)) {
+//       foo = any.unpack(Foo.class);
+//     }
+//
+//  Example 3: Pack and unpack a message in Python.
+//
+//     foo = Foo(...)
+//     any = Any()
+//     any.Pack(foo)
+//     ...
+//     if any.Is(Foo.DESCRIPTOR):
+//       any.Unpack(foo)
+//       ...
+//
+// The pack methods provided by protobuf library will by default use
+// 'type.googleapis.com/full.type.name' as the type URL and the unpack
+// methods only use the fully qualified type name after the last '/'
+// in the type URL, for example "foo.bar.com/x/y.z" will yield type
+// name "y.z".
+//
+//
+// JSON
+// ====
+// The JSON representation of an `Any` value uses the regular
+// representation of the deserialized, embedded message, with an
+// additional field `@type` which contains the type URL. Example:
+//
+//     package google.profile;
+//     message Person {
+//       string first_name = 1;
+//       string last_name = 2;
+//     }
+//
+//     {
+//       "@type": "type.googleapis.com/google.profile.Person",
+//       "firstName": <string>,
+//       "lastName": <string>
+//     }
+//
+// If the embedded message type is well-known and has a custom JSON
+// representation, that representation will be embedded adding a field
+// `value` which holds the custom JSON in addition to the `@type`
+// field. Example (for message [google.protobuf.Duration][]):
+//
+//     {
+//       "@type": "type.googleapis.com/google.protobuf.Duration",
+//       "value": "1.212s"
+//     }
+//
+message Any {
+  // A URL/resource name whose content describes the type of the
+  // serialized protocol buffer message.
+  //
+  // For URLs which use the scheme `http`, `https`, or no scheme, the
+  // following restrictions and interpretations apply:
+  //
+  // * If no scheme is provided, `https` is assumed.
+  // * The last segment of the URL's path must represent the fully
+  //   qualified name of the type (as in `path/google.protobuf.Duration`).
+  //   The name should be in a canonical form (e.g., leading "." is
+  //   not accepted).
+  // * An HTTP GET on the URL must yield a [google.protobuf.Type][]
+  //   value in binary format, or produce an error.
+  // * Applications are allowed to cache lookup results based on the
+  //   URL, or have them precompiled into a binary to avoid any
+  //   lookup. Therefore, binary compatibility needs to be preserved
+  //   on changes to types. (Use versioned type names to manage
+  //   breaking changes.)
+  //
+  // Schemes other than `http`, `https` (or the empty scheme) might be
+  // used with implementation specific semantics.
+  //
+  string type_url = 1;
+
+  // Must be a valid serialized protocol buffer of the above specified type.
+  bytes value = 2;
+}

go/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go

+// Code generated by protoc-gen-go.
+// source: github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
+// DO NOT EDIT!
+
+/*
+Package timestamp is a generated protocol buffer package.
+
+It is generated from these files:
+	github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
+
+It has these top-level messages:
+	Timestamp
+*/
+package timestamp
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// A Timestamp represents a point in time independent of any time zone
+// or calendar, represented as seconds and fractions of seconds at
+// nanosecond resolution in UTC Epoch time. It is encoded using the
+// Proleptic Gregorian Calendar which extends the Gregorian calendar
+// backwards to year one. It is encoded assuming all minutes are 60
+// seconds long, i.e. leap seconds are "smeared" so that no leap second
+// table is needed for interpretation. Range is from
+// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
+// By restricting to that range, we ensure that we can convert to
+// and from  RFC 3339 date strings.
+// See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
+//
+// Example 1: Compute Timestamp from POSIX `time()`.
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(time(NULL));
+//     timestamp.set_nanos(0);
+//
+// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+//
+//     struct timeval tv;
+//     gettimeofday(&tv, NULL);
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(tv.tv_sec);
+//     timestamp.set_nanos(tv.tv_usec * 1000);
+//
+// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+//
+//     FILETIME ft;
+//     GetSystemTimeAsFileTime(&ft);
+//     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+//
+//     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+//     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+//     Timestamp timestamp;
+//     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+//     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+//
+// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+//
+//     long millis = System.currentTimeMillis();
+//
+//     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+//         .setNanos((int) ((millis % 1000) * 1000000)).build();
+//
+//
+// Example 5: Compute Timestamp from current time in Python.
+//
+//     now = time.time()
+//     seconds = int(now)
+//     nanos = int((now - seconds) * 10**9)
+//     timestamp = Timestamp(seconds=seconds, nanos=nanos)
+//
+//
+type Timestamp struct {
+	// Represents seconds of UTC time since Unix epoch
+	// 1970-01-01T00:00:00Z. Must be from from 0001-01-01T00:00:00Z to
+	// 9999-12-31T23:59:59Z inclusive.
+	Seconds int64 `protobuf:"varint,1,opt,name=seconds" json:"seconds,omitempty"`
+	// Non-negative fractions of a second at nanosecond resolution. Negative
+	// second values with fractions must still have non-negative nanos values
+	// that count forward in time. Must be from 0 to 999,999,999
+	// inclusive.
+	Nanos int32 `protobuf:"varint,2,opt,name=nanos" json:"nanos,omitempty"`
+}
+
+func (m *Timestamp) Reset()                    { *m = Timestamp{} }
+func (m *Timestamp) String() string            { return proto.CompactTextString(m) }
+func (*Timestamp) ProtoMessage()               {}
+func (*Timestamp) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+func (*Timestamp) XXX_WellKnownType() string   { return "Timestamp" }
+
+func init() {
+	proto.RegisterType((*Timestamp)(nil), "google.protobuf.Timestamp")
+}
+
+func init() {
+	proto.RegisterFile("github.com/golang/protobuf/ptypes/timestamp/timestamp.proto", fileDescriptor0)
+}
+
+var fileDescriptor0 = []byte{
+	// 194 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xb2, 0x4e, 0xcf, 0x2c, 0xc9,
+	0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc, 0x4b, 0xd7, 0x2f, 0x28,
+	0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0x28, 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x2f, 0xc9,
+	0xcc, 0x4d, 0x2d, 0x2e, 0x49, 0xcc, 0x2d, 0x40, 0xb0, 0xf4, 0xc0, 0x6a, 0x84, 0xf8, 0xd3, 0xf3,
+	0xf3, 0xd3, 0x73, 0x52, 0xf5, 0x60, 0x3a, 0x94, 0xac, 0xb9, 0x38, 0x43, 0x60, 0x6a, 0x84, 0x24,
+	0xb8, 0xd8, 0x8b, 0x53, 0x93, 0xf3, 0xf3, 0x52, 0x8a, 0x25, 0x18, 0x15, 0x18, 0x35, 0x98, 0x83,
+	0x60, 0x5c, 0x21, 0x11, 0x2e, 0xd6, 0xbc, 0xc4, 0xbc, 0xfc, 0x62, 0x09, 0x26, 0x05, 0x46, 0x0d,
+	0xd6, 0x20, 0x08, 0xc7, 0xa9, 0x91, 0x91, 0x4b, 0x38, 0x39, 0x3f, 0x57, 0x0f, 0xcd, 0x50, 0x27,
+	0x3e, 0xb8, 0x91, 0x01, 0x20, 0xa1, 0x00, 0xc6, 0x28, 0x6d, 0x12, 0x1c, 0xbd, 0x80, 0x91, 0xf1,
+	0x07, 0x23, 0xe3, 0x22, 0x26, 0x66, 0xf7, 0x00, 0xa7, 0x55, 0x4c, 0x72, 0xee, 0x10, 0xc3, 0x03,
+	0xa0, 0xca, 0xf5, 0xc2, 0x53, 0x73, 0x72, 0xbc, 0xf3, 0xf2, 0xcb, 0xf3, 0x42, 0x40, 0xda, 0x92,
+	0xd8, 0xc0, 0xe6, 0x18, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x17, 0x5f, 0xb7, 0xdc, 0x17, 0x01,
+	0x00, 0x00,
+}

go/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto

+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option cc_enable_arenas = true;
+option go_package = "github.com/golang/protobuf/ptypes/timestamp";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "TimestampProto";
+option java_multiple_files = true;
+option java_generate_equals_and_hash = true;
+option objc_class_prefix = "GPB";
+
+// A Timestamp represents a point in time independent of any time zone
+// or calendar, represented as seconds and fractions of seconds at
+// nanosecond resolution in UTC Epoch time. It is encoded using the
+// Proleptic Gregorian Calendar which extends the Gregorian calendar
+// backwards to year one. It is encoded assuming all minutes are 60
+// seconds long, i.e. leap seconds are "smeared" so that no leap second
+// table is needed for interpretation. Range is from
+// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
+// By restricting to that range, we ensure that we can convert to
+// and from  RFC 3339 date strings.
+// See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
+//
+// Example 1: Compute Timestamp from POSIX `time()`.
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(time(NULL));
+//     timestamp.set_nanos(0);
+//
+// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+//
+//     struct timeval tv;
+//     gettimeofday(&tv, NULL);
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(tv.tv_sec);
+//     timestamp.set_nanos(tv.tv_usec * 1000);
+//
+// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+//
+//     FILETIME ft;
+//     GetSystemTimeAsFileTime(&ft);
+//     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+//
+//     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+//     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+//     Timestamp timestamp;
+//     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+//     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+//
+// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+//
+//     long millis = System.currentTimeMillis();
+//
+//     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+//         .setNanos((int) ((millis % 1000) * 1000000)).build();
+//
+//
+// Example 5: Compute Timestamp from current time in Python.
+//
+//     now = time.time()
+//     seconds = int(now)
+//     nanos = int((now - seconds) * 10**9)
+//     timestamp = Timestamp(seconds=seconds, nanos=nanos)
+//
+//
+message Timestamp {
+
+  // Represents seconds of UTC time since Unix epoch
+  // 1970-01-01T00:00:00Z. Must be from from 0001-01-01T00:00:00Z to
+  // 9999-12-31T23:59:59Z inclusive.
+  int64 seconds = 1;
+
+  // Non-negative fractions of a second at nanosecond resolution. Negative
+  // second values with fractions must still have non-negative nanos values
+  // that count forward in time. Must be from 0 to 999,999,999
+  // inclusive.
+  int32 nanos = 2;
+}

go/vendor/gitlab.com/gitlab-org/gitaly-proto/LICENSE

+The MIT License (MIT)
+
+Copyright (c) 2016-2017 GitLab B.V.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/README.md

+# Auto-generated Go gRPC bindings for gitaly
+
+This Go package is used both by the Gitaly server itself and by Go
+Gitaly clients (such as gitlab-workhorse).

go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/VERSION

+0.5.0

go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/commit.pb.go

+// Code generated by protoc-gen-go.
+// source: commit.proto
+// DO NOT EDIT!
+
+/*
+Package gitaly is a generated protocol buffer package.
+
+It is generated from these files:
+	commit.proto
+	diff.proto
+	notifications.proto
+	ref.proto
+	shared.proto
+	smarthttp.proto
+	ssh.proto
+
+It has these top-level messages:
+	CommitIsAncestorRequest
+	CommitIsAncestorResponse
+	CommitDiffRequest
+	CommitDiffResponse
+	PostReceiveRequest
+	PostReceiveResponse
+	FindDefaultBranchNameRequest
+	FindDefaultBranchNameResponse
+	FindAllBranchNamesRequest
+	FindAllBranchNamesResponse
+	FindAllTagNamesRequest
+	FindAllTagNamesResponse
+	FindRefNameRequest
+	FindRefNameResponse
+	FindLocalBranchesRequest
+	FindLocalBranchesResponse
+	FindLocalBranchResponse
+	FindLocalBranchCommitAuthor
+	Repository
+	ExitStatus
+	InfoRefsRequest
+	InfoRefsResponse
+	PostUploadPackRequest
+	PostUploadPackResponse
+	PostReceivePackRequest
+	PostReceivePackResponse
+	SSHUploadPackRequest
+	SSHUploadPackResponse
+	SSHReceivePackRequest
+	SSHReceivePackResponse
+*/
+package gitaly
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type CommitIsAncestorRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	AncestorId string      `protobuf:"bytes,2,opt,name=ancestor_id,json=ancestorId" json:"ancestor_id,omitempty"`
+	ChildId    string      `protobuf:"bytes,3,opt,name=child_id,json=childId" json:"child_id,omitempty"`
+}
+
+func (m *CommitIsAncestorRequest) Reset()                    { *m = CommitIsAncestorRequest{} }
+func (m *CommitIsAncestorRequest) String() string            { return proto.CompactTextString(m) }
+func (*CommitIsAncestorRequest) ProtoMessage()               {}
+func (*CommitIsAncestorRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *CommitIsAncestorRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *CommitIsAncestorRequest) GetAncestorId() string {
+	if m != nil {
+		return m.AncestorId
+	}
+	return ""
+}
+
+func (m *CommitIsAncestorRequest) GetChildId() string {
+	if m != nil {
+		return m.ChildId
+	}
+	return ""
+}
+
+type CommitIsAncestorResponse struct {
+	Value bool `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
+}
+
+func (m *CommitIsAncestorResponse) Reset()                    { *m = CommitIsAncestorResponse{} }
+func (m *CommitIsAncestorResponse) String() string            { return proto.CompactTextString(m) }
+func (*CommitIsAncestorResponse) ProtoMessage()               {}
+func (*CommitIsAncestorResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *CommitIsAncestorResponse) GetValue() bool {
+	if m != nil {
+		return m.Value
+	}
+	return false
+}
+
+func init() {
+	proto.RegisterType((*CommitIsAncestorRequest)(nil), "gitaly.CommitIsAncestorRequest")
+	proto.RegisterType((*CommitIsAncestorResponse)(nil), "gitaly.CommitIsAncestorResponse")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for Commit service
+
+type CommitClient interface {
+	CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error)
+}
+
+type commitClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewCommitClient(cc *grpc.ClientConn) CommitClient {
+	return &commitClient{cc}
+}
+
+func (c *commitClient) CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error) {
+	out := new(CommitIsAncestorResponse)
+	err := grpc.Invoke(ctx, "/gitaly.Commit/CommitIsAncestor", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for Commit service
+
+type CommitServer interface {
+	CommitIsAncestor(context.Context, *CommitIsAncestorRequest) (*CommitIsAncestorResponse, error)
+}
+
+func RegisterCommitServer(s *grpc.Server, srv CommitServer) {
+	s.RegisterService(&_Commit_serviceDesc, srv)
+}
+
+func _Commit_CommitIsAncestor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CommitIsAncestorRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(CommitServer).CommitIsAncestor(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.Commit/CommitIsAncestor",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(CommitServer).CommitIsAncestor(ctx, req.(*CommitIsAncestorRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Commit_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.Commit",
+	HandlerType: (*CommitServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "CommitIsAncestor",
+			Handler:    _Commit_CommitIsAncestor_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "commit.proto",
+}
+
+func init() { proto.RegisterFile("commit.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 213 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x50, 0xbf, 0x4e, 0x84, 0x30,
+	0x18, 0xb7, 0x1a, 0x11, 0x3f, 0x18, 0xcc, 0x17, 0x13, 0x91, 0x05, 0xc2, 0xc4, 0x44, 0x0c, 0x3e,
+	0x81, 0x71, 0x62, 0xed, 0xe2, 0x68, 0x2a, 0x6d, 0xa4, 0x09, 0x50, 0x6c, 0x8b, 0x09, 0x8f, 0x70,
+	0x6f, 0x7d, 0xb9, 0xf6, 0xb8, 0x5c, 0xee, 0xc2, 0xf8, 0xfb, 0xdb, 0x5f, 0x3f, 0x88, 0x5b, 0x35,
+	0x0c, 0xd2, 0x56, 0x93, 0x56, 0x56, 0x61, 0xf0, 0x2b, 0x2d, 0xeb, 0x97, 0x34, 0x36, 0x1d, 0xd3,
+	0x82, 0x7b, 0xb6, 0xd8, 0x11, 0x78, 0xf9, 0x74, 0xb6, 0xc6, 0x7c, 0x8c, 0xad, 0x30, 0x56, 0x69,
+	0x2a, 0xfe, 0x66, 0x61, 0x2c, 0xd6, 0x00, 0x5a, 0x4c, 0xca, 0x48, 0xab, 0xf4, 0x92, 0x90, 0x9c,
+	0x94, 0x51, 0x8d, 0x95, 0xaf, 0xa9, 0xe8, 0x49, 0xa1, 0x67, 0x2e, 0xcc, 0x20, 0x62, 0xc7, 0x9a,
+	0x6f, 0xc9, 0x93, 0xdb, 0x9c, 0x94, 0x8f, 0x14, 0x56, 0xaa, 0xe1, 0xf8, 0x0a, 0x61, 0xdb, 0xc9,
+	0x9e, 0x1f, 0xd4, 0x3b, 0xa7, 0x3e, 0x38, 0xdc, 0xf0, 0xe2, 0x0d, 0x92, 0xeb, 0x29, 0x66, 0x52,
+	0xa3, 0x11, 0xf8, 0x0c, 0xf7, 0xff, 0xac, 0x9f, 0x85, 0x9b, 0x11, 0x52, 0x0f, 0x6a, 0x06, 0x81,
+	0x4f, 0xe0, 0x17, 0x3c, 0x5d, 0x66, 0x31, 0x5b, 0xb7, 0x6e, 0x7c, 0x30, 0xcd, 0xb7, 0x0d, 0xfe,
+	0xd9, 0xe2, 0xe6, 0x27, 0x70, 0x77, 0x7a, 0xdf, 0x07, 0x00, 0x00, 0xff, 0xff, 0x5d, 0x48, 0xb7,
+	0xcb, 0x4d, 0x01, 0x00, 0x00,
+}

go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/diff.pb.go

+// Code generated by protoc-gen-go.
+// source: diff.proto
+// DO NOT EDIT!
+
+package gitaly
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type CommitDiffRequest struct {
+	Repository    *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	LeftCommitId  string      `protobuf:"bytes,2,opt,name=left_commit_id,json=leftCommitId" json:"left_commit_id,omitempty"`
+	RightCommitId string      `protobuf:"bytes,3,opt,name=right_commit_id,json=rightCommitId" json:"right_commit_id,omitempty"`
+}
+
+func (m *CommitDiffRequest) Reset()                    { *m = CommitDiffRequest{} }
+func (m *CommitDiffRequest) String() string            { return proto.CompactTextString(m) }
+func (*CommitDiffRequest) ProtoMessage()               {}
+func (*CommitDiffRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
+
+func (m *CommitDiffRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *CommitDiffRequest) GetLeftCommitId() string {
+	if m != nil {
+		return m.LeftCommitId
+	}
+	return ""
+}
+
+func (m *CommitDiffRequest) GetRightCommitId() string {
+	if m != nil {
+		return m.RightCommitId
+	}
+	return ""
+}
+
+// A CommitDiffResponse corresponds to a single changed file in a commit.
+type CommitDiffResponse struct {
+	FromPath []byte `protobuf:"bytes,1,opt,name=from_path,json=fromPath,proto3" json:"from_path,omitempty"`
+	ToPath   []byte `protobuf:"bytes,2,opt,name=to_path,json=toPath,proto3" json:"to_path,omitempty"`
+	// Blob ID as returned via `git diff --full-index`
+	FromId    string   `protobuf:"bytes,3,opt,name=from_id,json=fromId" json:"from_id,omitempty"`
+	ToId      string   `protobuf:"bytes,4,opt,name=to_id,json=toId" json:"to_id,omitempty"`
+	OldMode   int32    `protobuf:"varint,5,opt,name=old_mode,json=oldMode" json:"old_mode,omitempty"`
+	NewMode   int32    `protobuf:"varint,6,opt,name=new_mode,json=newMode" json:"new_mode,omitempty"`
+	Binary    bool     `protobuf:"varint,7,opt,name=binary" json:"binary,omitempty"`
+	RawChunks [][]byte `protobuf:"bytes,8,rep,name=raw_chunks,json=rawChunks,proto3" json:"raw_chunks,omitempty"`
+}
+
+func (m *CommitDiffResponse) Reset()                    { *m = CommitDiffResponse{} }
+func (m *CommitDiffResponse) String() string            { return proto.CompactTextString(m) }
+func (*CommitDiffResponse) ProtoMessage()               {}
+func (*CommitDiffResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
+
+func (m *CommitDiffResponse) GetFromPath() []byte {
+	if m != nil {
+		return m.FromPath
+	}
+	return nil
+}
+
+func (m *CommitDiffResponse) GetToPath() []byte {
+	if m != nil {
+		return m.ToPath
+	}
+	return nil
+}
+
+func (m *CommitDiffResponse) GetFromId() string {
+	if m != nil {
+		return m.FromId
+	}
+	return ""
+}
+
+func (m *CommitDiffResponse) GetToId() string {
+	if m != nil {
+		return m.ToId
+	}
+	return ""
+}
+
+func (m *CommitDiffResponse) GetOldMode() int32 {
+	if m != nil {
+		return m.OldMode
+	}
+	return 0
+}
+
+func (m *CommitDiffResponse) GetNewMode() int32 {
+	if m != nil {
+		return m.NewMode
+	}
+	return 0
+}
+
+func (m *CommitDiffResponse) GetBinary() bool {
+	if m != nil {
+		return m.Binary
+	}
+	return false
+}
+
+func (m *CommitDiffResponse) GetRawChunks() [][]byte {
+	if m != nil {
+		return m.RawChunks
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*CommitDiffRequest)(nil), "gitaly.CommitDiffRequest")
+	proto.RegisterType((*CommitDiffResponse)(nil), "gitaly.CommitDiffResponse")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for Diff service
+
+type DiffClient interface {
+	// Returns stream of CommitDiffResponse: 1 per changed file
+	CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (Diff_CommitDiffClient, error)
+}
+
+type diffClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewDiffClient(cc *grpc.ClientConn) DiffClient {
+	return &diffClient{cc}
+}
+
+func (c *diffClient) CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (Diff_CommitDiffClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_Diff_serviceDesc.Streams[0], c.cc, "/gitaly.Diff/CommitDiff", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &diffCommitDiffClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type Diff_CommitDiffClient interface {
+	Recv() (*CommitDiffResponse, error)
+	grpc.ClientStream
+}
+
+type diffCommitDiffClient struct {
+	grpc.ClientStream
+}
+
+func (x *diffCommitDiffClient) Recv() (*CommitDiffResponse, error) {
+	m := new(CommitDiffResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Server API for Diff service
+
+type DiffServer interface {
+	// Returns stream of CommitDiffResponse: 1 per changed file
+	CommitDiff(*CommitDiffRequest, Diff_CommitDiffServer) error
+}
+
+func RegisterDiffServer(s *grpc.Server, srv DiffServer) {
+	s.RegisterService(&_Diff_serviceDesc, srv)
+}
+
+func _Diff_CommitDiff_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(CommitDiffRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(DiffServer).CommitDiff(m, &diffCommitDiffServer{stream})
+}
+
+type Diff_CommitDiffServer interface {
+	Send(*CommitDiffResponse) error
+	grpc.ServerStream
+}
+
+type diffCommitDiffServer struct {
+	grpc.ServerStream
+}
+
+func (x *diffCommitDiffServer) Send(m *CommitDiffResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+var _Diff_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.Diff",
+	HandlerType: (*DiffServer)(nil),
+	Methods:     []grpc.MethodDesc{},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "CommitDiff",
+			Handler:       _Diff_CommitDiff_Handler,
+			ServerStreams: true,
+		},
+	},
+	Metadata: "diff.proto",
+}
+
+func init() { proto.RegisterFile("diff.proto", fileDescriptor1) }
+
+var fileDescriptor1 = []byte{
+	// 328 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x91, 0xdd, 0x4a, 0xf3, 0x30,
+	0x18, 0xc7, 0xdf, 0xec, 0xa3, 0xeb, 0x9e, 0xb7, 0x2a, 0x46, 0xd0, 0x6e, 0x22, 0x94, 0x21, 0xd2,
+	0xa3, 0x21, 0xf3, 0x12, 0x26, 0xc8, 0x0e, 0x44, 0xc9, 0x0d, 0x94, 0x6c, 0x49, 0xd7, 0x60, 0xdb,
+	0xa7, 0xa6, 0x19, 0x65, 0x17, 0xe2, 0x25, 0x7a, 0x1f, 0xd2, 0xc4, 0xcd, 0x82, 0x1e, 0xe6, 0xf7,
+	0xfb, 0x27, 0x79, 0x3e, 0x00, 0x84, 0x4a, 0xd3, 0x79, 0xa5, 0xd1, 0x20, 0xf5, 0xb6, 0xca, 0xf0,
+	0x7c, 0x3f, 0x0d, 0xea, 0x8c, 0x6b, 0x29, 0x1c, 0x9d, 0x7d, 0x10, 0x38, 0x5f, 0x62, 0x51, 0x28,
+	0xf3, 0xa8, 0xd2, 0x94, 0xc9, 0xf7, 0x9d, 0xac, 0x0d, 0x5d, 0x00, 0x68, 0x59, 0x61, 0xad, 0x0c,
+	0xea, 0x7d, 0x48, 0x22, 0x12, 0xff, 0x5f, 0xd0, 0xb9, 0x7b, 0x60, 0xce, 0x8e, 0x86, 0x75, 0x52,
+	0xf4, 0x16, 0x4e, 0x73, 0x99, 0x9a, 0x64, 0x63, 0x5f, 0x4b, 0x94, 0x08, 0x7b, 0x11, 0x89, 0xc7,
+	0x2c, 0x68, 0xa9, 0xfb, 0x62, 0x25, 0xe8, 0x1d, 0x9c, 0x69, 0xb5, 0xcd, 0xba, 0xb1, 0xbe, 0x8d,
+	0x9d, 0x58, 0x7c, 0xc8, 0xcd, 0x3e, 0x09, 0xd0, 0x6e, 0x5d, 0x75, 0x85, 0x65, 0x2d, 0xe9, 0x35,
+	0x8c, 0x53, 0x8d, 0x45, 0x52, 0x71, 0x93, 0xd9, 0xba, 0x02, 0xe6, 0xb7, 0xe0, 0x95, 0x9b, 0x8c,
+	0x5e, 0xc1, 0xc8, 0xa0, 0x53, 0x3d, 0xab, 0x3c, 0x83, 0x07, 0x61, 0x6f, 0x1d, 0x3f, 0xf3, 0xda,
+	0xe3, 0x4a, 0xd0, 0x0b, 0x18, 0x1a, 0x6c, 0xf1, 0xc0, 0xe2, 0x81, 0xc1, 0x95, 0xa0, 0x13, 0xf0,
+	0x31, 0x17, 0x49, 0x81, 0x42, 0x86, 0xc3, 0x88, 0xc4, 0x43, 0x36, 0xc2, 0x5c, 0x3c, 0xa3, 0x90,
+	0xad, 0x2a, 0x65, 0xe3, 0x94, 0xe7, 0x54, 0x29, 0x1b, 0xab, 0x2e, 0xc1, 0x5b, 0xab, 0x92, 0xeb,
+	0x7d, 0x38, 0x8a, 0x48, 0xec, 0xb3, 0xef, 0x13, 0xbd, 0x01, 0xd0, 0xbc, 0x49, 0x36, 0xd9, 0xae,
+	0x7c, 0xab, 0x43, 0x3f, 0xea, 0xc7, 0x01, 0x1b, 0x6b, 0xde, 0x2c, 0x2d, 0x58, 0xbc, 0xc0, 0xa0,
+	0x6d, 0x90, 0x3e, 0x01, 0xfc, 0xb4, 0x4b, 0x27, 0x87, 0x59, 0xff, 0x5a, 0xcd, 0x74, 0xfa, 0x97,
+	0x72, 0xd3, 0x99, 0xfd, 0xbb, 0x27, 0x6b, 0xcf, 0xee, 0xf5, 0xe1, 0x2b, 0x00, 0x00, 0xff, 0xff,
+	0xca, 0xe9, 0x71, 0x86, 0xfb, 0x01, 0x00, 0x00,
+}

go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/helper/inforefs.go

+package helper
+
+import (
+	"io"
+
+	pb "gitlab.com/gitlab-org/gitaly-proto/go"
+)
+
+type InfoRefsClient interface {
+	Recv() (*pb.InfoRefsResponse, error)
+}
+
+type InfoRefsClientWriterTo struct {
+	InfoRefsClient
+}
+
+func (clientReader *InfoRefsClientWriterTo) WriteTo(w io.Writer) (total int64, err error) {
+	for {
+		response, err := clientReader.Recv()
+		if err == io.EOF {
+			return total, nil
+		} else if err != nil {
+			return total, err
+		}
+
+		n, err := w.Write(response.GetData())
+		total += int64(n)
+		if err != nil {
+			return total, err
+		}
+	}
+}

go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/notifications.pb.go

+// Code generated by protoc-gen-go.
+// source: notifications.proto
+// DO NOT EDIT!
+
+package gitaly
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type PostReceiveRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+}
+
+func (m *PostReceiveRequest) Reset()                    { *m = PostReceiveRequest{} }
+func (m *PostReceiveRequest) String() string            { return proto.CompactTextString(m) }
+func (*PostReceiveRequest) ProtoMessage()               {}
+func (*PostReceiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
+
+func (m *PostReceiveRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+type PostReceiveResponse struct {
+}
+
+func (m *PostReceiveResponse) Reset()                    { *m = PostReceiveResponse{} }
+func (m *PostReceiveResponse) String() string            { return proto.CompactTextString(m) }
+func (*PostReceiveResponse) ProtoMessage()               {}
+func (*PostReceiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }
+
+func init() {
+	proto.RegisterType((*PostReceiveRequest)(nil), "gitaly.PostReceiveRequest")
+	proto.RegisterType((*PostReceiveResponse)(nil), "gitaly.PostReceiveResponse")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for Notifications service
+
+type NotificationsClient interface {
+	PostReceive(ctx context.Context, in *PostReceiveRequest, opts ...grpc.CallOption) (*PostReceiveResponse, error)
+}
+
+type notificationsClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewNotificationsClient(cc *grpc.ClientConn) NotificationsClient {
+	return &notificationsClient{cc}
+}
+
+func (c *notificationsClient) PostReceive(ctx context.Context, in *PostReceiveRequest, opts ...grpc.CallOption) (*PostReceiveResponse, error) {
+	out := new(PostReceiveResponse)
+	err := grpc.Invoke(ctx, "/gitaly.Notifications/PostReceive", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for Notifications service
+
+type NotificationsServer interface {
+	PostReceive(context.Context, *PostReceiveRequest) (*PostReceiveResponse, error)
+}
+
+func RegisterNotificationsServer(s *grpc.Server, srv NotificationsServer) {
+	s.RegisterService(&_Notifications_serviceDesc, srv)
+}
+
+func _Notifications_PostReceive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(PostReceiveRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(NotificationsServer).PostReceive(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.Notifications/PostReceive",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(NotificationsServer).PostReceive(ctx, req.(*PostReceiveRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Notifications_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.Notifications",
+	HandlerType: (*NotificationsServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "PostReceive",
+			Handler:    _Notifications_PostReceive_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "notifications.proto",
+}
+
+func init() { proto.RegisterFile("notifications.proto", fileDescriptor2) }
+
+var fileDescriptor2 = []byte{
+	// 163 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xce, 0xcb, 0x2f, 0xc9,
+	0x4c, 0xcb, 0x4c, 0x4e, 0x2c, 0xc9, 0xcc, 0xcf, 0x2b, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17,
+	0x62, 0x4b, 0xcf, 0x2c, 0x49, 0xcc, 0xa9, 0x94, 0xe2, 0x29, 0xce, 0x48, 0x2c, 0x4a, 0x4d, 0x81,
+	0x88, 0x2a, 0x79, 0x70, 0x09, 0x05, 0xe4, 0x17, 0x97, 0x04, 0xa5, 0x26, 0xa7, 0x66, 0x96, 0xa5,
+	0x06, 0xa5, 0x16, 0x96, 0xa6, 0x16, 0x97, 0x08, 0x19, 0x71, 0x71, 0x15, 0xa5, 0x16, 0xe4, 0x17,
+	0x67, 0x96, 0xe4, 0x17, 0x55, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x1b, 0x09, 0xe9, 0x41, 0x0c,
+	0xd0, 0x0b, 0x82, 0xcb, 0x04, 0x21, 0xa9, 0x52, 0x12, 0xe5, 0x12, 0x46, 0x31, 0xa9, 0xb8, 0x20,
+	0x3f, 0xaf, 0x38, 0xd5, 0x28, 0x92, 0x8b, 0xd7, 0x0f, 0xd9, 0x35, 0x42, 0x1e, 0x5c, 0xdc, 0x48,
+	0xea, 0x84, 0xa4, 0x60, 0xc6, 0x62, 0x3a, 0x43, 0x4a, 0x1a, 0xab, 0x1c, 0xc4, 0x60, 0x25, 0x86,
+	0x24, 0x36, 0xb0, 0x17, 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xf2, 0x5e, 0x1f, 0x64, 0xef,
+	0x00, 0x00, 0x00,
+}

go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/shared.pb.go

+// Code generated by protoc-gen-go.
+// source: shared.proto
+// DO NOT EDIT!
+
+package gitaly
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type Repository struct {
+	Path         string `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
+	StorageName  string `protobuf:"bytes,2,opt,name=storage_name,json=storageName" json:"storage_name,omitempty"`
+	RelativePath string `protobuf:"bytes,3,opt,name=relative_path,json=relativePath" json:"relative_path,omitempty"`
+}
+
+func (m *Repository) Reset()                    { *m = Repository{} }
+func (m *Repository) String() string            { return proto.CompactTextString(m) }
+func (*Repository) ProtoMessage()               {}
+func (*Repository) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} }
+
+func (m *Repository) GetPath() string {
+	if m != nil {
+		return m.Path
+	}
+	return ""
+}
+
+func (m *Repository) GetStorageName() string {
+	if m != nil {
+		return m.StorageName
+	}
+	return ""
+}
+
+func (m *Repository) GetRelativePath() string {
+	if m != nil {
+		return m.RelativePath
+	}
+	return ""
+}
+
+type ExitStatus struct {
+	Value int32 `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
+}
+
+func (m *ExitStatus) Reset()                    { *m = ExitStatus{} }
+func (m *ExitStatus) String() string            { return proto.CompactTextString(m) }
+func (*ExitStatus) ProtoMessage()               {}
+func (*ExitStatus) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{1} }
+
+func (m *ExitStatus) GetValue() int32 {
+	if m != nil {
+		return m.Value
+	}
+	return 0
+}
+
+func init() {
+	proto.RegisterType((*Repository)(nil), "gitaly.Repository")
+	proto.RegisterType((*ExitStatus)(nil), "gitaly.ExitStatus")
+}
+
+func init() { proto.RegisterFile("shared.proto", fileDescriptor4) }
+
+var fileDescriptor4 = []byte{
+	// 161 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x34, 0x8e, 0xb1, 0xca, 0xc2, 0x40,
+	0x10, 0x84, 0xc9, 0xff, 0x9b, 0x80, 0x6b, 0x6c, 0x16, 0x8b, 0x94, 0x1a, 0x1b, 0x2b, 0x1b, 0x9f,
+	0xc1, 0x56, 0xe4, 0x7c, 0x80, 0xb0, 0xe2, 0x92, 0x3b, 0xb8, 0x78, 0xc7, 0xdd, 0x26, 0x98, 0xb7,
+	0x17, 0x56, 0xed, 0x76, 0xbf, 0x99, 0x61, 0x06, 0xea, 0x6c, 0x29, 0xf1, 0xe3, 0x18, 0x53, 0x90,
+	0x80, 0x55, 0xef, 0x84, 0xfc, 0xdc, 0x5a, 0x00, 0xc3, 0x31, 0x64, 0x27, 0x21, 0xcd, 0x88, 0xb0,
+	0x88, 0x24, 0xb6, 0x29, 0xb6, 0xc5, 0x61, 0x69, 0xf4, 0xc6, 0x1d, 0xd4, 0x59, 0x42, 0xa2, 0x9e,
+	0xbb, 0x27, 0x0d, 0xdc, 0xfc, 0xa9, 0xb6, 0xfa, 0xb2, 0x0b, 0x0d, 0x8c, 0x7b, 0x58, 0x27, 0xf6,
+	0x24, 0x6e, 0xe2, 0x4e, 0xf3, 0xff, 0xea, 0xa9, 0x7f, 0xf0, 0x4a, 0x62, 0xdb, 0x16, 0xe0, 0xfc,
+	0x72, 0x72, 0x13, 0x92, 0x31, 0xe3, 0x06, 0xca, 0x89, 0xfc, 0xc8, 0x5a, 0x55, 0x9a, 0xcf, 0x73,
+	0xaf, 0x74, 0xdc, 0xe9, 0x1d, 0x00, 0x00, 0xff, 0xff, 0xbd, 0xf7, 0x56, 0x73, 0xac, 0x00, 0x00,
+	0x00,
+}

go/vendor/gitlab.com/gitlab-org/gitaly-proto/go/smarthttp.pb.go

+// Code generated by protoc-gen-go.
+// source: smarthttp.proto
+// DO NOT EDIT!
+
+package gitaly
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type InfoRefsRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+}
+
+func (m *InfoRefsRequest) Reset()                    { *m = InfoRefsRequest{} }
+func (m *InfoRefsRequest) String() string            { return proto.CompactTextString(m) }
+func (*InfoRefsRequest) ProtoMessage()               {}
+func (*InfoRefsRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} }
+
+func (m *InfoRefsRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+type InfoRefsResponse struct {
+	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *InfoRefsResponse) Reset()                    { *m = InfoRefsResponse{} }
+func (m *InfoRefsResponse) String() string            { return proto.CompactTextString(m) }
+func (*InfoRefsResponse) ProtoMessage()               {}
+func (*InfoRefsResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{1} }
+
+func (m *InfoRefsResponse) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+type PostUploadPackRequest struct {
+	// repository should only be present in the first message of the stream
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	// Raw data to be copied to stdin of 'git upload-pack'
+	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *PostUploadPackRequest) Reset()                    { *m = PostUploadPackRequest{} }
+func (m *PostUploadPackRequest) String() string            { return proto.CompactTextString(m) }
+func (*PostUploadPackRequest) ProtoMessage()               {}
+func (*PostUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{2} }
+
+func (m *PostUploadPackRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *PostUploadPackRequest) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+type PostUploadPackResponse struct {
+	// Raw data from stdout of 'git upload-pack'
+	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *PostUploadPackResponse) Reset()                    { *m = PostUploadPackResponse{} }
+func (m *PostUploadPackResponse) String() string            { return proto.CompactTextString(m) }
+func (*PostUploadPackResponse) ProtoMessage()               {}
+func (*PostUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{3} }
+
+func (m *PostUploadPackResponse) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+type PostReceivePackRequest struct {
+	// repository should only be present in the first message of the stream
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	// Raw data to be copied to stdin of 'git receive-pack'
+	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
+	// gl_id becomes env variable GL_ID, used by the Git {pre,post}-receive
+	// hooks. Should only be present in the first message of the stream.
+	GlId string `protobuf:"bytes,3,opt,name=gl_id,json=glId" json:"gl_id,omitempty"`
+}
+
+func (m *PostReceivePackRequest) Reset()                    { *m = PostReceivePackRequest{} }
+func (m *PostReceivePackRequest) String() string            { return proto.CompactTextString(m) }
+func (*PostReceivePackRequest) ProtoMessage()               {}
+func (*PostReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{4} }
+
+func (m *PostReceivePackRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *PostReceivePackRequest) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+func (m *PostReceivePackRequest) GetGlId() string {
+	if m != nil {
+		return m.GlId
+	}
+	return ""
+}
+
+type PostReceivePackResponse struct {
+	// Raw data from stdout of 'git receive-pack'
+	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *PostReceivePackResponse) Reset()                    { *m = PostReceivePackResponse{} }
+func (m *PostReceivePackResponse) String() string            { return proto.CompactTextString(m) }
+func (*PostReceivePackResponse) ProtoMessage()               {}
+func (*PostReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{5} }
+
+func (m *PostReceivePackResponse) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*InfoRefsRequest)(nil), "gitaly.InfoRefsRequest")
+	proto.RegisterType((*InfoRefsResponse)(nil), "gitaly.InfoRefsResponse")
+	proto.RegisterType((*PostUploadPackRequest)(nil), "gitaly.PostUploadPackRequest")
+	proto.RegisterType((*PostUploadPackResponse)(nil), "gitaly.PostUploadPackResponse")
+	proto.RegisterType((*PostReceivePackRequest)(nil), "gitaly.PostReceivePackRequest")
+	proto.RegisterType((*PostReceivePackResponse)(nil), "gitaly.PostReceivePackResponse")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for SmartHTTP service
+
+type SmartHTTPClient interface {
+	// The response body for GET /info/refs?service=git-upload-pack
+	InfoRefsUploadPack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsUploadPackClient, error)
+	// The response body for GET /info/refs?service=git-receive-pack
+	InfoRefsReceivePack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsReceivePackClient, error)
+	// Request and response body for POST /upload-pack
+	PostUploadPack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostUploadPackClient, error)
+	// Request and response body for POST /receive-pack
+	PostReceivePack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostReceivePackClient, error)
+}
+
+type smartHTTPClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewSmartHTTPClient(cc *grpc.ClientConn) SmartHTTPClient {
+	return &smartHTTPClient{cc}
+}
+
+func (c *smartHTTPClient) InfoRefsUploadPack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsUploadPackClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[0], c.cc, "/gitaly.SmartHTTP/InfoRefsUploadPack", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &smartHTTPInfoRefsUploadPackClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type SmartHTTP_InfoRefsUploadPackClient interface {
+	Recv() (*InfoRefsResponse, error)
+	grpc.ClientStream
+}
+
+type smartHTTPInfoRefsUploadPackClient struct {
+	grpc.ClientStream
+}
+
+func (x *smartHTTPInfoRefsUploadPackClient) Recv() (*InfoRefsResponse, error) {
+	m := new(InfoRefsResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *smartHTTPClient) InfoRefsReceivePack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsReceivePackClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[1], c.cc, "/gitaly.SmartHTTP/InfoRefsReceivePack", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &smartHTTPInfoRefsReceivePackClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type SmartHTTP_InfoRefsReceivePackClient interface {
+	Recv() (*InfoRefsResponse, error)
+	grpc.ClientStream
+}
+
+type smartHTTPInfoRefsReceivePackClient struct {
+	grpc.ClientStream
+}
+
+func (x *smartHTTPInfoRefsReceivePackClient) Recv() (*InfoRefsResponse, error) {
+	m := new(InfoRefsResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *smartHTTPClient) PostUploadPack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostUploadPackClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[2], c.cc, "/gitaly.SmartHTTP/PostUploadPack", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &smartHTTPPostUploadPackClient{stream}
+	return x, nil
+}
+
+type SmartHTTP_PostUploadPackClient interface {
+	Send(*PostUploadPackRequest) error
+	Recv() (*PostUploadPackResponse, error)
+	grpc.ClientStream
+}
+
+type smartHTTPPostUploadPackClient struct {
+	grpc.ClientStream
+}
+
+func (x *smartHTTPPostUploadPackClient) Send(m *PostUploadPackRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *smartHTTPPostUploadPackClient) Recv() (*PostUploadPackResponse, error) {
+	m := new(PostUploadPackResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *smartHTTPClient) PostReceivePack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostReceivePackClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[3], c.cc, "/gitaly.SmartHTTP/PostReceivePack", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &smartHTTPPostReceivePackClient{stream}
+	return x, nil
+}
+
+type SmartHTTP_PostReceivePackClient interface {
+	Send(*PostReceivePackRequest) error
+	Recv() (*PostReceivePackResponse, error)
+	grpc.ClientStream
+}
+
+type smartHTTPPostReceivePackClient struct {
+	grpc.ClientStream
+}
+
+func (x *smartHTTPPostReceivePackClient) Send(m *PostReceivePackRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *smartHTTPPostReceivePackClient) Recv() (*PostReceivePackResponse, error) {
+	m := new(PostReceivePackResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Server API for SmartHTTP service
+
+type SmartHTTPServer interface {
+	// The response body for GET /info/refs?service=git-upload-pack
+	InfoRefsUploadPack(*InfoRefsRequest, SmartHTTP_InfoRefsUploadPackServer) error
+	// The response body for GET /info/refs?service=git-receive-pack
+	InfoRefsReceivePack(*InfoRefsRequest, SmartHTTP_InfoRefsReceivePackServer) error
+	// Request and response body for POST /upload-pack
+	PostUploadPack(SmartHTTP_PostUploadPackServer) error
+	// Request and response body for POST /receive-pack
+	PostReceivePack(SmartHTTP_PostReceivePackServer) error
+}
+
+func RegisterSmartHTTPServer(s *grpc.Server, srv SmartHTTPServer) {
+	s.RegisterService(&_SmartHTTP_serviceDesc, srv)
+}
+
+func _SmartHTTP_InfoRefsUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(InfoRefsRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(SmartHTTPServer).InfoRefsUploadPack(m, &smartHTTPInfoRefsUploadPackServer{stream})
+}
+
+type SmartHTTP_InfoRefsUploadPackServer interface {
+	Send(*InfoRefsResponse) error
+	grpc.ServerStream
+}
+
+type smartHTTPInfoRefsUploadPackServer struct {
+	grpc.ServerStream
+}
+
+func (x *smartHTTPInfoRefsUploadPackServer) Send(m *InfoRefsResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func _SmartHTTP_InfoRefsReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(InfoRefsRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(SmartHTTPServer).InfoRefsReceivePack(m, &smartHTTPInfoRefsReceivePackServer{stream})
+}
+
+type SmartHTTP_InfoRefsReceivePackServer interface {
+	Send(*InfoRefsResponse) error
+	grpc.ServerStream
+}
+
+type smartHTTPInfoRefsReceivePackServer struct {
+	grpc.ServerStream
+}
+
+func (x *smartHTTPInfoRefsReceivePackServer) Send(m *InfoRefsResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func _SmartHTTP_PostUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(SmartHTTPServer).PostUploadPack(&smartHTTPPostUploadPackServer{stream})
+}
+
+type SmartHTTP_PostUploadPackServer interface {
+	Send(*PostUploadPackResponse) error
+	Recv() (*PostUploadPackRequest, error)
+	grpc.ServerStream
+}
+
+type smartHTTPPostUploadPackServer struct {
+	grpc.ServerStream
+}
+
+func (x *smartHTTPPostUploadPackServer) Send(m *PostUploadPackResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *smartHTTPPostUploadPackServer) Recv() (*PostUploadPackRequest, error) {
+	m := new(PostUploadPackRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func _SmartHTTP_PostReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(SmartHTTPServer).PostReceivePack(&smartHTTPPostReceivePackServer{stream})
+}
+
+type SmartHTTP_PostReceivePackServer interface {
+	Send(*PostReceivePackResponse) error
+	Recv() (*PostReceivePackRequest, error)
+	grpc.ServerStream
+}
+
+type smartHTTPPostReceivePackServer struct {
+	grpc.ServerStream
+}
+
+func (x *smartHTTPPostReceivePackServer) Send(m *PostReceivePackResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *smartHTTPPostReceivePackServer) Recv() (*PostReceivePackRequest, error) {
+	m := new(PostReceivePackRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+var _SmartHTTP_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.SmartHTTP",
+	HandlerType: (*SmartHTTPServer)(nil),
+	Methods:     []grpc.MethodDesc{},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "InfoRefsUploadPack",
+			Handler:       _SmartHTTP_InfoRefsUploadPack_Handler,
+			ServerStreams: true,
+		},
+		{
+			StreamName:    "InfoRefsReceivePack",
+			Handler:       _SmartHTTP_InfoRefsReceivePack_Handler,
+			ServerStreams: true,
+		},
+		{
+			StreamName:    "PostUploadPack",
+			Handler:       _SmartHTTP_PostUploadPack_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
+		{
+			StreamName:    "PostReceivePack",
+			Handler:       _SmartHTTP_PostReceivePack_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
+	},
+	Metadata: "smarthttp.proto",
+}
+
+func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor5) }
+
+var fileDescriptor5 = []byte{
+	// 304 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x53, 0x4d, 0x4b, 0xc3, 0x40,
+	0x14, 0x74, 0x6b, 0x2d, 0xf4, 0x59, 0xac, 0xbc, 0xa2, 0x0d, 0x01, 0xb5, 0xe4, 0x20, 0x39, 0x68,
+	0x28, 0xf1, 0x37, 0x08, 0x16, 0x3d, 0x84, 0xb5, 0x05, 0x6f, 0x65, 0x6d, 0xb6, 0x69, 0x30, 0x76,
+	0xe3, 0xee, 0x56, 0xe8, 0x2f, 0xf5, 0xef, 0x88, 0x09, 0xf9, 0x68, 0x62, 0x3c, 0x28, 0xde, 0xc2,
+	0x9b, 0xf7, 0x66, 0x26, 0x33, 0x2c, 0xf4, 0xd5, 0x2b, 0x93, 0x7a, 0xa5, 0x75, 0xec, 0xc4, 0x52,
+	0x68, 0x81, 0x9d, 0x20, 0xd4, 0x2c, 0xda, 0x9a, 0x3d, 0xb5, 0x62, 0x92, 0xfb, 0xe9, 0xd4, 0xba,
+	0x85, 0xfe, 0x64, 0xbd, 0x14, 0x94, 0x2f, 0x15, 0xe5, 0x6f, 0x1b, 0xae, 0x34, 0xba, 0x00, 0x92,
+	0xc7, 0x42, 0x85, 0x5a, 0xc8, 0xad, 0x41, 0x46, 0xc4, 0x3e, 0x74, 0xd1, 0x49, 0xaf, 0x1d, 0x9a,
+	0x23, 0xb4, 0xb4, 0x65, 0x5d, 0xc2, 0x71, 0x41, 0xa3, 0x62, 0xb1, 0x56, 0x1c, 0x11, 0xda, 0x3e,
+	0xd3, 0x2c, 0x61, 0xe8, 0xd1, 0xe4, 0xdb, 0x9a, 0xc3, 0x89, 0x27, 0x94, 0x9e, 0xc5, 0x91, 0x60,
+	0xbe, 0xc7, 0x16, 0x2f, 0x7f, 0x10, 0xcd, 0x05, 0x5a, 0x25, 0x81, 0x2b, 0x38, 0xad, 0x0a, 0xfc,
+	0x60, 0x67, 0x93, 0x6e, 0x53, 0xbe, 0xe0, 0xe1, 0x3b, 0xff, 0x07, 0x3f, 0x38, 0x80, 0x83, 0x20,
+	0x9a, 0x87, 0xbe, 0xb1, 0x3f, 0x22, 0x76, 0x97, 0xb6, 0x83, 0x68, 0xe2, 0x5b, 0xd7, 0x30, 0xac,
+	0xc9, 0x36, 0xbb, 0x74, 0x3f, 0x5a, 0xd0, 0x7d, 0xfc, 0x6a, 0xf3, 0x6e, 0x3a, 0xf5, 0xf0, 0x1e,
+	0x30, 0x8b, 0xba, 0xf8, 0x4b, 0x1c, 0x66, 0xde, 0x2a, 0x6d, 0x9a, 0x46, 0x1d, 0x48, 0xa5, 0xac,
+	0xbd, 0x31, 0xc1, 0x07, 0x18, 0x14, 0xf3, 0xdc, 0xcd, 0x6f, 0xd9, 0x66, 0x70, 0xb4, 0x1b, 0x3e,
+	0x9e, 0x65, 0xfb, 0xdf, 0xb6, 0x6e, 0x9e, 0x37, 0xc1, 0x19, 0xa9, 0x4d, 0xc6, 0x04, 0x9f, 0xa0,
+	0x5f, 0x89, 0x0b, 0x77, 0x0e, 0xeb, 0xf5, 0x99, 0x17, 0x8d, 0x78, 0x99, 0xf9, 0xb9, 0x93, 0x3c,
+	0x82, 0x9b, 0xcf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x16, 0x3e, 0x9b, 0xd1, 0x2d, 0x03, 0x00, 0x00,
+}

go/vendor/golang.org/x/net/LICENSE

+Copyright (c) 2009 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.