Cleaning up more code, system generated by config

master
Frederick F. Kautz IV 10 years ago
parent 2011cffe8a
commit 5878dd5e50
  1. 1
      .gitignore
  2. 9
      Makefile
  3. 36
      gateway.go
  4. 67
      gateway_test.go
  5. 2
      minio/main.go

1
.gitignore vendored

@ -1 +1,2 @@
**/*.swp **/*.swp
/cover/

@ -3,7 +3,8 @@
all: test install all: test install
test: test:
godep go test -race github.com/minios/minios mkdir -p cover
godep go test -race -coverprofile=cover/cover.out github.com/minios/minios
godep go test -race github.com/minios/minios/minio godep go test -race github.com/minios/minios/minio
install: install:
@ -17,3 +18,9 @@ restore:
env: env:
godep go env godep go env
run: all
minio gateway
cover: test
go tool cover -html=cover/cover.out

@ -8,34 +8,39 @@ import (
"net/http" "net/http"
) )
// Stores system configuration, populated from CLI or test runner
type GatewayConfig struct {
StorageDriver StorageDriver
}
// Message for requesting a bucket
type BucketRequest struct { type BucketRequest struct {
name string name string
context Context context Context
callback chan Bucket callback chan Bucket
} }
// Context interface for security and session information
type Context interface{} type Context interface{}
type BucketService interface { // Bucket definition
Serve(chan BucketRequest) Bucket
}
type Bucket interface { type Bucket interface {
GetName(Context) string GetName(Context) string
Get(Context, string) ([]byte, error) Get(Context, string) ([]byte, error)
Put(Context, string, []byte) error Put(Context, string, []byte) error
} }
type fakeContext struct{} // Storage driver function, should read from a channel and respond through callback channels
type StorageDriver func(bucket string, input chan ObjectRequest)
func GatewayHandler(w http.ResponseWriter, req *http.Request) { // TODO remove when building real context
fmt.Fprintf(w, "Gateway") type fakeContext struct{}
}
type GatewayGetHandler struct { type GatewayGetHandler struct {
requestBucketChan chan BucketRequest requestBucketChan chan BucketRequest
} }
// GET requests server
func (handler GatewayGetHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) { func (handler GatewayGetHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
vars := mux.Vars(req) vars := mux.Vars(req)
bucketName := vars["bucket"] bucketName := vars["bucket"]
@ -51,6 +56,8 @@ func (handler GatewayGetHandler) ServeHTTP(w http.ResponseWriter, req *http.Requ
object, err := bucket.Get(context, string(path)) object, err := bucket.Get(context, string(path))
if err != nil { if err != nil {
http.Error(w, err.Error(), 404) http.Error(w, err.Error(), 404)
} else if object == nil {
http.Error(w, errors.New("Object not found").Error(), 404)
} else { } else {
fmt.Fprintf(w, string(object)) fmt.Fprintf(w, string(object))
} }
@ -76,21 +83,21 @@ func (handler GatewayPutHandler) ServeHTTP(w http.ResponseWriter, req *http.Requ
bucket.Put(context, path, object) bucket.Put(context, path, object)
} }
func RegisterGatewayHandlers(router *mux.Router) { func RegisterGatewayHandlers(router *mux.Router, config GatewayConfig) {
requestBucketChan := make(chan BucketRequest) requestBucketChan := make(chan BucketRequest)
go SynchronizedBucketService(requestBucketChan) go SynchronizedBucketService(requestBucketChan, config)
getHandler := GatewayGetHandler{requestBucketChan: requestBucketChan} getHandler := GatewayGetHandler{requestBucketChan: requestBucketChan}
putHandler := GatewayPutHandler{requestBucketChan: requestBucketChan} putHandler := GatewayPutHandler{requestBucketChan: requestBucketChan}
router.Handle("/{bucket}/{path:.*}", getHandler).Methods("GET") router.Handle("/{bucket}/{path:.*}", getHandler).Methods("GET")
router.Handle("/{bucket}/{path:.*}", putHandler).Methods("PUT") router.Handle("/{bucket}/{path:.*}", putHandler).Methods("PUT")
} }
func SynchronizedBucketService(input chan BucketRequest) { func SynchronizedBucketService(input chan BucketRequest, config GatewayConfig) {
buckets := make(map[string]*SynchronizedBucket) buckets := make(map[string]*SynchronizedBucket)
for request := range input { for request := range input {
if buckets[request.name] == nil { if buckets[request.name] == nil {
bucketChannel := make(chan ObjectRequest) bucketChannel := make(chan ObjectRequest)
go inMemoryBucketServer(bucketChannel) go config.StorageDriver(request.name, bucketChannel)
buckets[request.name] = &SynchronizedBucket{ buckets[request.name] = &SynchronizedBucket{
name: request.name, name: request.name,
channel: bucketChannel, channel: bucketChannel,
@ -159,13 +166,16 @@ func (bucket *SynchronizedBucket) closeChannel() {
close(bucket.channel) close(bucket.channel)
} }
func inMemoryBucketServer(input chan ObjectRequest) { func InMemoryStorageDriver(bucket string, input chan ObjectRequest) {
objects := make(map[string][]byte) objects := make(map[string][]byte)
for request := range input { for request := range input {
fmt.Println("objects:", objects)
switch request.requestType { switch request.requestType {
case "GET": case "GET":
fmt.Println("GET: " + request.path)
request.callback <- objects[request.path] request.callback <- objects[request.path]
case "PUT": case "PUT":
fmt.Println("PUT: " + request.path)
objects[request.path] = request.object objects[request.path] = request.object
request.callback <- nil request.callback <- nil
default: default:

@ -1,11 +1,12 @@
package minio package minio
import ( import (
"github.com/gorilla/mux"
. "gopkg.in/check.v1" . "gopkg.in/check.v1"
"io/ioutil" "io/ioutil"
"log"
"net/http" "net/http"
"net/http/httptest" "net/http/httptest"
"strings"
"testing" "testing"
) )
@ -16,21 +17,41 @@ var _ = Suite(&MySuite{})
func Test(t *testing.T) { TestingT(t) } func Test(t *testing.T) { TestingT(t) }
func (s *MySuite) TestPrintsGateway(c *C) { func (s *MySuite) TestPrintsGateway(c *C) {
server := httptest.NewServer(http.HandlerFunc(GatewayHandler)) // set up router with in memory storage driver
router := mux.NewRouter()
config := GatewayConfig{StorageDriver: InMemoryStorageDriver}
RegisterGatewayHandlers(router, config)
server := httptest.NewServer(router)
defer server.Close() defer server.Close()
res, err := http.Get(server.URL)
if err != nil { // GET request, empty
log.Fatal(err) getReq1, _ := http.NewRequest("GET", server.URL+"/one/two/three", nil)
} client := &http.Client{}
body, err := ioutil.ReadAll(res.Body) resp, err := client.Do(getReq1)
res.Body.Close() c.Assert(resp.StatusCode, Equals, 404)
if err != nil { c.Assert(err, IsNil)
log.Fatal(err)
} // assert object not found response
bodyString := string(body) body, _ := ioutil.ReadAll(resp.Body)
if bodyString == "" { c.Assert(string(body), Equals, "Object not found\n")
log.Fatal("Expected '', Received '" + bodyString + "'") c.Assert(err, IsNil)
}
// add new object
putReq, _ := http.NewRequest("PUT", server.URL+"/one/two/three", strings.NewReader("hello"))
resp, err = client.Do(putReq)
c.Assert(resp.StatusCode, Equals, 200)
c.Assert(err, IsNil)
// verify object exists
getReq2, _ := http.NewRequest("GET", server.URL+"/one/two/three", strings.NewReader("hello"))
resp, err = client.Do(getReq2)
c.Assert(resp.StatusCode, Equals, 200)
c.Assert(err, IsNil)
// verify object's contents
body2, _ := ioutil.ReadAll(resp.Body)
c.Assert(string(body2), Equals, "hello")
c.Assert(err, IsNil)
} }
type TestContext struct{} type TestContext struct{}
@ -38,9 +59,10 @@ type TestContext struct{}
func (s *MySuite) TestBucketCreation(c *C) { func (s *MySuite) TestBucketCreation(c *C) {
requestBucketChan := make(chan BucketRequest) requestBucketChan := make(chan BucketRequest)
defer close(requestBucketChan) defer close(requestBucketChan)
go SynchronizedBucketService(requestBucketChan) go SynchronizedBucketService(requestBucketChan, GatewayConfig{StorageDriver: InMemoryStorageDriver})
context := TestContext{} context := TestContext{}
// get new bucket A
var bucketA1 Bucket var bucketA1 Bucket
callback := make(chan Bucket) callback := make(chan Bucket)
requestBucketChan <- BucketRequest{ requestBucketChan <- BucketRequest{
@ -51,6 +73,7 @@ func (s *MySuite) TestBucketCreation(c *C) {
bucketA1 = <-callback bucketA1 = <-callback
c.Assert(bucketA1.GetName(context), Equals, "bucketA") c.Assert(bucketA1.GetName(context), Equals, "bucketA")
// get bucket A again
var bucketA2 Bucket var bucketA2 Bucket
callback = make(chan Bucket) callback = make(chan Bucket)
requestBucketChan <- BucketRequest{ requestBucketChan <- BucketRequest{
@ -60,9 +83,9 @@ func (s *MySuite) TestBucketCreation(c *C) {
} }
bucketA2 = <-callback bucketA2 = <-callback
c.Assert(bucketA2.GetName(context), Equals, "bucketA") c.Assert(bucketA2.GetName(context), Equals, "bucketA")
c.Assert(bucketA1, DeepEquals, bucketA2) c.Assert(bucketA1, DeepEquals, bucketA2)
// get new bucket B
var bucketB Bucket var bucketB Bucket
callback = make(chan Bucket) callback = make(chan Bucket)
requestBucketChan <- BucketRequest{ requestBucketChan <- BucketRequest{
@ -74,29 +97,33 @@ func (s *MySuite) TestBucketCreation(c *C) {
c.Assert(bucketB.GetName(context), Equals, "bucketB") c.Assert(bucketB.GetName(context), Equals, "bucketB")
} }
func (s *MySuite) TestBucketOperations(c *C) { func (s *MySuite) TestInMemoryBucketOperations(c *C) {
// Test in memory bucket operations
requestBucketChan := make(chan BucketRequest) requestBucketChan := make(chan BucketRequest)
defer close(requestBucketChan) defer close(requestBucketChan)
go SynchronizedBucketService(requestBucketChan) go SynchronizedBucketService(requestBucketChan, GatewayConfig{StorageDriver: InMemoryStorageDriver})
context := TestContext{} context := TestContext{}
// get bucket
callback := make(chan Bucket) callback := make(chan Bucket)
requestBucketChan <- BucketRequest{ requestBucketChan <- BucketRequest{
name: "bucket", name: "bucket",
context: context, context: context,
callback: callback, callback: callback,
} }
bucket := <-callback bucket := <-callback
c.Assert(bucket.GetName(context), Equals, "bucket") c.Assert(bucket.GetName(context), Equals, "bucket")
// get missing value
nilResult, err := bucket.Get(context, "foo") nilResult, err := bucket.Get(context, "foo")
c.Assert(nilResult, IsNil) c.Assert(nilResult, IsNil)
c.Assert(err, IsNil) c.Assert(err, IsNil)
// add new value
err = bucket.Put(context, "foo", []byte("bar")) err = bucket.Put(context, "foo", []byte("bar"))
c.Assert(err, IsNil) c.Assert(err, IsNil)
// retrieve value
barResult, err := bucket.Get(context, "foo") barResult, err := bucket.Get(context, "foo")
c.Assert(err, IsNil) c.Assert(err, IsNil)
c.Assert(string(barResult), Equals, "bar") c.Assert(string(barResult), Equals, "bar")

@ -26,7 +26,7 @@ func main() {
Name: "gateway", Name: "gateway",
Usage: "Start a gateway node", Usage: "Start a gateway node",
Action: func(c *cli.Context) { Action: func(c *cli.Context) {
minio.RegisterGatewayHandlers(router) minio.RegisterGatewayHandlers(router, minio.GatewayConfig{StorageDriver: minio.InMemoryStorageDriver})
runServer = true runServer = true
}, },
}, },

Loading…
Cancel
Save