Golang codec.Codec類代碼示例

// create a new miner api instance
func NewMinerApi(expanse *exp.Expanse, coder codec.Codec) *minerApi {
	return &minerApi{
		expanse: expanse,
		methods: MinerMapping,
		codec:   coder.New(nil),
	}
}

// create a new web3 api instance
func NewWeb3Api(xeth *xeth.XEth, coder codec.Codec) *web3Api {
	return &web3Api{
		xeth:    xeth,
		methods: Web3Mapping,
		codec:   coder.New(nil),
	}
}

// Create a new in process client
func NewHttpClient(cfg HttpConfig, c codec.Codec) *httpClient {
	return &httpClient{
		address: cfg.ListenAddress,
		port:    cfg.ListenPort,
		codec:   c.New(nil),
	}
}

// create a new txpool api instance
func NewTxPoolApi(xeth *xeth.XEth, exp *exp.Expanse, coder codec.Codec) *txPoolApi {
	return &txPoolApi{
		xeth:    xeth,
		expanse: exp,
		methods: txpoolMapping,
		codec:   coder.New(nil),
	}
}

// create a new net api instance
func NewPersonalApi(xeth *xeth.XEth, exp *exp.Expanse, coder codec.Codec) *personalApi {
	return &personalApi{
		xeth:    xeth,
		expanse: exp,
		methods: personalMapping,
		codec:   coder.New(nil),
	}
}

// create a new db api instance
func NewDbApi(xeth *xeth.XEth, expanse *exp.Expanse, coder codec.Codec) *dbApi {
	return &dbApi{
		xeth:    xeth,
		expanse: expanse,
		methods: DbMapping,
		codec:   coder.New(nil),
	}
}

// create a new whisper api instance
func NewShhApi(xeth *xeth.XEth, exp *exp.Expanse, coder codec.Codec) *shhApi {
	return &shhApi{
		xeth:    xeth,
		expanse: exp,
		methods: shhMapping,
		codec:   coder.New(nil),
	}
}

// create a new net api instance
func NewNetApi(xeth *xeth.XEth, exp *exp.Expanse, coder codec.Codec) *netApi {
	return &netApi{
		xeth:    xeth,
		expanse: exp,
		methods: netMapping,
		codec:   coder.New(nil),
	}
}

func handle(id int, conn net.Conn, api shared.ExpanseApi, c codec.Codec) {
	codec := c.New(conn)

	defer func() {
		if r := recover(); r != nil {
			glog.Errorf("panic: %v\n", r)
		}
		codec.Close()
	}()

	for {
		requests, isBatch, err := codec.ReadRequest()
		if err == io.EOF {
			return
		} else if err != nil {
			glog.V(logger.Debug).Infof("Closed IPC Conn %06d recv err - %v\n", id, err)
			return
		}

		if isBatch {
			responses := make([]*interface{}, len(requests))
			responseCount := 0
			for _, req := range requests {
				res, err := api.Execute(req)
				if req.Id != nil {
					rpcResponse := shared.NewRpcResponse(req.Id, req.Jsonrpc, res, err)
					responses[responseCount] = rpcResponse
					responseCount += 1
				}
			}

			err = codec.WriteResponse(responses[:responseCount])
			if err != nil {
				glog.V(logger.Debug).Infof("Closed IPC Conn %06d send err - %v\n", id, err)
				return
			}
		} else {
			var rpcResponse interface{}
			res, err := api.Execute(requests[0])

			rpcResponse = shared.NewRpcResponse(requests[0].Id, requests[0].Jsonrpc, res, err)
			err = codec.WriteResponse(rpcResponse)
			if err != nil {
				glog.V(logger.Debug).Infof("Closed IPC Conn %06d send err - %v\n", id, err)
				return
			}
		}
	}
}

// create a new admin api instance
func NewAdminApi(xeth *xeth.XEth, expanse *exp.Expanse, codec codec.Codec) *adminApi {
	return &adminApi{
		xeth:    xeth,
		expanse: expanse,
		codec:   codec,
		coder:   codec.New(nil),
	}
}

func newIpcClient(cfg IpcConfig, codec codec.Codec) (*ipcClient, error) {
	c, err := net.DialUnix("unix", nil, &net.UnixAddr{cfg.Endpoint, "unix"})
	if err != nil {
		return nil, err
	}

	coder := codec.New(c)
	msg := shared.Request{
		Id:      0,
		Method:  useragent.EnableUserAgentMethod,
		Jsonrpc: shared.JsonRpcVersion,
		Params:  []byte("[]"),
	}

	coder.WriteResponse(msg)
	coder.Recv()

	return &ipcClient{cfg.Endpoint, c, codec, coder}, nil
}

// create new ethApi instance
func NewEthApi(xeth *xeth.XEth, exp *exp.Expanse, codec codec.Codec) *ethApi {
	return &ethApi{xeth, exp, ethMapping, codec.New(nil)}
}