// setupHandlerChain does plumbing for logging and such.
func setupHandlerChain(c *xhandler.Chain) {
host, _ := os.Hostname()
conf := xlog.Config{
// Log info level and higher
Level: xlog.LevelInfo,
// Set some global env fields
Fields: xlog.F{
"role": "my-shitty-service",
"host": host,
},
// Output everything on console
Output: xlog.NewOutputChannel(xlog.NewConsoleOutput()),
}
// Add close notifier handler so context is cancelled when the client closes
// the connection
c.UseC(xhandler.CloseHandler)
// Install the logger handler
c.UseC(xlog.NewHandler(conf))
// Add timeout handler (HAHA)
//c.UseC(xhandler.TimeoutHandler(2 * time.Second))
// Install some provided extra handler to set some request's context fields.
// Thanks to those handler, all our logs will come with some pre-populated fields.
c.UseC(xlog.MethodHandler("method"))
c.UseC(xlog.URLHandler("url"))
c.UseC(xlog.RemoteAddrHandler("ip"))
c.UseC(xlog.UserAgentHandler("user_agent"))
c.UseC(xlog.RefererHandler("referer"))
c.UseC(xlog.RequestIDHandler("req_id", "Request-Id"))
}
func main() {
// Create a REST API resource index
index := resource.NewIndex()
// Add a resource on /users[/:user_id]
users := index.Bind("users", user, mem.NewHandler(), resource.Conf{
// We allow all REST methods
// (rest.ReadWrite is a shortcut for []resource.Mode{resource.Create, resource.Read, resource.Update, resource.Delete, resource,List})
AllowedModes: resource.ReadWrite,
})
// Bind a sub resource on /users/:user_id/posts[/:post_id]
// and reference the user on each post using the "user" field of the posts resource.
posts := users.Bind("posts", "user", post, mem.NewHandler(), resource.Conf{
// Posts can only be read, created and deleted, not updated
AllowedModes: []resource.Mode{resource.Read, resource.List, resource.Create, resource.Delete},
})
// Add a friendly alias to public posts
// (equivalent to /users/:user_id/posts?filter={"published":true})
posts.Alias("public", url.Values{"filter": []string{"{\"published\":true}"}})
// Create API HTTP handler for the resource graph
api, err := rest.NewHandler(index)
if err != nil {
log.Fatalf("Invalid API configuration: %s", err)
}
c := alice.New()
// Add close notifier handler so context is cancelled when the client closes
// the connection
// c.Append(xhandler.CloseHandler)
// Add timeout handler
// c.Append(xhandler.TimeoutHandler(2 * time.Second))
// Install a logger (see https://github.com/rs/xlog)
c = c.Append(xlog.NewHandler(xlog.Config{}))
resource.LoggerLevel = resource.LogLevelDebug
resource.Logger = func(ctx context.Context, level resource.LogLevel, msg string, fields map[string]interface{}) {
xlog.FromContext(ctx).OutputF(xlog.Level(level), 2, msg, fields)
}
// Log API access
c = c.Append(xaccess.NewHandler())
// Add CORS support with passthrough option on so rest-layer can still
// handle OPTIONS method
c = c.Append(cors.New(cors.Options{OptionsPassthrough: true}).Handler)
// Bind the API under /api/ path
http.Handle("/api/", http.StripPrefix("/api/", c.Then(api)))
// Serve it
log.Print("Serving API on http://localhost:8080")
if err := http.ListenAndServe(":8080", nil); err != nil {
log.Fatal(err)
}
}
func Example_combinedOutputs() {
conf := xlog.Config{
Output: xlog.NewOutputChannel(xlog.MultiOutput{
// Output interesting messages to console
0: xlog.FilterOutput{
Cond: func(fields map[string]interface{}) bool {
val, found := fields["type"]
return found && val == "interesting"
},
Output: xlog.NewConsoleOutput(),
},
// Also setup by-level loggers
1: xlog.LevelOutput{
// Send debug messages to console if they match type
Debug: xlog.FilterOutput{
Cond: func(fields map[string]interface{}) bool {
val, found := fields["type"]
return found && val == "interesting"
},
Output: xlog.NewConsoleOutput(),
},
},
// Also send everything over syslog
2: xlog.NewSyslogOutput("", "", ""),
}),
}
lh := xlog.NewHandler(conf)
_ = lh
}
func ExampleMultiOutput() {
conf := xlog.Config{
Output: xlog.NewOutputChannel(xlog.MultiOutput{
// Output everything to console
0: xlog.NewConsoleOutput(),
// and also to local syslog
1: xlog.NewSyslogOutput("", "", ""),
}),
}
lh := xlog.NewHandler(conf)
_ = lh
}
func ExampleNewSyslogWriter() {
conf := xlog.Config{
Output: xlog.NewOutputChannel(xlog.LevelOutput{
Debug: xlog.NewLogstashOutput(xlog.NewSyslogWriter("", "", syslog.LOG_LOCAL0|syslog.LOG_DEBUG, "")),
Info: xlog.NewLogstashOutput(xlog.NewSyslogWriter("", "", syslog.LOG_LOCAL0|syslog.LOG_INFO, "")),
Warn: xlog.NewLogstashOutput(xlog.NewSyslogWriter("", "", syslog.LOG_LOCAL0|syslog.LOG_WARNING, "")),
Error: xlog.NewLogstashOutput(xlog.NewSyslogWriter("", "", syslog.LOG_LOCAL0|syslog.LOG_ERR, "")),
}),
}
lh := xlog.NewHandler(conf)
_ = lh
}
func Example_handler() {
c := alice.New()
host, _ := os.Hostname()
conf := xlog.Config{
// Set some global env fields
Fields: xlog.F{
"role": "my-service",
"host": host,
},
}
// Install the logger handler with default output on the console
c.Append(xlog.NewHandler(conf))
// Plug the xlog handler's input to Go's default logger
log.SetFlags(0)
log.SetOutput(xlog.New(conf))
// Install some provided extra handler to set some request's context fields.
// Thanks to those handler, all our logs will come with some pre-populated fields.
c.Append(xlog.RemoteAddrHandler("ip"))
c.Append(xlog.UserAgentHandler("user_agent"))
c.Append(xlog.RefererHandler("referer"))
c.Append(xlog.RequestIDHandler("req_id", "Request-Id"))
// Here is your final handler
h := c.Then(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Get the logger from the request's context. You can safely assume it
// will be always there: if the handler is removed, xlog.FromContext
// will return a NopLogger
l := xlog.FromRequest(r)
// Then log some errors
if err := errors.New("some error from elsewhere"); err != nil {
l.Errorf("Here is an error: %v", err)
}
// Or some info with fields
l.Info("Something happend", xlog.F{
"user": "******",
"status": "ok",
})
}))
http.Handle("/", h)
if err := http.ListenAndServe(":8080", nil); err != nil {
log.SetOutput(os.Stderr) // make sure we print to console
log.Fatal(err)
}
}
func ExampleLevelOutput() {
conf := xlog.Config{
Output: xlog.NewOutputChannel(xlog.LevelOutput{
// Send debug message to console
Debug: xlog.NewConsoleOutput(),
// and error messages to syslog
Error: xlog.NewSyslogOutput("", "", ""),
// other levels are discarded
}),
}
lh := xlog.NewHandler(conf)
_ = lh
}
func ExampleFilterOutput() {
conf := xlog.Config{
Output: xlog.NewOutputChannel(xlog.FilterOutput{
// Match messages containing a field type = interesting
Cond: func(fields map[string]interface{}) bool {
val, found := fields["type"]
return found && val == "interesting"
},
// Output matching messages to the console
Output: xlog.NewConsoleOutput(),
}),
}
lh := xlog.NewHandler(conf)
_ = lh
}
func init() {
// read config data
cfg.initDefaultConfig()
uno = initUnoconv()
//plug the xlog handler's input to Go's default logger
log.SetFlags(0)
xlogger := xlog.New(cfg.loggerConfig)
log.SetOutput(xlogger)
//register some middleware handlers
mw.initCommonHandlers(
xlog.NewHandler(cfg.loggerConfig),
xaccess.NewHandler(),
)
}
func TestNewHandler(t *testing.T) {
h := NewHandler()(xhandler.HandlerFuncC(func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusAccepted)
w.Write([]byte{'1', '2', '3'})
}))
o := &recorderOutput{}
l := xlog.NewHandler(xlog.Config{
Output: o,
})
r, _ := http.NewRequest("GET", "/path", nil)
w := httptest.NewRecorder()
l(h).ServeHTTPC(context.Background(), w, r)
runtime.Gosched()
for i := 0; len(o.last) == 0 && i < 100; i++ {
time.Sleep(10 * time.Millisecond)
}
if assert.NotNil(t, o.last) {
assert.Equal(t, 3, o.last["size"])
assert.Equal(t, "info", o.last["level"])
assert.Equal(t, "access", o.last["type"])
assert.Equal(t, "GET", o.last["method"])
assert.Equal(t, "ok", o.last["status"])
assert.Equal(t, 202, o.last["status_code"])
assert.Equal(t, "GET /path 202", o.last["message"])
assert.NotEmpty(t, o.last["duration"])
assert.NotEmpty(t, o.last["time"])
}
xx := string(bytes.Repeat([]byte{'x'}, 150))
r, _ = http.NewRequest("GET", "/"+xx, nil)
w = httptest.NewRecorder()
l(h).ServeHTTPC(context.Background(), w, r)
runtime.Gosched()
for i := 0; len(o.last) == 0 && i < 100; i++ {
time.Sleep(10 * time.Millisecond)
}
if assert.NotNil(t, o.last) {
assert.Equal(t, "GET /"+xx[:48]+"..."+xx[:49]+" 202", o.last["message"])
}
}
func main() {
index := resource.NewIndex()
users := index.Bind("users", user, mem.NewHandler(), resource.Conf{
AllowedModes: resource.ReadWrite,
})
users.Alias("admin", url.Values{"filter": []string{`{"admin": true}`}})
posts := index.Bind("posts", post, mem.NewHandler(), resource.Conf{
AllowedModes: resource.ReadWrite,
})
posts.Bind("followers", "post", postFollower, mem.NewHandler(), resource.Conf{
AllowedModes: resource.ReadWrite,
})
// Create API HTTP handler for the resource graph
api, err := rest.NewHandler(index)
if err != nil {
log.Fatalf("Invalid API configuration: %s", err)
}
// Setup logger
c := alice.New()
c = c.Append(xlog.NewHandler(xlog.Config{}))
c = c.Append(xaccess.NewHandler())
c = c.Append(xlog.RequestHandler("req"))
c = c.Append(xlog.RemoteAddrHandler("ip"))
c = c.Append(xlog.UserAgentHandler("ua"))
c = c.Append(xlog.RefererHandler("ref"))
c = c.Append(xlog.RequestIDHandler("req_id", "Request-Id"))
resource.LoggerLevel = resource.LogLevelDebug
resource.Logger = func(ctx context.Context, level resource.LogLevel, msg string, fields map[string]interface{}) {
xlog.FromContext(ctx).OutputF(xlog.Level(level), 2, msg, fields)
}
// Bind the API under /api/ path
http.Handle("/api/", http.StripPrefix("/api/", c.Then(api)))
// Create and bind the graphql endpoint
graphql, err := graphql.NewHandler(index)
if err != nil {
log.Fatal(err)
}
http.Handle("/graphql", c.Then(graphql))
http.HandleFunc("/graphiql", func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`
<!DOCTYPE html>
<html>
<head>
<style>
html, body {height: 100%; margin: 0; overflow: hidden; width: 100%;}
</style>
<link href="//cdn.jsdelivr.net/graphiql/0.4.9/graphiql.css" rel="stylesheet" />
<script src="//cdn.jsdelivr.net/fetch/0.9.0/fetch.min.js"></script>
<script src="//cdn.jsdelivr.net/react/0.14.7/react.min.js"></script>
<script src="//cdn.jsdelivr.net/react/0.14.7/react-dom.min.js"></script>
<script src="//cdn.jsdelivr.net/graphiql/0.4.9/graphiql.min.js"></script>
</head>
<body>
<script>
// Collect the URL parameters
var parameters = {};
window.location.search.substr(1).split('&').forEach(function (entry) {
var eq = entry.indexOf('=');
if (eq >= 0) {
parameters[decodeURIComponent(entry.slice(0, eq))] =
decodeURIComponent(entry.slice(eq + 1));
}
});
// Produce a Location query string from a parameter object.
function locationQuery(params) {
return '/graphql?' + Object.keys(params).map(function (key) {
return encodeURIComponent(key) + '=' +
encodeURIComponent(params[key]);
}).join('&');
}
// Derive a fetch URL from the current URL, sans the GraphQL parameters.
var graphqlParamNames = {
query: true,
variables: true,
operationName: true
};
var otherParams = {};
for (var k in parameters) {
if (parameters.hasOwnProperty(k) && graphqlParamNames[k] !== true) {
otherParams[k] = parameters[k];
}
}
var fetchURL = locationQuery(otherParams);
// Defines a GraphQL fetcher using the fetch API.
function graphQLFetcher(graphQLParams) {
return fetch(fetchURL, {
method: 'post',
headers: {
'Accept': 'application/json',
'Content-Type': 'application/json'
},
body: JSON.stringify(graphQLParams),
credentials: 'include',
}).then(function (response) {
return response.text();
}).then(function (responseBody) {
try {
return JSON.parse(responseBody);
} catch (error) {
return responseBody;
}
});
}
// When the query and variables string is edited, update the URL bar so
// that it can be easily shared.
function onEditQuery(newQuery) {
parameters.query = newQuery;
updateURL();
}
function onEditVariables(newVariables) {
parameters.variables = newVariables;
updateURL();
}
function updateURL() {
history.replaceState(null, null, locationQuery(parameters));
}
// Render <GraphiQL /> into the body.
React.render(
React.createElement(GraphiQL, {
fetcher: graphQLFetcher,
onEditQuery: onEditQuery,
onEditVariables: onEditVariables,
defaultQuery: "{\
postsList{\
i: id,\
m: meta{\
t: title,\
b: body},\
thumb_small_url: thumbnail_url(height:80)\
}\
}",
}),
document.body
);
</script>
</body>
</html>`))
})
// Inject some fixtures
fixtures := [][]string{
{"PUT", "/users/johndoe", `{"name": "John Doe", "ip": "1.2.3.4", "password": "******", "admin": true}`},
{"PUT", "/users/fan1", `{"name": "Fan 1", "ip": "1.2.3.4", "password": "******"}}`},
{"PUT", "/users/fan2", `{"name": "Fan 2", "ip": "1.2.3.4", "password": "******"}}`},
{"PUT", "/users/fan3", `{"name": "Fan 3", "ip": "1.2.3.4", "password": "******"}}`},
{"PUT", "/users/fan4", `{"name": "Fan 4", "ip": "1.2.3.4", "password": "******"}}`},
{"PUT", "/posts/ar5qrgukj5l7a6eq2ps0",
`{
"user": "******",
"thumbnail_url": "http://dom.com/image.png",
"meta": {
"title": "First Post",
"body": "This is my first post"
}
}`},
{"POST", "/posts/ar5qrgukj5l7a6eq2ps0/followers", `{"user": "******"}`},
{"POST", "/posts/ar5qrgukj5l7a6eq2ps0/followers", `{"user": "******"}`},
{"POST", "/posts/ar5qrgukj5l7a6eq2ps0/followers", `{"user": "******"}`},
}
for _, fixture := range fixtures {
req, err := http.NewRequest(fixture[0], fixture[1], strings.NewReader(fixture[2]))
if err != nil {
log.Fatal(err)
}
w := httptest.NewRecorder()
api.ServeHTTP(w, req)
if w.Code >= 400 {
log.Fatalf("Error returned for `%s %s`: %v", fixture[0], fixture[1], w)
}
}
// Serve it
log.Print("Serving API on http://localhost:8080")
log.Print("Visit http://localhost:8080/graphiql for a GraphiQL UI")
log.Println("Play with (httpie):\n",
"- http :8080/graphql query=='{postsList{id,thumb_s_url:thumbnail_url(height:80)}}'\n",
"- http :8080/graphql query=='{postsList{i:id,m:meta{t:title, b:body},thumb_small_url:thumbnail_url(height:80)}}'\n",
"- http :8080/graphql query=='{postsList{id,meta{title},user{id,name}}}'\n",
"- http :8080/graphql query=='{posts(id:\"ar5qrgukj5l7a6eq2ps0\"){followers{post{id,meta{title}},user{id,name}}}}'\n",
"- http :8080/graphql query=='{posts(id:\"ar5qrgukj5l7a6eq2ps0\"){id,meta{title},followers(limit:2){user{id,name}}}}'")
if err := http.ListenAndServe(":8080", nil); err != nil {
log.Fatal(err)
}
}
func main() {
flag.Parse()
// Create a REST API resource index
index := resource.NewIndex()
// Bind user on /users
users := index.Bind("users", user, mem.NewHandler(), resource.Conf{
AllowedModes: resource.ReadWrite,
})
// Init the db with some users (user registration is not handled by this example)
secret, _ := schema.Password{}.Validate("secret")
users.Insert(context.Background(), []*resource.Item{
{ID: "admin", Updated: time.Now(), ETag: "abcd", Payload: map[string]interface{}{
"id": "jack",
"name": "Jack Sparrow",
"password": secret,
}},
{ID: "john", Updated: time.Now(), ETag: "efgh", Payload: map[string]interface{}{
"id": "john",
"name": "John Doe",
"password": secret,
}},
})
// Bind post on /posts
posts := index.Bind("posts", post, mem.NewHandler(), resource.Conf{
AllowedModes: resource.ReadWrite,
})
// Protect resources
users.Use(AuthResourceHook{UserField: "id"})
posts.Use(AuthResourceHook{UserField: "user"})
// Create API HTTP handler for the resource graph
api, err := rest.NewHandler(index)
if err != nil {
log.Fatalf("Invalid API configuration: %s", err)
}
// Setup logger
c := alice.New()
c = c.Append(xlog.NewHandler(xlog.Config{}))
c = c.Append(xaccess.NewHandler())
c = c.Append(xlog.RequestHandler("req"))
c = c.Append(xlog.RemoteAddrHandler("ip"))
c = c.Append(xlog.UserAgentHandler("ua"))
c = c.Append(xlog.RefererHandler("ref"))
c = c.Append(xlog.RequestIDHandler("req_id", "Request-Id"))
resource.LoggerLevel = resource.LogLevelDebug
resource.Logger = func(ctx context.Context, level resource.LogLevel, msg string, fields map[string]interface{}) {
xlog.FromContext(ctx).OutputF(xlog.Level(level), 2, msg, fields)
}
// Setup auth middleware
jwtSecretBytes := []byte(*jwtSecret)
c = c.Append(NewJWTHandler(users, func(t *jwt.Token) (interface{}, error) {
println("paf")
if t.Method != jwt.SigningMethodHS256 {
return nil, jwt.ErrInvalidKey
}
return jwtSecretBytes, nil
}))
// Bind the API under /
http.Handle("/", c.Then(api))
// Demo tokens
jackToken := jwt.New(jwt.SigningMethodHS256)
jackClaims := jackToken.Claims.(jwt.MapClaims)
jackClaims["user_id"] = "jack"
jackTokenString, err := jackToken.SignedString(jwtSecretBytes)
if err != nil {
log.Fatal(err)
}
johnToken := jwt.New(jwt.SigningMethodHS256)
johnClaims := johnToken.Claims.(jwt.MapClaims)
johnClaims["user_id"] = "john"
johnTokenString, err := johnToken.SignedString(jwtSecretBytes)
if err != nil {
log.Fatal(err)
}
// Serve it
log.Print("Serving API on http://localhost:8080")
log.Printf("Your token secret is %q, change it with the `-jwt-secret' flag", *jwtSecret)
log.Print("Play with tokens:\n",
"\n",
"- http :8080/posts access_token==", johnTokenString, " title=\"John's post\"\n",
"- http :8080/posts access_token==", johnTokenString, "\n",
"- http :8080/posts\n",
"\n",
"- http :8080/posts access_token==", jackTokenString, " title=\"Jack's post\"\n",
"- http :8080/posts access_token==", jackTokenString, "\n",
)
if err := http.ListenAndServe(":8080", nil); err != nil {
log.Fatal(err)
}
}
func main() {
index := resource.NewIndex()
index.Bind("posts", post, restrix.Wrap("posts", mem.NewHandler()), resource.Conf{
AllowedModes: resource.ReadWrite,
})
// Create API HTTP handler for the resource graph
api, err := rest.NewHandler(index)
if err != nil {
log.Fatalf("Invalid API configuration: %s", err)
}
// Setup logger
c := alice.New()
c = c.Append(xlog.NewHandler(xlog.Config{}))
c = c.Append(xaccess.NewHandler())
resource.LoggerLevel = resource.LogLevelDebug
resource.Logger = func(ctx context.Context, level resource.LogLevel, msg string, fields map[string]interface{}) {
xlog.FromContext(ctx).OutputF(xlog.Level(level), 2, msg, fields)
}
// Bind the API under the root path
http.Handle("/", c.Then(api))
// Configure hystrix commands
hystrix.Configure(map[string]hystrix.CommandConfig{
"posts.MultiGet": {
Timeout: 500,
MaxConcurrentRequests: 200,
ErrorPercentThreshold: 25,
},
"posts.Find": {
Timeout: 1000,
MaxConcurrentRequests: 100,
ErrorPercentThreshold: 25,
},
"posts.Insert": {
Timeout: 1000,
MaxConcurrentRequests: 50,
ErrorPercentThreshold: 25,
},
"posts.Update": {
Timeout: 1000,
MaxConcurrentRequests: 50,
ErrorPercentThreshold: 25,
},
"posts.Delete": {
Timeout: 1000,
MaxConcurrentRequests: 10,
ErrorPercentThreshold: 10,
},
"posts.Clear": {
Timeout: 10000,
MaxConcurrentRequests: 5,
ErrorPercentThreshold: 10,
},
})
// Start the metrics stream handler
hystrixStreamHandler := hystrix.NewStreamHandler()
hystrixStreamHandler.Start()
log.Print("Serving Hystrix metrics on http://localhost:8081")
go http.ListenAndServe(net.JoinHostPort("", "8081"), hystrixStreamHandler)
// Inject some fixtures
fixtures := [][]string{
{"POST", "/posts", `{"title": "First Post", "body": "This is my first post"}`},
{"POST", "/posts", `{"title": "Second Post", "body": "This is my second post"}`},
{"POST", "/posts", `{"title": "Third Post", "body": "This is my third post"}`},
}
for _, fixture := range fixtures {
req, err := http.NewRequest(fixture[0], fixture[1], strings.NewReader(fixture[2]))
if err != nil {
log.Fatal(err)
}
w := httptest.NewRecorder()
api.ServeHTTP(w, req)
if w.Code >= 400 {
log.Fatalf("Error returned for `%s %s`: %v", fixture[0], fixture[1], w)
}
}
// Serve it
log.Print("Serving API on http://localhost:8080")
if err := http.ListenAndServe(":8080", nil); err != nil {
log.Fatal(err)
}
}
func main() {
index := resource.NewIndex()
index.Bind("users", user, mem.NewHandler(), resource.Conf{
AllowedModes: resource.ReadWrite,
})
posts := index.Bind("posts", post, mem.NewHandler(), resource.Conf{
AllowedModes: resource.ReadWrite,
})
posts.Bind("followers", "post", postFollower, mem.NewHandler(), resource.Conf{
AllowedModes: resource.ReadWrite,
})
// Create API HTTP handler for the resource graph
api, err := rest.NewHandler(index)
if err != nil {
log.Fatalf("Invalid API configuration: %s", err)
}
// Setup logger
c := alice.New()
c = c.Append(xlog.NewHandler(xlog.Config{}))
c = c.Append(xaccess.NewHandler())
resource.LoggerLevel = resource.LogLevelDebug
resource.Logger = func(ctx context.Context, level resource.LogLevel, msg string, fields map[string]interface{}) {
xlog.FromContext(ctx).OutputF(xlog.Level(level), 2, msg, fields)
}
// Bind the API under the root path
http.Handle("/", c.Then(api))
// Inject some fixtures
fixtures := [][]string{
{"PUT", "/users/johndoe", `{"name": "John Doe", "ip": "1.2.3.4", "password": "******"}`},
{"PUT", "/users/fan1", `{"name": "Fan 1", "ip": "1.2.3.4", "password": "******"}}`},
{"PUT", "/users/fan2", `{"name": "Fan 2", "ip": "1.2.3.4", "password": "******"}}`},
{"PUT", "/users/fan3", `{"name": "Fan 3", "ip": "1.2.3.4", "password": "******"}}`},
{"PUT", "/users/fan4", `{"name": "Fan 4", "ip": "1.2.3.4", "password": "******"}}`},
{"PUT", "/posts/ar5qrgukj5l7a6eq2ps0",
`{
"user": "******",
"thumbnail_url": "http://dom.com/image.png",
"meta": {
"title": "First Post",
"body": "This is my first post"
}
}`},
{"POST", "/posts/ar5qrgukj5l7a6eq2ps0/followers", `{"user": "******"}`},
{"POST", "/posts/ar5qrgukj5l7a6eq2ps0/followers", `{"user": "******"}`},
{"POST", "/posts/ar5qrgukj5l7a6eq2ps0/followers", `{"user": "******"}`},
}
for _, fixture := range fixtures {
req, err := http.NewRequest(fixture[0], fixture[1], strings.NewReader(fixture[2]))
if err != nil {
log.Fatal(err)
}
w := httptest.NewRecorder()
api.ServeHTTP(w, req)
if w.Code >= 400 {
log.Fatalf("Error returned for `%s %s`: %v", fixture[0], fixture[1], w)
}
}
// Serve it
log.Print("Serving API on http://localhost:8080")
log.Println("Play with (httpie):\n",
"- http :8080/posts fields=='id,thumb_s_url:thumbnail_url(height:80)'\n",
"- http :8080/posts fields=='i:id,m:meta{t:title,b:body},thumb_small_url:thumbnail_url(height:80)'\n",
"- http :8080/posts fields=='id,meta,user{id,name}'\n",
"- http :8080/posts/ar5qrgukj5l7a6eq2ps0/followers fields=='post{id,meta{title}},user{id,name}'\n",
"- http :8080/posts/ar5qrgukj5l7a6eq2ps0 fields=='id,meta{title},followers(limit:2){user{id,name}}'")
if err := http.ListenAndServe(":8080", nil); err != nil {
log.Fatal(err)
}
}
func Example() {
var (
// Define a user resource schema
user = schema.Schema{
Fields: schema.Fields{
"id": {
Required: true,
// When a field is read-only, on default values or hooks can
// set their value. The client can't change it.
ReadOnly: true,
// This is a field hook called when a new user is created.
// The schema.NewID hook is a provided hook to generate a
// unique id when no value is provided.
OnInit: schema.NewID,
// The Filterable and Sortable allows usage of filter and sort
// on this field in requests.
Filterable: true,
Sortable: true,
Validator: &schema.String{
Regexp: "^[0-9a-f]{32}$",
},
},
"created": {
Required: true,
ReadOnly: true,
Filterable: true,
Sortable: true,
OnInit: schema.Now,
Validator: &schema.Time{},
},
"updated": {
Required: true,
ReadOnly: true,
Filterable: true,
Sortable: true,
OnInit: schema.Now,
// The OnUpdate hook is called when the item is edited. Here we use
// provided Now hook which just return the current time.
OnUpdate: schema.Now,
Validator: &schema.Time{},
},
// Define a name field as required with a string validator
"name": {
Required: true,
Filterable: true,
Validator: &schema.String{
MaxLen: 150,
},
},
},
}
// Define a post resource schema
post = schema.Schema{
Fields: schema.Fields{
// schema.*Field are shortcuts for common fields (identical to users' same fields)
"id": schema.IDField,
"created": schema.CreatedField,
"updated": schema.UpdatedField,
// Define a user field which references the user owning the post.
// See bellow, the content of this field is enforced by the fact
// that posts is a sub-resource of users.
"user": {
Required: true,
Filterable: true,
Validator: &schema.Reference{
Path: "users",
},
},
"public": {
Filterable: true,
Validator: &schema.Bool{},
},
// Sub-documents are handled via a sub-schema
"meta": {
Schema: &schema.Schema{
Fields: schema.Fields{
"title": {
Required: true,
Validator: &schema.String{
MaxLen: 150,
},
},
"body": {
Validator: &schema.String{
MaxLen: 100000,
},
},
},
},
},
},
}
)
// Create a REST API root resource
index := resource.NewIndex()
// Add a resource on /users[/:user_id]
users := index.Bind("users", user, mem.NewHandler(), resource.Conf{
// We allow all REST methods
// (rest.ReadWrite is a shortcut for []rest.Mode{Create, Read, Update, Delete, List})
AllowedModes: resource.ReadWrite,
})
// Bind a sub resource on /users/:user_id/posts[/:post_id]
// and reference the user on each post using the "user" field of the posts resource.
posts := users.Bind("posts", "user", post, mem.NewHandler(), resource.Conf{
// Posts can only be read, created and deleted, not updated
AllowedModes: []resource.Mode{resource.Read, resource.List, resource.Create, resource.Delete},
})
// Add a friendly alias to public posts
// (equivalent to /users/:user_id/posts?filter={"public":true})
posts.Alias("public", url.Values{"filter": []string{"{\"public\"=true}"}})
// Create API HTTP handler for the resource graph
api, err := rest.NewHandler(index)
if err != nil {
log.Fatalf("Invalid API configuration: %s", err)
}
// Init an alice handler chain (use your preferred one)
c := alice.New()
// Add close notifier handler so context is cancelled when the client closes
// the connection
//c.Append(xhandler.CloseHandler)
// Add timeout handler
//c.Append(xhandler.TimeoutHandler(2 * time.Second))
// Install a logger (see https://github.com/rs/xlog)
c = c.Append(xlog.NewHandler(xlog.Config{}))
resource.LoggerLevel = resource.LogLevelDebug
resource.Logger = func(ctx context.Context, level resource.LogLevel, msg string, fields map[string]interface{}) {
xlog.FromContext(ctx).OutputF(xlog.Level(level), 2, msg, fields)
}
// Log API access
c = c.Append(xaccess.NewHandler())
// Add CORS support with passthrough option on so rest-layer can still
// handle OPTIONS method
c = c.Append(cors.New(cors.Options{OptionsPassthrough: true}).Handler)
// Bind the API under /api/ path
http.Handle("/api/", http.StripPrefix("/api/", c.Then(api)))
// Serve it
log.Print("Serving API on http://localhost:8080")
if err := http.ListenAndServe(":8080", nil); err != nil {
log.Fatal(err)
}
}
func main() {
// Create a REST API resource index
index := resource.NewIndex()
// Bind user on /users
users := index.Bind("users", user, mem.NewHandler(), resource.Conf{
AllowedModes: resource.ReadWrite,
})
// Init the db with some users (user registration is not handled by this example)
secret, _ := schema.Password{}.Validate("secret")
users.Insert(context.Background(), []*resource.Item{
{ID: "admin", Updated: time.Now(), ETag: "abcd", Payload: map[string]interface{}{
"id": "admin",
"name": "Dilbert",
"password": secret,
}},
{ID: "john", Updated: time.Now(), ETag: "efgh", Payload: map[string]interface{}{
"id": "john",
"name": "John Doe",
"password": secret,
}},
})
// Bind post on /posts
posts := index.Bind("posts", post, mem.NewHandler(), resource.Conf{
AllowedModes: resource.ReadWrite,
})
// Protect resources
users.Use(AuthResourceHook{UserField: "id"})
posts.Use(AuthResourceHook{UserField: "user"})
// Create API HTTP handler for the resource graph
api, err := rest.NewHandler(index)
if err != nil {
log.Fatalf("Invalid API configuration: %s", err)
}
// Setup logger
c := alice.New()
c = c.Append(xlog.NewHandler(xlog.Config{}))
c = c.Append(xaccess.NewHandler())
c = c.Append(xlog.RequestHandler("req"))
c = c.Append(xlog.RemoteAddrHandler("ip"))
c = c.Append(xlog.UserAgentHandler("ua"))
c = c.Append(xlog.RefererHandler("ref"))
c = c.Append(xlog.RequestIDHandler("req_id", "Request-Id"))
resource.LoggerLevel = resource.LogLevelDebug
resource.Logger = func(ctx context.Context, level resource.LogLevel, msg string, fields map[string]interface{}) {
xlog.FromContext(ctx).OutputF(xlog.Level(level), 2, msg, fields)
}
// Setup auth middleware
c = c.Append(NewBasicAuthHandler(users))
// Bind the API under /
http.Handle("/", c.Then(api))
// Serve it
log.Print("Serving API on http://localhost:8080")
if err := http.ListenAndServe(":8080", nil); err != nil {
log.Fatal(err)
}
}