From ad8f0dd0122515e80a9a2b5eea9e0c6c23c6b34c Mon Sep 17 00:00:00 2001 From: Vishal Rana Date: Fri, 19 Aug 2016 14:07:07 -0700 Subject: [PATCH] Closes #626, #625 Signed-off-by: Vishal Rana --- context.go | 29 +----------- context/context.go | 94 +++++++++++++++++++++++++++++++++++++++ context/context_1.7.go | 13 ++++++ context/context_pre1.7.go | 13 ++++++ 4 files changed, 122 insertions(+), 27 deletions(-) create mode 100644 context/context.go create mode 100644 context/context_1.7.go create mode 100644 context/context_pre1.7.go diff --git a/context.go b/context.go index cf579d96..56275589 100644 --- a/context.go +++ b/context.go @@ -16,39 +16,14 @@ import ( "bytes" - "golang.org/x/net/context" + "github.com/labstack/echo/context" ) type ( // Context represents the context of the current HTTP request. It holds request and // response objects, path, path parameters, data and registered handler. Context interface { - // Context returns `net/context.Context`. - Context() context.Context - - // SetContext sets `net/context.Context`. - SetContext(context.Context) - - // Deadline returns the time when work done on behalf of this context - // should be canceled. Deadline returns ok==false when no deadline is - // set. Successive calls to Deadline return the same results. - Deadline() (deadline time.Time, ok bool) - - // Done returns a channel that's closed when work done on behalf of this - // context should be canceled. Done may return nil if this context can - // never be canceled. Successive calls to Done return the same value. - Done() <-chan struct{} - - // Err returns a non-nil error value after Done is closed. Err returns - // Canceled if the context was canceled or DeadlineExceeded if the - // context's deadline passed. No other values for Err are defined. - // After Done is closed, successive calls to Err return the same value. - Err() error - - // Value returns the value associated with this context for key, or nil - // if no value is associated with key. Successive calls to Value with - // the same key returns the same result. - Value(key interface{}) interface{} + context.Context // Request returns `engine.Request` interface. Request() engine.Request diff --git a/context/context.go b/context/context.go new file mode 100644 index 00000000..92f79659 --- /dev/null +++ b/context/context.go @@ -0,0 +1,94 @@ +package context + +import "time" + +type Context interface { + // Deadline returns the time when work done on behalf of this context + // should be canceled. Deadline returns ok==false when no deadline is + // set. Successive calls to Deadline return the same results. + Deadline() (deadline time.Time, ok bool) + + // Done returns a channel that's closed when work done on behalf of this + // context should be canceled. Done may return nil if this context can + // never be canceled. Successive calls to Done return the same value. + // + // WithCancel arranges for Done to be closed when cancel is called; + // WithDeadline arranges for Done to be closed when the deadline + // expires; WithTimeout arranges for Done to be closed when the timeout + // elapses. + // + // Done is provided for use in select statements: + // + // // Stream generates values with DoSomething and sends them to out + // // until DoSomething returns an error or ctx.Done is closed. + // func Stream(ctx context.Context, out chan<- Value) error { + // for { + // v, err := DoSomething(ctx) + // if err != nil { + // return err + // } + // select { + // case <-ctx.Done(): + // return ctx.Err() + // case out <- v: + // } + // } + // } + // + // See https://blog.golang.org/pipelines for more examples of how to use + // a Done channel for cancelation. + Done() <-chan struct{} + + // Err returns a non-nil error value after Done is closed. Err returns + // Canceled if the context was canceled or DeadlineExceeded if the + // context's deadline passed. No other values for Err are defined. + // After Done is closed, successive calls to Err return the same value. + Err() error + + // Value returns the value associated with this context for key, or nil + // if no value is associated with key. Successive calls to Value with + // the same key returns the same result. + // + // Use context values only for request-scoped data that transits + // processes and API boundaries, not for passing optional parameters to + // functions. + // + // A key identifies a specific value in a Context. Functions that wish + // to store values in Context typically allocate a key in a global + // variable then use that key as the argument to context.WithValue and + // Context.Value. A key can be any type that supports equality; + // packages should define keys as an unexported type to avoid + // collisions. + // + // Packages that define a Context key should provide type-safe accessors + // for the values stored using that key: + // + // // Package user defines a User type that's stored in Contexts. + // package user + // + // import "context" + // + // // User is the type of value stored in the Contexts. + // type User struct {...} + // + // // key is an unexported type for keys defined in this package. + // // This prevents collisions with keys defined in other packages. + // type key int + // + // // userKey is the key for user.User values in Contexts. It is + // // unexported; clients use user.NewContext and user.FromContext + // // instead of using this key directly. + // var userKey key = 0 + // + // // NewContext returns a new Context that carries value u. + // func NewContext(ctx context.Context, u *User) context.Context { + // return context.WithValue(ctx, userKey, u) + // } + // + // // FromContext returns the User value stored in ctx, if any. + // func FromContext(ctx context.Context) (*User, bool) { + // u, ok := ctx.Value(userKey).(*User) + // return u, ok + // } + Value(key interface{}) interface{} +} diff --git a/context/context_1.7.go b/context/context_1.7.go new file mode 100644 index 00000000..800f00ae --- /dev/null +++ b/context/context_1.7.go @@ -0,0 +1,13 @@ +// +build go1.7 + +package context + +import "context" + +func Background() Context { + return context.Background() +} + +func WithValue(parent Context, key, val interface{}) Context { + return context.WithValue(parent, key, val) +} diff --git a/context/context_pre1.7.go b/context/context_pre1.7.go new file mode 100644 index 00000000..195dd3fa --- /dev/null +++ b/context/context_pre1.7.go @@ -0,0 +1,13 @@ +// +build !go1.7 + +package context + +import "golang.org/x/net/context" + +func Background() Context { + return context.Background() +} + +func WithValue(parent Context, key, val interface{}) Context { + return context.WithValue(parent, key, val) +}