TUN-528: Move cloudflared into a separate repo

vendor/zombiezen.com/go/capnproto2/internal/demo/BUILD.bazel

@@ -0,0 +1,24 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["doc.go"],
+    importpath = "zombiezen.com/go/capnproto2/internal/demo",
+    visibility = ["//:__subpackages__"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "book_test.go",
+        "hash_test.go",
+    ],
+    embed = [":go_default_library"],
+    deps = [
+        "//:go_default_library",
+        "//internal/demo/books:go_default_library",
+        "//internal/demo/hashes:go_default_library",
+        "//rpc:go_default_library",
+        "@org_golang_x_net//context:go_default_library",
+    ],
+)

vendor/zombiezen.com/go/capnproto2/internal/demo/book_test.go

@@ -0,0 +1,61 @@
+package demo_test
+
+import (
+	"fmt"
+	"io"
+
+	"zombiezen.com/go/capnproto2"
+	"zombiezen.com/go/capnproto2/internal/demo/books"
+)
+
+func Example_book() {
+	r, w := io.Pipe()
+	go writer(w)
+	reader(r)
+	// Output:
+	// "War and Peace" has 1440 pages
+}
+
+func writer(out io.Writer) {
+	// Make a brand new empty message.  A Message allocates Cap'n Proto structs.
+	msg, seg, err := capnp.NewMessage(capnp.SingleSegment(nil))
+	if err != nil {
+		panic(err)
+	}
+
+	// Create a new Book struct.  Every message must have a root struct.
+	book, err := books.NewRootBook(seg)
+	if err != nil {
+		panic(err)
+	}
+	book.SetTitle("War and Peace")
+	book.SetPageCount(1440)
+
+	// Write the message to stdout.
+	err = capnp.NewEncoder(out).Encode(msg)
+	if err != nil {
+		panic(err)
+	}
+}
+
+func reader(in io.Reader) {
+	// Read the message from stdin.
+	msg, err := capnp.NewDecoder(in).Decode()
+	if err != nil {
+		panic(err)
+	}
+
+	// Extract the root struct from the message.
+	book, err := books.ReadRootBook(msg)
+	if err != nil {
+		panic(err)
+	}
+
+	// Access fields from the struct.
+	title, err := book.Title()
+	if err != nil {
+		panic(err)
+	}
+	pageCount := book.PageCount()
+	fmt.Printf("%q has %d pages\n", title, pageCount)
+}

vendor/zombiezen.com/go/capnproto2/internal/demo/books/BUILD.bazel

@@ -0,0 +1,16 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "books.capnp.go",
+        "gen.go",
+    ],
+    importpath = "zombiezen.com/go/capnproto2/internal/demo/books",
+    visibility = ["//:__subpackages__"],
+    deps = [
+        "//:go_default_library",
+        "//encoding/text:go_default_library",
+        "//schemas:go_default_library",
+    ],
+)

vendor/zombiezen.com/go/capnproto2/internal/demo/books/books.capnp

@@ -0,0 +1,12 @@
+using Go = import "/go.capnp";
+@0x85d3acc39d94e0f8;
+$Go.package("books");
+$Go.import("zombiezen.com/go/capnproto2/internal/demo/books");
+
+struct Book {
+	title @0 :Text;
+	# Title of the book.
+
+	pageCount @1 :Int32;
+	# Number of pages in the book.
+}

vendor/zombiezen.com/go/capnproto2/internal/demo/books/books.capnp.go

