func (handler *_TunnelClient) Active(context gorpc.Context) error { handler.agents = make(map[string]*_Agent) handler.system.addTunnel(handler.name, handler, context.Pipeline()) // send TunnelWhoAmI whoAmI := gorpc.NewTunnelWhoAmI() whoAmI.Services = handler.system.system.AgentServices() var buff bytes.Buffer gorpc.WriteTunnelWhoAmI(&buff, whoAmI) message := gorpc.NewMessage() message.Code = gorpc.CodeTunnelWhoAmI message.Content = buff.Bytes() context.Send(message) return nil }
func (handler *_HeartbeatHandler) timeoutLoop(context gorpc.Context, exitflag chan bool) { wheel := context.Pipeline().TimeWheel() ticker := wheel.NewTicker(handler.timeout) defer ticker.Stop() for { select { case <-ticker.C: if time.Now().Sub(handler.timestamp) > handler.timeout*2 { handler.context.Close() handler.W("heartbeat timeout(%s), close current pipeline(%s)", handler.timeout*2, handler.context.Pipeline()) return } message := gorpc.NewMessage() message.Code = gorpc.CodeHeartbeat handler.context.Send(message) handler.V("%s send heartbeat message", handler.context.Pipeline()) case <-exitflag: handler.V("exit heartbeat loop .....................") return } } }
func (handler *_TunnelClient) Inactive(context gorpc.Context) { for _, agent := range handler.agents { handler.system.system.UnbindAgent(agent) } handler.system.removeTunnel(handler.name, handler, context.Pipeline()) }
func (handler *_TransProxyHandler) Active(context gorpc.Context) error { dh, _ := context.Pipeline().Handler(dhHandler) handler.device = dh.(gorpcHandler.CryptoServer).GetDevice() return nil }
func (client *_Client) Active(context gorpc.Context) error { dh, _ := context.Pipeline().Handler(dhHandler) device := dh.(handler.CryptoServer).GetDevice() client.pipeline = context.Pipeline() client.device = device client.context.addClient(client) return nil }
func (handler *_TunnelServerHandler) MessageReceived(context gorpc.Context, message *gorpc.Message) (*gorpc.Message, error) { if message.Code == gorpc.CodeTunnelWhoAmI { handler.I("tunnel handshake ......") whoAmI, err := gorpc.ReadTunnelWhoAmI(bytes.NewBuffer(message.Content)) if err != nil { return nil, err } handler.proxy.proxy.BindServices(handler.proxy, context.Pipeline(), whoAmI.Services) context.FireActive() return nil, nil } if message.Code != gorpc.CodeTunnel { return message, nil } handler.V("backward tunnel message") tunnel, err := gorpc.ReadTunnel(bytes.NewBuffer(message.Content)) if err != nil { handler.E("backward tunnel(%s) message -- failed\n%s", tunnel.ID, err) return nil, err } if device, ok := handler.proxy.client(tunnel.ID); ok { tunnel.Message.Agent = handler.id err := device.SendMessage(tunnel.Message) if err == nil { handler.V("backward tunnel message -- success") return nil, nil } return nil, err } handler.E("backward tunnel(%s) message -- failed,device not found", tunnel.ID) return nil, nil }
func (handler *_HeartbeatHandler) MessageReceived(context gorpc.Context, message *gorpc.Message) (*gorpc.Message, error) { if message.Code == gorpc.CodeHeartbeat { handler.V("%s recv heartbeat message", context.Pipeline()) if handler.timeout != 0 { handler.timestamp = time.Now() } return nil, nil } return message, nil }
func newAgent(ctx gorpc.Context, handler *_TunnelClient, device *gorpc.Device) (*_Agent, error) { context := &_Agent{ handler: handler, id: device, } context.Sink = gorpc.NewSink(device.String(), context, ctx.Pipeline().TimeWheel(), handler.timeout) var err error err = handler.system.system.BindAgent(context) if err != nil { return nil, err } return context, nil }
func (handler *_StateHandler) Inactive(context gorpc.Context) { handler.f(context.Pipeline(), gorpc.StateDisconnect) }
func (handler *_StateHandler) Unregister(context gorpc.Context) { handler.f(context.Pipeline(), gorpc.StateClosed) }
func (handler *_StateHandler) Active(context gorpc.Context) error { handler.f(context.Pipeline(), gorpc.StateConnected) return nil }
func (handler *_TunnelServerHandler) Inactive(context gorpc.Context) { go handler.proxy.proxy.UnbindServices(handler.proxy, context.Pipeline()) }