roc

README

Channel driven multiplexing connection

How to install

go get github.com/hyperf/roc

How to use

roc-skeleton

• action/foo_save_action.go

package action

import (
	"encoding/json"
	"fmt"
	"github.com/hyperf/roc"
	"github.com/hyperf/roc/exception"
	"github.com/hyperf/roc/formatter"
	"github.com/hyperf/roc/serializer"
)

type FooSaveAction struct {
}

type FooSaveInput struct {
	Name   string `json:"name"`
	Gender int    `json:"gender"`
}
type FooSaveRequest struct {
	ID    int
	Input FooSaveInput
}

func (m *FooSaveRequest) UnmarshalJSON(bytes []byte) error {
	var raw []json.RawMessage
	if err := json.Unmarshal(bytes, &raw); err != nil {
		return err
	}

	if err := json.Unmarshal(raw[0], &m.ID); err != nil {
		return err
	}

	if err := json.Unmarshal(raw[1], &m.Input); err != nil {
		return err
	}

	return nil
}

type FooSaveResult struct {
	IsSuccess bool `json:"is_success"`
}

func (f *FooSaveAction) getRequest(packet *roc.Packet, serializer serializer.SerializerInterface) (*FooSaveRequest, exception.ExceptionInterface) {
	req := &formatter.JsonRPCRequest[*FooSaveRequest, any]{}

	if err := serializer.UnSerialize(packet.GetBody(), req); err != nil {
		return nil, exception.NewDefaultException(err.Error())
	}

	return req.Data, nil
}

func (f *FooSaveAction) Handle(packet *roc.Packet, serializer serializer.SerializerInterface) (any, exception.ExceptionInterface) {
	request, e := f.getRequest(packet, serializer)
	if e != nil {
		return nil, e
	}

	fmt.Println(request.ID, request.Input.Name)

	return &FooSaveResult{IsSuccess: true}, nil
}

• main.go

package main

import (
	"github.com/hyperf/roc"
	"github.com/hyperf/roc/examples/json_rpc/action"
	"github.com/hyperf/roc/exception"
	"github.com/hyperf/roc/formatter"
	"github.com/hyperf/roc/router"
	"github.com/hyperf/roc/server"
)

func SetUpRouters() *router.SimpleRouter {
	r := router.NewSimpleRouter()
	r.Add("/foo/save", &action.FooSaveAction{})
	return r
}

func main() {
	r := SetUpRouters()

	handler := server.NewTcpServerHandler(func(route *formatter.JsonRPCRoute, packet *roc.Packet, server *server.TcpServer) (any, exception.ExceptionInterface) {
		action, ok := r.Routes[route.Path]
		if !ok {
			return nil, &exception.Exception{Code: exception.NOT_FOUND, Message: "The route is not defined."}
		}

		return action.Handle(packet, server.Serializer)
	})

	serv := server.NewTcpServer("0.0.0.0:9501", handler)

	serv.Start()
}

Related Repositories

• multiplex Channel driven multiplexing connection for PHP.
• multiplex-socket Socket of channel driven multiplexing connection for PHP.
• rpc-multiplex RPC of channel driven multiplexing connection for PHP.

Documentation

Index

• Constants
• type ChannelManager
  • func NewChannelManager() *ChannelManager
  • func (c ChannelManager) Close(id uint32)
  • func (c ChannelManager) Flush()
  • func (c *ChannelManager) Get(id uint32, initialize bool) chan []byte
  • func (c ChannelManager) GetChannels() map[uint32]chan []byte
  • func (_ *ChannelManager) Make(length uint32) chan []byte
• type HasHeartbeatInterface
• type IdGenerator
  • func (i *IdGenerator) Generate() uint32
• type IdGeneratorInterface
• type Packer
  • func (p *Packer) Pack(packet *Packet) []byte
  • func (p *Packer) UnPack(bs []byte) *Packet
• type PackerInterface
• type Packet
  • func NewPacket(id uint32, body string) *Packet
  • func (p *Packet) GetBody() string
  • func (p *Packet) GetId() uint32
  • func (p *Packet) IsHeartbeat() bool

Constants

const PING = "ping"

const PONG = "pong"

Types

type ChannelManager

type ChannelManager struct {
	// contains filtered or unexported fields
}

func NewChannelManager

func NewChannelManager() *ChannelManager

func (ChannelManager) Close

func (c ChannelManager) Close(id uint32)

func (ChannelManager) Flush

func (c ChannelManager) Flush()

func (*ChannelManager) Get

func (c *ChannelManager) Get(id uint32, initialize bool) chan []byte

func (ChannelManager) GetChannels

func (c ChannelManager) GetChannels() map[uint32]chan []byte

func (*ChannelManager) Make

func (_ *ChannelManager) Make(length uint32) chan []byte

type HasHeartbeatInterface

type HasHeartbeatInterface interface {
	IsHeartbeat() bool
}

type IdGenerator

type IdGenerator struct {
	// contains filtered or unexported fields
}

func (*IdGenerator) Generate

func (i *IdGenerator) Generate() uint32

type IdGeneratorInterface

type IdGeneratorInterface interface {
	Generate() uint32
}

type Packer

type Packer struct {
}

func (*Packer) Pack

func (p *Packer) Pack(packet *Packet) []byte

func (*Packer) UnPack

func (p *Packer) UnPack(bs []byte) *Packet

type PackerInterface

type PackerInterface interface {
	Pack(packet *Packet) []byte
	UnPack(bs []byte) *Packet
}

type Packet

type Packet struct {
	// contains filtered or unexported fields
}

func NewPacket

func NewPacket(id uint32, body string) *Packet

func (*Packet) GetBody

func (p *Packet) GetBody() string

func (*Packet) GetId

func (p *Packet) GetId() uint32

func (*Packet) IsHeartbeat

func (p *Packet) IsHeartbeat() bool