@@ -0,0 +1,104 @@
+// Code generated by capnpc-go. DO NOT EDIT.
+
+package books
+
+import (
+	capnp "zombiezen.com/go/capnproto2"
+	text "zombiezen.com/go/capnproto2/encoding/text"
+	schemas "zombiezen.com/go/capnproto2/schemas"
+)
+
+type Book struct{ capnp.Struct }
+
+// Book_TypeID is the unique identifier for the type Book.
+const Book_TypeID = 0x8100cc88d7d4d47c
+
+func NewBook(s *capnp.Segment) (Book, error) {
+	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
+	return Book{st}, err
+}
+
+func NewRootBook(s *capnp.Segment) (Book, error) {
+	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
+	return Book{st}, err
+}
+
+func ReadRootBook(msg *capnp.Message) (Book, error) {
+	root, err := msg.RootPtr()
+	return Book{root.Struct()}, err
+}
+
+func (s Book) String() string {
+	str, _ := text.Marshal(0x8100cc88d7d4d47c, s.Struct)
+	return str
+}
+
+func (s Book) Title() (string, error) {
+	p, err := s.Struct.Ptr(0)
+	return p.Text(), err
+}
+
+func (s Book) HasTitle() bool {
+	p, err := s.Struct.Ptr(0)
+	return p.IsValid() || err != nil
+}
+
+func (s Book) TitleBytes() ([]byte, error) {
+	p, err := s.Struct.Ptr(0)
+	return p.TextBytes(), err
+}
+
+func (s Book) SetTitle(v string) error {
+	return s.Struct.SetText(0, v)
+}
+
+func (s Book) PageCount() int32 {
+	return int32(s.Struct.Uint32(0))
+}
+
+func (s Book) SetPageCount(v int32) {
+	s.Struct.SetUint32(0, uint32(v))
+}
+
+// Book_List is a list of Book.
+type Book_List struct{ capnp.List }
+
+// NewBook creates a new list of Book.
+func NewBook_List(s *capnp.Segment, sz int32) (Book_List, error) {
+	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1}, sz)
+	return Book_List{l}, err
+}
+
+func (s Book_List) At(i int) Book { return Book{s.List.Struct(i)} }
+
+func (s Book_List) Set(i int, v Book) error { return s.List.SetStruct(i, v.Struct) }
+
+func (s Book_List) String() string {
+	str, _ := text.MarshalList(0x8100cc88d7d4d47c, s.List)
+	return str
+}
+
+// Book_Promise is a wrapper for a Book promised by a client call.
+type Book_Promise struct{ *capnp.Pipeline }
+
+func (p Book_Promise) Struct() (Book, error) {
+	s, err := p.Pipeline.Struct()
+	return Book{s}, err
+}
+
+const schema_85d3acc39d94e0f8 = "x\xda\x12\x88w`2d\xdd\xcf\xc8\xc0\x10(\xc2\xca" +
+	"\xb6\xbf\xe6\xca\x95\xeb\x1dg\x1a\x03y\x18\x19\xff\xffx" +
+	"0e\xee\xe15\x97[\x19X\x19\xd9\x19\x18\x04\x8fv" +
+	"\x09\x9e\x05\xd1'\xcb\x19t\xff'\xe5\xe7g\x17\xeb%" +
+	"'2\x16\xe4\x15X9\xe5\xe7g30\x0402\x06" +
+	"r0\xb300\xb0020\x08j\x1a10\x04\xaa" +
+	"03\x06\x1a0122\x8a0\x82\xc4t\x83\x18\x18" +
+	"\x02u\x98\x19\x03-\x98\x18\xe5K2KrR\x19y" +
+	"\x18\x98\x18y\x18\x18\xff\x17$\xa6\xa7:\xe7\x97\xe61" +
+	"0\x960\xb2001\xb200\x02\x02\x00\x00\xff\xff" +
+	"F\xa9$\xae"
+
+func init() {
+	schemas.Register(schema_85d3acc39d94e0f8,
+		0x8100cc88d7d4d47c)
+}

vendor/zombiezen.com/go/capnproto2/internal/demo/books/gen.go

@@ -0,0 +1,3 @@
+//go:generate capnp compile -I ../../../std -ogo books.capnp
+
+package books

vendor/zombiezen.com/go/capnproto2/internal/demo/doc.go

@@ -0,0 +1,2 @@
+// Package demo contains example tests.
+package demo

vendor/zombiezen.com/go/capnproto2/internal/demo/hash_test.go

