httpacess first implement: register device.

pkg/server/config.go

@@ -32,5 +32,5 @@ var (
 
 	confEtcd = flag.String(FlagEtcd, "", "etcd service addr, format ip:port;ip:port")
 
-	confLogLevel = flag.String(FlagLogLevel, "warn", "default log level, options are panic|fatal|error|warn|info|debug")
+	confLogLevel = flag.String(FlagLogLevel, "info", "default log level, options are panic|fatal|error|warn|info|debug")
 )

pkg/server/rpc_client.go

@@ -66,12 +66,12 @@ func (client *RPCClient) Call(severName string, serverMethod string, args interf
 
 		err = rpcCallWithReconnect(client.clients[mapkey], addr, serverMethod, args, reply)
 		if err != nil {
-			Log.Warn("RpcCallWithReconnect error : %s", err)
+			Log.Warnf("RpcCallWithReconnect error : %s", err)
 			continue
 		}
 
 		return nil
 	}
 
-	return errorf("rpc all failed")
+	return errorf(err.Error())
 }

services/httpaccess/actions.go

@@ -0,0 +1,62 @@
+package main
+
+import (
+	"github.com/PandoCloud/pando-cloud/pkg/models"
+	"github.com/PandoCloud/pando-cloud/pkg/rpcs"
+	"github.com/PandoCloud/pando-cloud/pkg/server"
+	"github.com/martini-contrib/render"
+	"net/http"
+)
+
+const (
+	ErrOK          = 0
+	ErrSystemFault = 10001
+)
+
+func renderError(code int, err error) Common {
+	result := Common{}
+	result.Code = code
+	result.Message = err.Error()
+	server.Log.Error(err.Error())
+	return result
+}
+
+// device register args
+type DeviceRegisterArgs struct {
+	ProductKey string `json:"product_key"  binding:"required"`
+	DeviceCode string `json:"device_code"  binding:"required"`
+	Version    string `json:"version"  binding:"required"`
+}
+
+// device authentication args
+type DeviceAuthArgs struct {
+	DeviceId     int64  `json:"device_id" binding:"required"`
+	DeviceSecret string `json:"device_secret" binding:"required"`
+	Protocol     string `json:"protocol" binding:"required"`
+}
+
+func RegisterDevice(args DeviceRegisterArgs, r render.Render) {
+	server.Log.Printf("ACTION RegisterDevice, args:: %v ", args)
+	rpcargs := &rpcs.DeviceRegisterArgs{
+		ProductKey:    args.ProductKey,
+		DeviceCode:    args.DeviceCode,
+		DeviceVersion: args.Version,
+	}
+	device := &models.Device{}
+	err := server.RPCCallByName("registry", "Registry.RegisterDevice", rpcargs, device)
+	if err != nil {
+		r.JSON(http.StatusOK, renderError(ErrSystemFault, err))
+		return
+	}
+	server.Log.Infof("register device success: %v", device)
+
+	result := DeviceRegisterResponse{}
+	result.Data = DeviceRegisterData{
+		DeviceId:         device.ID,
+		DeviceSecret:     device.DeviceSecret,
+		DeviceKey:        device.DeviceKey,
+		DeviceIdentifier: device.DeviceIdentifier,
+	}
+	r.JSON(http.StatusOK, result)
+	return
+}

services/httpaccess/main.go

@@ -0,0 +1,36 @@
+package main
+
+import (
+	"github.com/PandoCloud/pando-cloud/pkg/server"
+	"github.com/go-martini/martini"
+	"github.com/martini-contrib/render"
+	//"net/http"
+)
+
+func main() {
+	// init server
+	err := server.Init("httpaccess")
+	if err != nil {
+		server.Log.Fatal(err)
+		return
+	}
+
+	// martini setup
+	martini.Env = martini.Prod
+	handler := martini.Classic()
+	handler.Use(render.Renderer())
+	route(handler)
+
+	// register a http handler
+	err = server.RegisterHTTPHandler(handler)
+	if err != nil {
+		server.Log.Errorf("RegisterHTTPHandler Error: %s", err)
+		return
+	}
+
+	// go
+	err = server.Run()
+	if err != nil {
+		server.Log.Fatal(err)
+	}
+}

services/httpaccess/response.go

@@ -0,0 +1,35 @@
+package main
+
+// common response fields
+type Common struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+}
+
+// device register response data field
+type DeviceRegisterData struct {
+	DeviceId         int64  `json:"device_id"`
+	DeviceSecret     string `json:"device_secret"`
+	DeviceKey        string `json:"device_key"`
+	DeviceIdentifier string `json:"device_identifier"`
+}
+
+// device register response
+type DeviceRegisterResponse struct {
+	Common
+	Data DeviceRegisterData `json:"data"`
+}
+
+// device auth response data field
+type DeviceAuthData struct {
+	AccessToken   string `json:"access_token"`
+	AccessAddr    string `json:"access_addr"`
+	EventSequence uint64 `json:"event_sequence"`
+	DataSequence  uint64 `json:"data_sequence"`
+}
+
+// device auth response
+type DeviceAuthResponse struct {
+	Common
+	Data DeviceAuthData `json:"data"`
+}

services/httpaccess/router.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"github.com/go-martini/martini"
+	"github.com/martini-contrib/binding"
+)
+
+// martini router
+func route(m *martini.ClassicMartini) {
+	// regist a device
+	m.Post("/v1/devices/registration", binding.Json(DeviceRegisterArgs{}), RegisterDevice)
+
+	// auth device
+	// m.Post("v1/devices/authentication", binding.Json(DeviceAuthArgs{}), actions.AuthDevice)
+
+}

services/registry/main.go

@@ -1,9 +1,39 @@
 package main
 
 import (
-//"github.com/PandoCloud/pando-cloud/pkg/server"
+	"github.com/PandoCloud/pando-cloud/pkg/mysql"
+	"github.com/PandoCloud/pando-cloud/pkg/server"
 )
 
 func main() {
+	// init server
+	err := server.Init("registry")
+	if err != nil {
+		server.Log.Fatal(err)
+		return
+	}
 
+	err = mysql.MigrateDatabase(*confDBHost, *confDBPort, *confDBName, *confDBUser, *confDBPass)
+	if err != nil {
+		server.Log.Fatal(err)
+		return
+	}
+
+	// register a rpc service
+	r, err := NewRegistry()
+	if err != nil {
+		server.Log.Fatal(err)
+		return
+	}
+	err = server.RegisterRPCHandler(r)
+	if err != nil {
+		server.Log.Errorf("Register RPC service Error: %s", err)
+		return
+	}
+
+	// start to run
+	err = server.Run()
+	if err != nil {
+		server.Log.Fatal(err)
+	}
 }

services/registry/registry_test.go

@@ -86,7 +86,10 @@ func testDevice(t *testing.T, r *Registry) {
 }
 
 func TestRegistry(t *testing.T) {
-	mysql.MigrateDatabase(defaultDBHost, defaultDBPort, defaultDBName, defaultDBUser, "")
+	err := mysql.MigrateDatabase(defaultDBHost, defaultDBPort, defaultDBName, defaultDBUser, "")
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	*confAESKey = "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"