Exemple #1
0
func main() {
	// s := rpcv2.NewServer()
	s := rpc
	s.RegisterCodec(json2.NewCodec(), "application/json")
	s.RegisterCodec(json2.NewCodec(), "application/json;charset=UTF-8")
	arith := new(arith.Arith)
	utility := new(utility.Utility)
	s.RegisterService(arith, "")
	s.RegisterService(utility, "")
	r := mux.NewRouter()
	r.Handle("/rpc", s)
	http.ListenAndServe(":1234", r)
}
Exemple #2
0
// Initialize mock JSONRPC server for NQM log
// You may use "test.mockrpc.port" to customize port of HTTP for it
func StartMockJsonRpcServer(c *C, jsonrpcServiceSetupFunc func(*rpc.Server)) {
	if testHttpServer != nil {
		return
	}

	flag.Parse()

	jsonrpcService := rpc.NewServer()
	jsonrpcService.RegisterCodec(json2.NewCodec(), "application/json")
	jsonrpcServiceSetupFunc(jsonrpcService)

	/**
	 * Set-up HTTP server for testing
	 */
	testHttpServer = httptest.NewUnstartedServer(jsonrpcService)
	listener, err := net.Listen("tcp", "127.0.0.1:"+*mockRpcPort)
	if err != nil {
		panic(err)
	}
	testHttpServer.Listener = listener
	testHttpServer.Start()
	// :~)

	rpcServiceCaller = jsonrpc.NewService(testHttpServer.URL)

	c.Logf("Test HTTP Server: \"%v\"", testHttpServer.URL)
}
Exemple #3
0
// registerWebRouter - registers web router for serving minio browser.
func registerWebRouter(mux *router.Router, web *webAPIHandlers) {
	// Initialize a new json2 codec.
	codec := json2.NewCodec()

	// Minio browser router.
	webBrowserRouter := mux.NewRoute().PathPrefix(reservedBucket).Subrouter()

	// Initialize json rpc handlers.
	webRPC := jsonrpc.NewServer()
	webRPC.RegisterCodec(codec, "application/json")
	webRPC.RegisterCodec(codec, "application/json; charset=UTF-8")
	webRPC.RegisterService(web, "Web")

	// RPC handler at URI - /minio/webrpc
	webBrowserRouter.Methods("POST").Path("/webrpc").Handler(webRPC)
	webBrowserRouter.Methods("PUT").Path("/upload/{bucket}/{object:.+}").HandlerFunc(web.Upload)
	webBrowserRouter.Methods("GET").Path("/download/{bucket}/{object:.+}").Queries("token", "{token:.*}").HandlerFunc(web.Download)

	// Add compression for assets.
	compressedAssets := handlers.CompressHandler(http.StripPrefix(reservedBucket, http.FileServer(assetFS())))

	// Serve javascript files and favicon from assets.
	webBrowserRouter.Path(fmt.Sprintf("/{assets:[^/]+.js|%s}", specialAssets)).Handler(compressedAssets)

	// Serve index.html for rest of the requests.
	webBrowserRouter.Path("/{index:.*}").Handler(indexHandler{http.StripPrefix(reservedBucket, http.FileServer(assetFS()))})
}
func init() {
	s := rpc.NewServer()
	s.RegisterCodec(json2.NewCodec(), "application/json")
	s.RegisterService(new(HelloService), "")
	http.Handle("/", s)
	go http.ListenAndServe("127.0.0.1:9097", nil)
}
Exemple #5
0
func getWebAPIHandler(web *WebAPI) http.Handler {
	var handlerFns = []HandlerFunc{
		setCacheControlHandler, // Adds Cache-Control header
		setTimeValidityHandler, // Validate time.
		setJWTAuthHandler,      // Authentication handler for verifying JWT's.
		setCorsHandler,         // CORS added only for testing purposes.
	}
	if web.AccessLog {
		handlerFns = append(handlerFns, setAccessLogHandler)
	}

	s := jsonrpc.NewServer()
	codec := json2.NewCodec()
	s.RegisterCodec(codec, "application/json")
	s.RegisterCodec(codec, "application/json; charset=UTF-8")
	s.RegisterService(web, "Web")
	mux := router.NewRouter()
	// Root router.
	root := mux.NewRoute().PathPrefix("/").Subrouter()
	root.Handle("/rpc", s)

	// Enable this when we add assets.
	root.PathPrefix("/login").Handler(http.StripPrefix("/login", http.FileServer(assetFS())))
	root.Handle("/{file:.*}", http.FileServer(assetFS()))
	return registerHandlers(mux, handlerFns...)
}
Exemple #6
0
func (server *JsonDriverServer) StartServer() error {
	s := rpc.NewServer()
	s.RegisterCodec(json2.NewCodec(), "application/json-rpc")
	s.RegisterService(new(PinProtocol), "")
	s.RegisterService(new(FinProtocol), "")
	s.RegisterService(new(PingjiaProtocol), "")
	s.RegisterService(new(MsfProtocol), "")
	s.RegisterService(new(IcProtocol), "")
	s.RegisterService(new(IdcProtocol), "")
	s.RegisterService(new(DebugProtocol), "")
	s.RegisterService(new(ConfigProtocol), "")
	s.RegisterService(new(Pr2Protocol), "")
	http.Handle("/rpc", s)
	p := strconv.Itoa(server.Port)
	var err error
	//具有多个ip

	err = http.ListenAndServe("0.0.0.0:"+p, nil)
	utils.Info("json rpc server start listening ip 0.0.0.0 port %s", p)
	if err != nil {
		utils.Error("start listening ip 0.0.0.0 error:%s", err.Error())
	}

	return nil
}
Exemple #7
0
func init() {
	log.Println("table8_restaurant_api.init() ... starting")
	rpc_v2 := rpc.NewServer()
	rpc_v2.RegisterCodec(json2.NewCodec(), "application/json")
	app.Register(rpc_v2)

	log.Println("table8_restaurant_api.init() ... ready")
	http.Handle("/restaurant/0.1/", rpc_v2)
}
Exemple #8
0
func Serve(port string, handlers []RpcHandler) {
	r := mux.NewRouter()
	for _, handler := range handlers {
		s := rpc.NewServer()
		s.RegisterCodec(json2.NewCodec(), "application/json")
		s.RegisterService(handler.Service, "")
		r.Handle(handler.Path, s)
	}

	endless.DefaultHammerTime = -1
	endless.ListenAndServe(":"+port, r)
}
Exemple #9
0
func init() {
	Server = rpc.NewServer()
	Server.RegisterCodec(json2.NewCodec(), "application/json-rpc")
	http.Handle(HTTPEndpoint, Server)
}