boilerplate codegen first cut

.gitignore

@@ -1,6 +1,9 @@
-addsvc/addsvc
-addsvc/client/addcli/addcli
-cover.out
+examples/addsvc/addsvc
+examples/addsvc/client/addcli/addcli
+examples/stringsvc1/stringsvc1
+examples/stringsvc2/stringsvc2
+examples/stringsvc3/stringsvc3
+gover.coverprofile
 
 # Compiled Object files, Static and Dynamic libs (Shared Objects)
 *.o

.travis.yml

@@ -2,6 +2,6 @@ language: go
 
 go:
     - 1.4.2
+    - 1.5
     - tip
 
-

CONTRIBUTING.md

@@ -18,5 +18,5 @@ Before submitting major changes, here are a few guidelines to follow:
 [issues]: https://github.com/go-kit/kit/issues
 [prs]: https://github.com/go-kit/kit/pulls
 [squash]: http://gitready.com/advanced/2009/02/10/squashing-commits-with-rebase.html
-[message]: https://github.com/go-kit/kit/issues
+[message]: http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html
 

README.md

@@ -1,66 +1,186 @@
-# gokit [![Circle CI](https://circleci.com/gh/go-kit/kit.svg?style=svg)](https://circleci.com/gh/go-kit/kit) [![Drone.io](https://drone.io/github.com/go-kit/kit/status.png)](https://drone.io/github.com/go-kit/kit/latest) [![Travis CI](https://travis-ci.org/go-kit/kit.svg?branch=master)](https://travis-ci.org/go-kit/kit) [![GoDoc](https://godoc.org/github.com/go-kit/kit?status.svg)](https://godoc.org/github.com/go-kit/kit)
+# Go kit [![Circle CI](https://circleci.com/gh/go-kit/kit.svg?style=svg)](https://circleci.com/gh/go-kit/kit) [![Drone.io](https://drone.io/github.com/go-kit/kit/status.png)](https://drone.io/github.com/go-kit/kit/latest) [![Travis CI](https://travis-ci.org/go-kit/kit.svg?branch=master)](https://travis-ci.org/go-kit/kit) [![GoDoc](https://godoc.org/github.com/go-kit/kit?status.svg)](https://godoc.org/github.com/go-kit/kit) [![Coverage Status](https://coveralls.io/repos/go-kit/kit/badge.svg?branch=master&service=github)](https://coveralls.io/github/go-kit/kit?branch=master)
 