@@ -0,0 +1,93 @@
+package demo_test
+
+import (
+	"crypto/sha1"
+	"fmt"
+	"hash"
+	"net"
+
+	"golang.org/x/net/context"
+	"zombiezen.com/go/capnproto2/internal/demo/hashes"
+	"zombiezen.com/go/capnproto2/rpc"
+)
+
+// hashFactory is a local implementation of HashFactory.
+type hashFactory struct{}
+
+func (hf hashFactory) NewSha1(call hashes.HashFactory_newSha1) error {
+	// Create a new locally implemented Hash capability.
+	hs := hashes.Hash_ServerToClient(hashServer{sha1.New()})
+	// Notice that methods can return other interfaces.
+	return call.Results.SetHash(hs)
+}
+
+// hashServer is a local implementation of Hash.
+type hashServer struct {
+	h hash.Hash
+}
+
+func (hs hashServer) Write(call hashes.Hash_write) error {
+	data, err := call.Params.Data()
+	if err != nil {
+		return err
+	}
+	_, err = hs.h.Write(data)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (hs hashServer) Sum(call hashes.Hash_sum) error {
+	s := hs.h.Sum(nil)
+	return call.Results.SetHash(s)
+}
+
+func server(c net.Conn) error {
+	// Create a new locally implemented HashFactory.
+	main := hashes.HashFactory_ServerToClient(hashFactory{})
+	// Listen for calls, using the HashFactory as the bootstrap interface.
+	conn := rpc.NewConn(rpc.StreamTransport(c), rpc.MainInterface(main.Client))
+	// Wait for connection to abort.
+	err := conn.Wait()
+	return err
+}
+
+func client(ctx context.Context, c net.Conn) error {
+	// Create a connection that we can use to get the HashFactory.
+	conn := rpc.NewConn(rpc.StreamTransport(c))
+	defer conn.Close()
+	// Get the "bootstrap" interface.  This is the capability set with
+	// rpc.MainInterface on the remote side.
+	hf := hashes.HashFactory{Client: conn.Bootstrap(ctx)}
+
+	// Now we can call methods on hf, and they will be sent over c.
+	s := hf.NewSha1(ctx, nil).Hash()
+	// s refers to a remote Hash.  Method calls are delivered in order.
+	s.Write(ctx, func(p hashes.Hash_write_Params) error {
+		err := p.SetData([]byte("Hello, "))
+		return err
+	})
+	s.Write(ctx, func(p hashes.Hash_write_Params) error {
+		err := p.SetData([]byte("World!"))
+		return err
+	})
+	result, err := s.Sum(ctx, nil).Struct()
+	if err != nil {
+		return err
+	}
+	sha1Val, err := result.Hash()
+	if err != nil {
+		return err
+	}
+	fmt.Printf("sha1: %x\n", sha1Val)
+	return nil
+}
+
+func Example_hash() {
+	c1, c2 := net.Pipe()
+	go server(c1)
+	client(context.Background(), c2)
+	// Output:
+	// sha1: 0a0a9f2a6772942557ab5355d76af442f8f65e01
+}

vendor/zombiezen.com/go/capnproto2/internal/demo/hashes/BUILD.bazel

@@ -0,0 +1,18 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "gen.go",
+        "hash.capnp.go",
+    ],
+    importpath = "zombiezen.com/go/capnproto2/internal/demo/hashes",
+    visibility = ["//:__subpackages__"],
+    deps = [
+        "//:go_default_library",
+        "//encoding/text:go_default_library",
+        "//schemas:go_default_library",
+        "//server:go_default_library",
+        "@org_golang_x_net//context:go_default_library",
+    ],
+)

vendor/zombiezen.com/go/capnproto2/internal/demo/hashes/gen.go

@@ -0,0 +1,3 @@
+//go:generate capnp compile -I ../../../std -ogo hash.capnp
+
+package hashes

vendor/zombiezen.com/go/capnproto2/internal/demo/hashes/hash.capnp

@@ -0,0 +1,13 @@
+using Go = import "/go.capnp";
+@0xdb8274f9144abc7e;
+$Go.package("hashes");
+$Go.import("zombiezen.com/go/capnproto2/internal/demo/hashes");
+
+interface HashFactory {
+	newSha1 @0 () -> (hash :Hash);
+}
+
+interface Hash {
+	write @0 (data :Data) -> ();
+	sum @1 () -> (hash :Data);
+}

vendor/zombiezen.com/go/capnproto2/internal/demo/hashes/hash.capnp.go