-**Go kit** is a **distributed programming toolkit** for microservices in the modern enterprise. We want to make Go a viable choice for application (business-logic) software in large organizations.
+**Go kit** is a **distributed programming toolkit** for building microservices
+in large organizations. We solve common problems in distributed systems, so
+you can focus on your business logic.
 
 - Mailing list: [go-kit](https://groups.google.com/forum/#!forum/go-kit)
 - Slack: [gophers.slack.com](https://gophers.slack.com) **#go-kit** ([invite](http://bit.ly/go-slack-signup))
 
+## Documentation
+
+### Examples
+
+Perhaps the best way to understand Go kit is to follow along as we build an
+[example service][examples] from first principles. This can serve as a
+blueprint for your own new service, or demonstrate how to adapt your existing
+service to use Go kit components.
+
+[examples]: https://github.com/go-kit/kit/tree/master/examples
+
+### Endpoint
+
+Go kit primarily deals in the RPC messaging pattern. We use an abstraction
+called an **[endpoint][]** to model invidivual RPCs. An endpoint can be
+implemented by a server, and called by a client. It's the fundamental building
+block of many Go kit components.
+
+[endpoint]: https://github.com/go-kit/kit/tree/master/endpoint/endpoint.go
+
+#### Circuit breaker
+
+The [circuitbreaker package][circuitbreaker] provides endpoint adapters to
+several popular circuit breaker libraries. Circuit breakers prevent thundering
+herds, and improve resiliency against intermittent errors. Every client-side
+endpoint should be wrapped in a circuit breaker.
+
+[circuitbreaker]: https://github.com/go-kit/kit/tree/master/circuitbreaker
+
+#### Rate limiter
+
+The [ratelimit package][ratelimit] provides endpoint adapters to rate limiting
+packages. Rate limiters are equally applicable to both server- and client-side
+endpoints. Use rate limiters to enforce upper thresholds on incoming or
+outgoing request throughput.
+
+[ratelimit]: https://github.com/go-kit/kit/tree/master/ratelimit
+
+### Transport
+
+The [transport package][transport] provides helpers to bind endpoints to
+specific serialization mechanisms. At the moment, Go kit just provides helpers
+for simple JSON over HTTP. If your organization uses a fully-featured
+transport, bindings are typically provided by the Go library for the
+transport, and there's not much for Go kit to do. In those cases, see the
+examples to understand how to write adapters for your endpoints. For now, see
+the [addsvc][addsvc] to understand how transport bindings work. We'll soon
+have specific examples for Thrift, gRPC, net/rpc, and JSON over HTTP. Avro and
+JSON/RPC support is planned.
+
+[transport]: https://github.com/go-kit/kit/tree/master/transport
+[addsvc]: https://github.com/go-kit/kit/tree/master/examples/addsvc
+
+### Logging
+
+Services produce logs to be consumed later, either by humans or machines.
+Humans might be interested in debugging errors, or tracing specific requests.
+Machines might be interested in counting interesting events, or aggregating
+information for offline processing. In both cases, it's important that the log
+messages be structured and actionable. Go kit's [log package][log] is designed
+to encourage both of these best practices.
+
+[log]: https://github.com/go-kit/kit/tree/master/log
+
+### Metrics (Instrumentation)
+
+Services can't be considered production-ready until they're thoroughly
+instrumented with metrics that track counts, latency, health, and other
+periodic or per-request information. Go kit's [metrics package][metrics]
+provides a robust common set of interfaces for instrumenting your service.
+Bindings exist for common backends, from [expvar][] to [statsd][] to
+[Prometheus][].
+
+[metrics]: https://github.com/go-kit/kit/tree/master/metrics
+[expvar]: http://golang.org/pkg/expvar
+[statsd]: https://github.com/etsy/statsd
+[Prometheus]: http://prometheus.io
+
+### Request tracing
+
+As your infrastructure grows, it becomes important to be able to trace a
+request, as it travels through multiple services and back to the user. Go
+kit's [tracing package][tracing] provides enhancements for your endpoints and
+transport bindings  to capture information about requests and emit them to
+request tracing systems. (Currently, [Zipkin][] is supported; [Appdash][]
+support is planned.)
+
+[tracing]: https://github.com/go-kit/kit/tree/master/tracing
+[Zipkin]: https://github.com/twitter/zipkin
+[Appdash]: https://github.com/sourcegraph/appdash
+
+### Service discovery and load balancing
+
+If your service calls another service, it needs to know how to find it, and
+should intelligently spread its load among those discovered instances. Go
+kit's [loadbalancer package][loadbalancer] provides client-side endpoint
+middleware to solve that problem, whether your organization uses static hosts
+or IPs, [DNS SRV records][dnssrv], Consul, etcd, or Zookeeper. And if you use
+a custom system, it's very easy to write your own [Publisher][] and use Go
+kit's load balancing strategies. (Currently, static hosts and DNS SRV are
+supported; Consul, etcd, and Zookeeper support is planned.)
+
+[loadbalancer]: https://github.com/go-kit/kit/tree/master/loadbalancer
+[dnssrv]: https://github.com/go-kit/kit/tree/master/loadbalancer/dnssrv
+[Publisher]: https://github.com/go-kit/kit/tree/master/loadbalancer/publisher.go
+
 ## Motivation
 
-See [the motivating blog post](http://peter.bourgon.org/go-kit) and [the video of the talk](https://www.youtube.com/watch?v=iFR_7AKkJFU).
+Go has emerged as the language of the server, but it remains underrepresented
+in large, consumer-focused tech companies like Facebook, Twitter, Netflix, and
+SoundCloud. These organizations have largely adopted JVM-based stacks for
+their business logic, owing in large part to libraries and ecosystems that
+directly support their microservice architectures.
+
+To reach its next level of success, Go needs more than simple primitives and
+idioms. It needs a comprehensive toolkit, for coherent distributed programming
+in the large. Go kit is a set of packages and best practices, leveraging years
+of production experience, and providing a comprehensive, robust, and trustable
+platform for organizations of any size.
+
+In short, Go kit brings Go to the modern enterprise.
+
+For more details, see
+ [the motivating blog post](http://peter.bourgon.org/go-kit) and
+ [the video of the talk](https://www.youtube.com/watch?v=iFR_7AKkJFU).
+See also the
+ [Go kit talk at GopherCon 2015](https://www.youtube.com/watch?v=1AjaZi4QuGo).
 
 ## Goals
 
 - Operate in a heterogeneous SOA — expect to interact with mostly non-Go-kit services
 - RPC as the primary messaging pattern
 - Pluggable serialization and transport — not just JSON over HTTP
-- Zipkin-compatible request tracing
+- Operate within existing infrastructures — no mandates for specific tools or technologies
 
 ## Non-goals
 
-- Supporting messaging patterns other than RPC (in the initial release) — pub/sub, CQRS, etc.
+- Supporting messaging patterns other than RPC (in the initial release) — MPI, pub/sub, CQRS, etc.
+- Re-implementing functionality that can be provided by wrapping existing packages
 - Having opinions on deployment, orchestration, process supervision, etc.
 - Having opinions on configuration passing — flags, env vars, files, etc.
 
-## Component status
-
-- [API stability](https://github.com/go-kit/kit/blob/master/rfc/rfc007-api-stability.md) — **adopted**
-- [`package log`](https://github.com/go-kit/kit/tree/master/log) — **implemented**
-- [`package metrics`](https://github.com/go-kit/kit/tree/master/metrics) — **implemented**
-- [`package endpoint`](https://github.com/go-kit/kit/tree/master/endpoint) — **implemented**
-- [`package transport`](https://github.com/go-kit/kit/tree/master/transport) — **implemented**
-- [`package circuitbreaker`](https://github.com/go-kit/kit/tree/master/circuitbreaker) — **implemented**
-- [`package loadbalancer`](https://github.com/go-kit/kit/tree/master/loadbalancer) — **implemented**
-- [`package ratelimit`](https://github.com/go-kit/kit/tree/master/ratelimit) — **implemented**
-- [`package tracing`](https://github.com/go-kit/kit/tree/master/tracing) — prototyping
-- Client patterns — prototyping
-- Service discovery — pending
-- Example [addsvc](https://github.com/go-kit/kit/tree/master/addsvc) — **implemented**
-
 ## Contributing
 
 Please see [CONTRIBUTING.md]. Thank you, [contributors]!
 
 [CONTRIBUTING.md]: /CONTRIBUTING.md
 [contributors]: https://github.com/go-kit/kit/graphs/contributors
 
-### Dependency management
+## Dependency management
+
+Go kit is a library, designed to be imported into a binary package. Vendoring
+is currently the best way for binary package authors to ensure reliable,
+reproducible builds.  Therefore, we strongly recommend our users use vendoring
+for all of their dependencies, including Go kit.   To avoid compatibility and
+availability issues, Go kit doesn't vendor its own dependencies, and doesn't
+recommend use of third-party import proxies.
 
-Users who import Go kit into their `package main` are responsible to organize
-and maintain all of their dependencies to ensure code compatibility and build
-reproducibility. Gokit makes no direct use of dependency management tools like
-[Godep](https://github.com/tools/godep).
+There are several tools which make vendoring easier, including [gb][],
+[govendor][], and [Godep][]. And Go kit uses a variety of continuous
+integration providers to find and fix compatibility problems as soon as they
+occur.
 
-We will use a variety of continuous integration providers to find and fix
-compatibility problems as soon as they occur.
+[gb]: http://getgb.io
+[govendor]: https://github.com/kardianos/govendor
+[Godep]: https://github.com/tools/godep
 
-### API stability policy
+## API stability policy
 
 The Go kit project depends on code maintained by others.
 This includes the Go standard library and sub-repositories and other external libraries.
 The Go language and standard library provide stability guarantees, but the other external libraries typically do not.
- [The API Stability RFC](https://github.com/go-kit/kit/tree/master/rfc/rfc007-api-stability.md)
-proposes a standard policy for package authors to advertise API stability.
+[The API Stability RFC](https://github.com/go-kit/kit/tree/master/rfc/rfc007-api-stability.md)
+ proposes a standard policy for package authors to advertise API stability.
 The Go kit project prefers to depend on code that abides the API stability policy.
 
 ## Related projects
@@ -83,7 +203,7 @@ Projects with a ★ have had particular influence on Go kit's design.
 - [FogCreek/logging](https://github.com/FogCreek/logging), a tagged style of logging
 - [grpc/grpc-go](https://github.com/grpc/grpc-go), HTTP/2 based RPC
 - [inconshreveable/log15](https://github.com/inconshreveable/log15), simple, powerful logging for Go ★
-- [mailgun/vulcand](https://github.com/mailgun/vulcand), prorammatic load balancer backed by etcd
+- [mailgun/vulcand](https://github.com/mailgun/vulcand), programmatic load balancer backed by etcd
 - [mattheath/phosphor](https://github.com/mattheath/phosphor), distributed system tracing
 - [pivotal-golang/lager](https://github.com/pivotal-golang/lager), an opinionated logging library
 - [rubyist/circuitbreaker](https://github.com/rubyist/circuitbreaker), circuit breaker library

addsvc/README.md → addsvc2/README.md

@@ -1,18 +1,21 @@
-# addsvc
+# addsvc2
 
-addsvc is an example service, used to illustrate the mechanics of gokit.
+addsvc2 is an example service, used to illustrate the mechanics of gokit.
 It exposes simple functionality on a variety of transports and endpoints.
 
 ## Server
 
-To build and run addsvc,
+To build and run addsvc2,
 
 ```
 $ go install
-$ addsvc
+$ addsvc2
 ```
 
 ## Client
+TODO: make it work with codegenrator.
+
+Everything below is not working.
 
 addsvc comes with an example client, [addcli][].
 

addsvc2/add/add.go

@@ -0,0 +1,9 @@
+package add
+
+import "golang.org/x/net/context"
+
+//go:generate gokit-gen -package github.com/sasha-s/kit/addsvc2/add -type Adder -w -binding=rpc,http
+
+type Adder interface {
+	Add(ctx context.Context, a int64, b int64) (v int64)
+}

addsvc2/add/adder_add_http_binding.go

@@ -0,0 +1,34 @@
+// Do not edit! Generated by gokit-generate
+package add
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"golang.org/x/net/context"
+
+	"github.com/go-kit/kit/endpoint"
+	httptransport "github.com/go-kit/kit/transport/http"
+)
+
+func MakeAdderAddHTTPBinding(ctx context.Context, e endpoint.Endpoint, before []httptransport.RequestFunc, after []httptransport.ResponseFunc) http.Handler {
+	decode := func(r *http.Request) (interface{}, error) {
+		defer r.Body.Close()
+		var request AdderAddRequest
+		if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
+			return nil, err
+		}
+		return request, nil
+	}
+	encode := func(w http.ResponseWriter, response interface{}) error {
+		return json.NewEncoder(w).Encode(response)
+	}
+	return httptransport.Server{
+		Context:		ctx,
+		Endpoint:		e,
+		DecodeRequestFunc:	decode,
+		EncodeResponseFunc:	encode,
+		Before:			before,
+		After:			append([]httptransport.ResponseFunc{httptransport.SetContentType("application/json; charset=utf-8")}, after...),
+	}
+}

addsvc2/add/adder_add_http_client.go

@@ -0,0 +1,61 @@
+// Do not edit! Generated by gokit-generate
+package add
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+
+	"golang.org/x/net/context"
+
+	"github.com/go-kit/kit/endpoint"
+	httptransport "github.com/go-kit/kit/transport/http"
+)
+
+// NewClient takes a URL that should point to an instance of an addsvc. It
+// returns an endpoint that makes a request to that URL.
+func NewAdderAddHTTPClient(method, url string, before ...httptransport.RequestFunc) endpoint.Endpoint {
+	return func(ctx0 context.Context, request interface{}) (interface{}, error) {
+		var (
+			ctx, cancel	= context.WithCancel(ctx0)
+			errs		= make(chan error, 1)
+			responses	= make(chan interface{}, 1)
+		)
+		defer cancel()
+		go func() {
+			var buf bytes.Buffer
+			if err := json.NewEncoder(&buf).Encode(request); err != nil {
+				errs <- err
+				return
+			}
+			req, err := http.NewRequest(method, url, &buf)
+			if err != nil {
+				errs <- err
+				return
+			}
+			for _, f := range before {
+				ctx = f(ctx, req)
+			}
+			resp, err := http.DefaultClient.Do(req)
+			if err != nil {
+				errs <- err
+				return
+			}
+			defer resp.Body.Close()
+			var response AdderAddResponse
+			if err := json.NewDecoder(resp.Body).Decode(&response); err != nil {
+				errs <- err
+				return
+			}
+			responses <- response
+		}()
+		select {
+		case <-ctx.Done():
+			return nil, context.DeadlineExceeded
+		case err := <-errs:
+			return nil, err
+		case response := <-responses:
+			return response, nil
+		}
+	}
+}