@@ -0,0 +1,605 @@
+// Code generated by capnpc-go. DO NOT EDIT.
+
+package hashes
+
+import (
+	context "golang.org/x/net/context"
+	capnp "zombiezen.com/go/capnproto2"
+	text "zombiezen.com/go/capnproto2/encoding/text"
+	schemas "zombiezen.com/go/capnproto2/schemas"
+	server "zombiezen.com/go/capnproto2/server"
+)
+
+type HashFactory struct{ Client capnp.Client }
+
+// HashFactory_TypeID is the unique identifier for the type HashFactory.
+const HashFactory_TypeID = 0xaead580f97fddabc
+
+func (c HashFactory) NewSha1(ctx context.Context, params func(HashFactory_newSha1_Params) error, opts ...capnp.CallOption) HashFactory_newSha1_Results_Promise {
+	if c.Client == nil {
+		return HashFactory_newSha1_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
+	}
+	call := &capnp.Call{
+		Ctx: ctx,
+		Method: capnp.Method{
+			InterfaceID:   0xaead580f97fddabc,
+			MethodID:      0,
+			InterfaceName: "hash.capnp:HashFactory",
+			MethodName:    "newSha1",
+		},
+		Options: capnp.NewCallOptions(opts),
+	}
+	if params != nil {
+		call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 0}
+		call.ParamsFunc = func(s capnp.Struct) error { return params(HashFactory_newSha1_Params{Struct: s}) }
+	}
+	return HashFactory_newSha1_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
+}
+
+type HashFactory_Server interface {
+	NewSha1(HashFactory_newSha1) error
+}
+
+func HashFactory_ServerToClient(s HashFactory_Server) HashFactory {
+	c, _ := s.(server.Closer)
+	return HashFactory{Client: server.New(HashFactory_Methods(nil, s), c)}
+}
+
+func HashFactory_Methods(methods []server.Method, s HashFactory_Server) []server.Method {
+	if cap(methods) == 0 {
+		methods = make([]server.Method, 0, 1)
+	}
+
+	methods = append(methods, server.Method{
+		Method: capnp.Method{
+			InterfaceID:   0xaead580f97fddabc,
+			MethodID:      0,
+			InterfaceName: "hash.capnp:HashFactory",
+			MethodName:    "newSha1",
+		},
+		Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
+			call := HashFactory_newSha1{c, opts, HashFactory_newSha1_Params{Struct: p}, HashFactory_newSha1_Results{Struct: r}}
+			return s.NewSha1(call)
+		},
+		ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
+	})
+
+	return methods
+}
+
+// HashFactory_newSha1 holds the arguments for a server call to HashFactory.newSha1.
+type HashFactory_newSha1 struct {
+	Ctx     context.Context
+	Options capnp.CallOptions
+	Params  HashFactory_newSha1_Params
+	Results HashFactory_newSha1_Results
+}
+
+type HashFactory_newSha1_Params struct{ capnp.Struct }
+
+// HashFactory_newSha1_Params_TypeID is the unique identifier for the type HashFactory_newSha1_Params.
+const HashFactory_newSha1_Params_TypeID = 0x92b20ad1a58ca0ca
+
+func NewHashFactory_newSha1_Params(s *capnp.Segment) (HashFactory_newSha1_Params, error) {
+	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
+	return HashFactory_newSha1_Params{st}, err
+}
+
+func NewRootHashFactory_newSha1_Params(s *capnp.Segment) (HashFactory_newSha1_Params, error) {
+	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
+	return HashFactory_newSha1_Params{st}, err
+}
+
+func ReadRootHashFactory_newSha1_Params(msg *capnp.Message) (HashFactory_newSha1_Params, error) {
+	root, err := msg.RootPtr()
+	return HashFactory_newSha1_Params{root.Struct()}, err
+}
+
+func (s HashFactory_newSha1_Params) String() string {
+	str, _ := text.Marshal(0x92b20ad1a58ca0ca, s.Struct)
+	return str
+}
+
+// HashFactory_newSha1_Params_List is a list of HashFactory_newSha1_Params.
+type HashFactory_newSha1_Params_List struct{ capnp.List }
+
+// NewHashFactory_newSha1_Params creates a new list of HashFactory_newSha1_Params.
+func NewHashFactory_newSha1_Params_List(s *capnp.Segment, sz int32) (HashFactory_newSha1_Params_List, error) {
+	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
+	return HashFactory_newSha1_Params_List{l}, err
+}
+
+func (s HashFactory_newSha1_Params_List) At(i int) HashFactory_newSha1_Params {
+	return HashFactory_newSha1_Params{s.List.Struct(i)}
+}
+
+func (s HashFactory_newSha1_Params_List) Set(i int, v HashFactory_newSha1_Params) error {
+	return s.List.SetStruct(i, v.Struct)
+}
+
+func (s HashFactory_newSha1_Params_List) String() string {
+	str, _ := text.MarshalList(0x92b20ad1a58ca0ca, s.List)
+	return str
+}
+
+// HashFactory_newSha1_Params_Promise is a wrapper for a HashFactory_newSha1_Params promised by a client call.
+type HashFactory_newSha1_Params_Promise struct{ *capnp.Pipeline }
+
+func (p HashFactory_newSha1_Params_Promise) Struct() (HashFactory_newSha1_Params, error) {
+	s, err := p.Pipeline.Struct()
+	return HashFactory_newSha1_Params{s}, err
+}
+
+type HashFactory_newSha1_Results struct{ capnp.Struct }
+
+// HashFactory_newSha1_Results_TypeID is the unique identifier for the type HashFactory_newSha1_Results.
+const HashFactory_newSha1_Results_TypeID = 0xea3e50f7663f7bdf
+
+func NewHashFactory_newSha1_Results(s *capnp.Segment) (HashFactory_newSha1_Results, error) {
+	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
+	return HashFactory_newSha1_Results{st}, err
+}
+
+func NewRootHashFactory_newSha1_Results(s *capnp.Segment) (HashFactory_newSha1_Results, error) {
+	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
+	return HashFactory_newSha1_Results{st}, err
+}
+
+func ReadRootHashFactory_newSha1_Results(msg *capnp.Message) (HashFactory_newSha1_Results, error) {
+	root, err := msg.RootPtr()
+	return HashFactory_newSha1_Results{root.Struct()}, err
+}
+
+func (s HashFactory_newSha1_Results) String() string {
+	str, _ := text.Marshal(0xea3e50f7663f7bdf, s.Struct)
+	return str
+}
+
+func (s HashFactory_newSha1_Results) Hash() Hash {
+	p, _ := s.Struct.Ptr(0)
+	return Hash{Client: p.Interface().Client()}
+}
+
+func (s HashFactory_newSha1_Results) HasHash() bool {
+	p, err := s.Struct.Ptr(0)
+	return p.IsValid() || err != nil
+}
+
+func (s HashFactory_newSha1_Results) SetHash(v Hash) error {
+	if v.Client == nil {
+		return s.Struct.SetPtr(0, capnp.Ptr{})
+	}
+	seg := s.Segment()
+	in := capnp.NewInterface(seg, seg.Message().AddCap(v.Client))
+	return s.Struct.SetPtr(0, in.ToPtr())
+}
+
+// HashFactory_newSha1_Results_List is a list of HashFactory_newSha1_Results.
+type HashFactory_newSha1_Results_List struct{ capnp.List }
+
+// NewHashFactory_newSha1_Results creates a new list of HashFactory_newSha1_Results.
+func NewHashFactory_newSha1_Results_List(s *capnp.Segment, sz int32) (HashFactory_newSha1_Results_List, error) {
+	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
+	return HashFactory_newSha1_Results_List{l}, err
+}
+
+func (s HashFactory_newSha1_Results_List) At(i int) HashFactory_newSha1_Results {
+	return HashFactory_newSha1_Results{s.List.Struct(i)}
+}
+
+func (s HashFactory_newSha1_Results_List) Set(i int, v HashFactory_newSha1_Results) error {
+	return s.List.SetStruct(i, v.Struct)
+}
+
+func (s HashFactory_newSha1_Results_List) String() string {
+	str, _ := text.MarshalList(0xea3e50f7663f7bdf, s.List)
+	return str
+}
+
+// HashFactory_newSha1_Results_Promise is a wrapper for a HashFactory_newSha1_Results promised by a client call.
+type HashFactory_newSha1_Results_Promise struct{ *capnp.Pipeline }
+
+func (p HashFactory_newSha1_Results_Promise) Struct() (HashFactory_newSha1_Results, error) {
+	s, err := p.Pipeline.Struct()
+	return HashFactory_newSha1_Results{s}, err
+}
+
+func (p HashFactory_newSha1_Results_Promise) Hash() Hash {
+	return Hash{Client: p.Pipeline.GetPipeline(0).Client()}
+}
+
+type Hash struct{ Client capnp.Client }
+
+// Hash_TypeID is the unique identifier for the type Hash.
+const Hash_TypeID = 0xf29f97dd675a9431
+
+func (c Hash) Write(ctx context.Context, params func(Hash_write_Params) error, opts ...capnp.CallOption) Hash_write_Results_Promise {
+	if c.Client == nil {
+		return Hash_write_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
+	}
+	call := &capnp.Call{
+		Ctx: ctx,
+		Method: capnp.Method{
+			InterfaceID:   0xf29f97dd675a9431,
+			MethodID:      0,
+			InterfaceName: "hash.capnp:Hash",
+			MethodName:    "write",
+		},
+		Options: capnp.NewCallOptions(opts),
+	}
+	if params != nil {
+		call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
+		call.ParamsFunc = func(s capnp.Struct) error { return params(Hash_write_Params{Struct: s}) }
+	}
+	return Hash_write_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
+}
+func (c Hash) Sum(ctx context.Context, params func(Hash_sum_Params) error, opts ...capnp.CallOption) Hash_sum_Results_Promise {
+	if c.Client == nil {
+		return Hash_sum_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
+	}
+	call := &capnp.Call{
+		Ctx: ctx,
+		Method: capnp.Method{
+			InterfaceID:   0xf29f97dd675a9431,
+			MethodID:      1,
+			InterfaceName: "hash.capnp:Hash",
+			MethodName:    "sum",
+		},
+		Options: capnp.NewCallOptions(opts),
+	}
+	if params != nil {
+		call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 0}
+		call.ParamsFunc = func(s capnp.Struct) error { return params(Hash_sum_Params{Struct: s}) }
+	}
+	return Hash_sum_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
+}
+
+type Hash_Server interface {
+	Write(Hash_write) error
+
+	Sum(Hash_sum) error
+}
+
+func Hash_ServerToClient(s Hash_Server) Hash {
+	c, _ := s.(server.Closer)
+	return Hash{Client: server.New(Hash_Methods(nil, s), c)}
+}
+
+func Hash_Methods(methods []server.Method, s Hash_Server) []server.Method {
+	if cap(methods) == 0 {
+		methods = make([]server.Method, 0, 2)
+	}
+
+	methods = append(methods, server.Method{
+		Method: capnp.Method{
+			InterfaceID:   0xf29f97dd675a9431,
+			MethodID:      0,
+			InterfaceName: "hash.capnp:Hash",
+			MethodName:    "write",
+		},
+		Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
+			call := Hash_write{c, opts, Hash_write_Params{Struct: p}, Hash_write_Results{Struct: r}}
+			return s.Write(call)
+		},
+		ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 0},
+	})
+
+	methods = append(methods, server.Method{
+		Method: capnp.Method{
+			InterfaceID:   0xf29f97dd675a9431,
+			MethodID:      1,
+			InterfaceName: "hash.capnp:Hash",
+			MethodName:    "sum",
+		},
+		Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
+			call := Hash_sum{c, opts, Hash_sum_Params{Struct: p}, Hash_sum_Results{Struct: r}}
+			return s.Sum(call)
+		},
+		ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
+	})
+
+	return methods
+}
+
+// Hash_write holds the arguments for a server call to Hash.write.
+type Hash_write struct {
+	Ctx     context.Context
+	Options capnp.CallOptions
+	Params  Hash_write_Params
+	Results Hash_write_Results
+}
+
+// Hash_sum holds the arguments for a server call to Hash.sum.
+type Hash_sum struct {
+	Ctx     context.Context
+	Options capnp.CallOptions
+	Params  Hash_sum_Params
+	Results Hash_sum_Results
+}
+
+type Hash_write_Params struct{ capnp.Struct }
+
+// Hash_write_Params_TypeID is the unique identifier for the type Hash_write_Params.
+const Hash_write_Params_TypeID = 0xdffe94ae546cdee3
+
+func NewHash_write_Params(s *capnp.Segment) (Hash_write_Params, error) {
+	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
+	return Hash_write_Params{st}, err
+}
+
+func NewRootHash_write_Params(s *capnp.Segment) (Hash_write_Params, error) {
+	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
+	return Hash_write_Params{st}, err
+}
+
+func ReadRootHash_write_Params(msg *capnp.Message) (Hash_write_Params, error) {
+	root, err := msg.RootPtr()
+	return Hash_write_Params{root.Struct()}, err
+}
+
+func (s Hash_write_Params) String() string {
+	str, _ := text.Marshal(0xdffe94ae546cdee3, s.Struct)
+	return str
+}
+
+func (s Hash_write_Params) Data() ([]byte, error) {
+	p, err := s.Struct.Ptr(0)
+	return []byte(p.Data()), err
+}
+
+func (s Hash_write_Params) HasData() bool {
+	p, err := s.Struct.Ptr(0)
+	return p.IsValid() || err != nil
+}
+
+func (s Hash_write_Params) SetData(v []byte) error {
+	return s.Struct.SetData(0, v)
+}
+
+// Hash_write_Params_List is a list of Hash_write_Params.
+type Hash_write_Params_List struct{ capnp.List }
+
+// NewHash_write_Params creates a new list of Hash_write_Params.
+func NewHash_write_Params_List(s *capnp.Segment, sz int32) (Hash_write_Params_List, error) {
+	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
+	return Hash_write_Params_List{l}, err
+}
+
+func (s Hash_write_Params_List) At(i int) Hash_write_Params {
+	return Hash_write_Params{s.List.Struct(i)}
+}
+
+func (s Hash_write_Params_List) Set(i int, v Hash_write_Params) error {
+	return s.List.SetStruct(i, v.Struct)
+}
+
+func (s Hash_write_Params_List) String() string {
+	str, _ := text.MarshalList(0xdffe94ae546cdee3, s.List)
+	return str
+}
+
+// Hash_write_Params_Promise is a wrapper for a Hash_write_Params promised by a client call.
+type Hash_write_Params_Promise struct{ *capnp.Pipeline }
+
+func (p Hash_write_Params_Promise) Struct() (Hash_write_Params, error) {
+	s, err := p.Pipeline.Struct()
+	return Hash_write_Params{s}, err
+}
+
+type Hash_write_Results struct{ capnp.Struct }
+
+// Hash_write_Results_TypeID is the unique identifier for the type Hash_write_Results.
+const Hash_write_Results_TypeID = 0x80ac741ec7fb8f65
+
+func NewHash_write_Results(s *capnp.Segment) (Hash_write_Results, error) {
+	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
+	return Hash_write_Results{st}, err
+}
+
+func NewRootHash_write_Results(s *capnp.Segment) (Hash_write_Results, error) {
+	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
+	return Hash_write_Results{st}, err
+}
+
+func ReadRootHash_write_Results(msg *capnp.Message) (Hash_write_Results, error) {
+	root, err := msg.RootPtr()
+	return Hash_write_Results{root.Struct()}, err
+}
+
+func (s Hash_write_Results) String() string {
+	str, _ := text.Marshal(0x80ac741ec7fb8f65, s.Struct)
+	return str
+}
+
+// Hash_write_Results_List is a list of Hash_write_Results.
+type Hash_write_Results_List struct{ capnp.List }
+
+// NewHash_write_Results creates a new list of Hash_write_Results.
+func NewHash_write_Results_List(s *capnp.Segment, sz int32) (Hash_write_Results_List, error) {
+	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
+	return Hash_write_Results_List{l}, err
+}
+
+func (s Hash_write_Results_List) At(i int) Hash_write_Results {
+	return Hash_write_Results{s.List.Struct(i)}
+}
+
+func (s Hash_write_Results_List) Set(i int, v Hash_write_Results) error {
+	return s.List.SetStruct(i, v.Struct)
+}
+
+func (s Hash_write_Results_List) String() string {
+	str, _ := text.MarshalList(0x80ac741ec7fb8f65, s.List)
+	return str
+}
+
+// Hash_write_Results_Promise is a wrapper for a Hash_write_Results promised by a client call.
+type Hash_write_Results_Promise struct{ *capnp.Pipeline }
+
+func (p Hash_write_Results_Promise) Struct() (Hash_write_Results, error) {
+	s, err := p.Pipeline.Struct()
+	return Hash_write_Results{s}, err
+}
+
+type Hash_sum_Params struct{ capnp.Struct }
+
+// Hash_sum_Params_TypeID is the unique identifier for the type Hash_sum_Params.
+const Hash_sum_Params_TypeID = 0xe74bb2d0190cf89c
+
+func NewHash_sum_Params(s *capnp.Segment) (Hash_sum_Params, error) {
+	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
+	return Hash_sum_Params{st}, err
+}
+
+func NewRootHash_sum_Params(s *capnp.Segment) (Hash_sum_Params, error) {
+	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
+	return Hash_sum_Params{st}, err
+}
+
+func ReadRootHash_sum_Params(msg *capnp.Message) (Hash_sum_Params, error) {
+	root, err := msg.RootPtr()
+	return Hash_sum_Params{root.Struct()}, err
+}
+
+func (s Hash_sum_Params) String() string {
+	str, _ := text.Marshal(0xe74bb2d0190cf89c, s.Struct)
+	return str
+}
+
+// Hash_sum_Params_List is a list of Hash_sum_Params.
+type Hash_sum_Params_List struct{ capnp.List }
+
+// NewHash_sum_Params creates a new list of Hash_sum_Params.
+func NewHash_sum_Params_List(s *capnp.Segment, sz int32) (Hash_sum_Params_List, error) {
+	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
+	return Hash_sum_Params_List{l}, err
+}
+
+func (s Hash_sum_Params_List) At(i int) Hash_sum_Params { return Hash_sum_Params{s.List.Struct(i)} }
+
+func (s Hash_sum_Params_List) Set(i int, v Hash_sum_Params) error {
+	return s.List.SetStruct(i, v.Struct)
+}
+
+func (s Hash_sum_Params_List) String() string {
+	str, _ := text.MarshalList(0xe74bb2d0190cf89c, s.List)
+	return str
+}
+
+// Hash_sum_Params_Promise is a wrapper for a Hash_sum_Params promised by a client call.
+type Hash_sum_Params_Promise struct{ *capnp.Pipeline }
+
+func (p Hash_sum_Params_Promise) Struct() (Hash_sum_Params, error) {
+	s, err := p.Pipeline.Struct()
+	return Hash_sum_Params{s}, err
+}
+
+type Hash_sum_Results struct{ capnp.Struct }
+
+// Hash_sum_Results_TypeID is the unique identifier for the type Hash_sum_Results.
+const Hash_sum_Results_TypeID = 0xd093963b95a4e107
+
+func NewHash_sum_Results(s *capnp.Segment) (Hash_sum_Results, error) {
+	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
+	return Hash_sum_Results{st}, err
+}
+
+func NewRootHash_sum_Results(s *capnp.Segment) (Hash_sum_Results, error) {
+	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
+	return Hash_sum_Results{st}, err
+}
+
+func ReadRootHash_sum_Results(msg *capnp.Message) (Hash_sum_Results, error) {
+	root, err := msg.RootPtr()
+	return Hash_sum_Results{root.Struct()}, err
+}
+
+func (s Hash_sum_Results) String() string {
+	str, _ := text.Marshal(0xd093963b95a4e107, s.Struct)
+	return str
+}
+
+func (s Hash_sum_Results) Hash() ([]byte, error) {
+	p, err := s.Struct.Ptr(0)
+	return []byte(p.Data()), err
+}
+
+func (s Hash_sum_Results) HasHash() bool {
+	p, err := s.Struct.Ptr(0)
+	return p.IsValid() || err != nil
+}
+
+func (s Hash_sum_Results) SetHash(v []byte) error {
+	return s.Struct.SetData(0, v)
+}
+
+// Hash_sum_Results_List is a list of Hash_sum_Results.
+type Hash_sum_Results_List struct{ capnp.List }
+
+// NewHash_sum_Results creates a new list of Hash_sum_Results.
+func NewHash_sum_Results_List(s *capnp.Segment, sz int32) (Hash_sum_Results_List, error) {
+	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
+	return Hash_sum_Results_List{l}, err
+}
+
+func (s Hash_sum_Results_List) At(i int) Hash_sum_Results { return Hash_sum_Results{s.List.Struct(i)} }
+
+func (s Hash_sum_Results_List) Set(i int, v Hash_sum_Results) error {
+	return s.List.SetStruct(i, v.Struct)
+}
+
+func (s Hash_sum_Results_List) String() string {
+	str, _ := text.MarshalList(0xd093963b95a4e107, s.List)
+	return str
+}
+
+// Hash_sum_Results_Promise is a wrapper for a Hash_sum_Results promised by a client call.
+type Hash_sum_Results_Promise struct{ *capnp.Pipeline }
+
+func (p Hash_sum_Results_Promise) Struct() (Hash_sum_Results, error) {
+	s, err := p.Pipeline.Struct()
+	return Hash_sum_Results{s}, err
+}
+
+const schema_db8274f9144abc7e = "x\xda\x84\x92?h\x13a\x18\xc6\x9f\xe7\xbb;\xaf\xa8" +
+	"G\xfaq\x05\xe9bP\"\x82\xd8\xe2\xb5[\x05\x13\x1c" +
+	"Tt\xb9\x8b\x0e\xe2\xf6QO#$\xb5\xe4.\x14\x11" +
+	"\xff\xd0\xc5E\x10\xb4\xdaE\xd0A7\xed\xd0Q\xba\x8a" +
+	"(\x08u\xb4\x12\x8b:\x08\xdd\xec\xa2\xa5\xd4\x93\xef\x92" +
+	"k\x02!v\xfb\xe0y\xdf\xe7\x9e\xf7w\xcf\xe0fI" +
+	"x\xd6a\x13\x08\x8eY\xbb\x92\xf0\xc1\xe6\xbb\xfd\xf1\xab" +
+	"\xbb\x90\x83\x04L\x1bp7\xb8\x0e3\xf9\xf0\xfc\xfe\xcb" +
+	"O\xbb\x17\x1fB\xeek\x0b\xe3M\x8e\x11f\xb2\xb4\xb2" +
+	"5\x9f\xbb\xf8z\x01r\x8f\x91\xdc^:;\xb4\x11\xcf" +
+	"~\x01\xe8\xbe\xe5\x1b\xf7#\xb5\xc5{\x9ev\x7f\xe9W" +
+	"b\x7f{\xf1\xf8\xf8\x93G\xcb-\x7f+U?\xf3;" +
+	"\xe86Y\x04\x93\x1f_\xab\x17\x16\xe6\xfe\xaev\xeb[" +
+	"\\\x03]\x0a\xad?\xfd\xb3wxy\xf1\xdc\xcf\xae|" +
+	"\x07\xc4\x0a\xccd\xf5f\xf1\xcao\xff\xc4Z+_\xba" +
+	"8n\x89\x09\x82\xae\x93nzs\x97\xae6\xe7\x9f\xad" +
+	"\xf7\xc4\x1c\x11\xb3\xae'\xb4\xd3\x88\xb8\xe7\xde\x126\x8e" +
+	"&\x15\x15UF'\xd5\xb4\x98\x9a\x9e8\xa3\xdf3\xf5" +
+	"kqX(\x87\xf9\xa8Q\x8d\xa3m\xddh\xeb\xa7\xd4" +
+	"d|\xbd~ct*\x9c9_Q^\xc1\xcf\xab\xba" +
+	"\xaau\xe6\x98\xcd\x15[\x83>\x19\x98\x86\x05lse" +
+	"v\x80\x94'!\xa4e\xdfi{\x95\xe8\x93\xbd\x81\xa2" +
+	"F\xadP\x0e\xa3\x86]\x8d\xa3\xc04L\xc0$ \x9d" +
+	"#@0`0\x18\x12\xcc\xe9%:\x10t\xc0~'" +
+	"\xf9*\xa7\x93\xf6\xb3\xb8\xacb\xd5\xdfB\x87\xf0U]" +
+	"\x19\xb5\x9d\x91\x94\x8ba\xca\xee\xbfae\xe77\x81\x94" +
+	"]\xdf\xcc\x08B\xa3\x1bH\xd1e]aVZ\xe9\x8d" +
+	"A\xc8C6;=aV89|\x10B:v>" +
+	"=\xbbD;j\xd4R\xb4\xff\x02\x00\x00\xff\xff<." +
+	"\xe3\xa6"
+
+func init() {
+	schemas.Register(schema_db8274f9144abc7e,
+		0x80ac741ec7fb8f65,
+		0x92b20ad1a58ca0ca,
+		0xaead580f97fddabc,
+		0xd093963b95a4e107,
+		0xdffe94ae546cdee3,
+		0xe74bb2d0190cf89c,
+		0xea3e50f7663f7bdf,
+		0xf29f97dd675a9431)
+}