notify/client_send.go

package notify

import (
	"context"
	"fmt"
	"os"
	"sync/atomic"
	"time"
)

func (c *ClientCommon) send(msg TransferMsg) (WaitMsg, error) {
	return c.sendWithContext(context.Background(), msg)
}

func (c *ClientCommon) sendWithContext(ctx context.Context, msg TransferMsg) (WaitMsg, error) {
	return c.sendWithContextTimeout(ctx, msg, 0)
}

func (c *ClientCommon) sendWithContextTimeout(ctx context.Context, msg TransferMsg, writeTimeout time.Duration) (WaitMsg, error) {
	return c.sendWithContextTimeoutAtRoute(ctx, c.clientSessionRouteSnapshot(), msg, writeTimeout)
}

func (c *ClientCommon) sendWithContextTimeoutAtRoute(ctx context.Context, route clientSessionRoute, msg TransferMsg, writeTimeout time.Duration) (WaitMsg, error) {
	if err := c.ensureClientSessionRouteSendReady(route); err != nil {
		return WaitMsg{}, err
	}
	if ctx == nil {
		ctx = context.Background()
	}
	var wait WaitMsg
	if msg.Type != MSG_SYNC_REPLY && msg.Type != MSG_KEY_CHANGE && msg.Type != MSG_SYS_REPLY || msg.ID == 0 {
		msg.ID = atomic.AddUint64(&c.msgID, 1)
	}
	env, err := wrapTransferMsgEnvelope(msg, c.sequenceEn)
	if err != nil {
		return WaitMsg{}, err
	}
	env.controlCtx = ctx
	env.controlTimeout = writeTimeout
	if requiresSignalReplyWait(msg) {
		wait = c.getPendingWaitPool().createAndStore(msg)
	}
	err = c.sendSignalEnvelopeMaybeReliableAtRoute(route, env, msg)
	if err != nil {
		if requiresSignalReplyWait(msg) {
			c.getPendingWaitPool().removeAndClose(msg.ID)
		}
		return WaitMsg{}, err
	}
	return wait, err
}

func (c *ClientCommon) sendEnvelope(env Envelope) error {
	return c.sendEnvelopeAtRoute(c.clientSessionRouteSnapshot(), env)
}

func (c *ClientCommon) sendEnvelopeAtRoute(route clientSessionRoute, env Envelope) error {
	if err := c.ensureClientSessionRouteSendReady(route); err != nil {
		return err
	}
	payload, err := c.encodeEnvelopePayload(env)
	if err != nil {
		return err
	}
	if batchedControlEnvelope(env) {
		return c.writeControlPayloadToTransportBindingTimeout(env.controlContext(), route.binding, payload, env.controlPriority, env.controlTimeout)
	}
	return c.writePayloadToTransportBindingContextTimeout(env.controlContext(), route.binding, payload, env.controlTimeout)
}

func (c *ClientCommon) dispatchEnvelope(env Envelope, now time.Time) {
	c.dispatchEnvelopeAtRoute(c.clientSessionRouteSnapshot(), env, now)
}

func (c *ClientCommon) dispatchEnvelopeAtRoute(route clientSessionRoute, env Envelope, now time.Time) {
	switch env.Kind {
	case EnvelopeSignalAck:
		if c.handleSignalAckEnvelope(env) {
			return
		}
	case EnvelopeStreamData:
		c.dispatchStreamEnvelopeAtRoute(route, env)
		return
	case EnvelopeSignal:
		transfer, err := unwrapTransferMsgEnvelope(env, c.sequenceDe)
		if err != nil {
			if c.showError || c.debugMode {
				fmt.Println("client unwrap signal envelope error", err)
			}
			return
		}
		if c.handleReceivedSignalReliabilityAtRoute(route, transfer) {
			return
		}
		message := Message{
			ServerConn:  c,
			clientRoute: route,
			TransferMsg: transfer,
			NetType:     NET_CLIENT,
			Time:        now,
		}
		c.dispatchMsg(message)
	case EnvelopeFileMeta, EnvelopeFileChunk, EnvelopeFileEnd, EnvelopeFileAbort, EnvelopeAck:
		c.dispatchFileEnvelope(env, now)
	default:
	}
}

func (c *ClientCommon) Send(key string, value MsgVal) error {
	_, err := c.send(TransferMsg{
		Key:   key,
		Value: value,
		Type:  MSG_ASYNC,
	})
	return err
}

func (c *ClientCommon) sendWait(msg TransferMsg, timeout time.Duration) (Message, error) {
	ctx := context.Background()
	cancel := func() {}
	if timeout != 0 {
		ctx, cancel = context.WithTimeout(ctx, timeout)
	}
	defer cancel()
	data, err := c.sendWithContext(ctx, msg)
	if err != nil {
		return Message{}, publicContextSendError(ctx, err)
	}
	stopCh := sessionStopChan(c.clientStopContextSnapshot())
	if timeout == 0 {
		msg, ok := <-data.Reply
		if !ok {
			return msg, pendingWaitClosedErrorWith(stopCh, clientTransportDetachedError(c))
		}
		return msg, nil
	}
	select {
	case <-ctx.Done():
		c.getPendingWaitPool().removeAndClose(data.TransferMsg.ID)
		return Message{}, os.ErrDeadlineExceeded
	case <-stopCh:
		return Message{}, errServiceShutdown
	case msg, ok := <-data.Reply:
		if !ok {
			return msg, pendingWaitClosedErrorWith(stopCh, clientTransportDetachedError(c))
		}
		return msg, nil
	}
}

func (c *ClientCommon) sendCtx(msg TransferMsg, ctx context.Context) (Message, error) {
	return c.sendCtxAtRoute(c.clientSessionRouteSnapshot(), msg, ctx)
}

func (c *ClientCommon) sendCtxAtRoute(route clientSessionRoute, msg TransferMsg, ctx context.Context) (Message, error) {
	if ctx == nil {
		ctx = context.Background()
	}
	data, err := c.sendWithContextTimeoutAtRoute(ctx, route, msg, 0)
	if err != nil {
		return Message{}, publicContextSendError(ctx, err)
	}
	stopCh := sessionStopChan(route.sessionStopCtx)
	transportStopCh := sessionStopChan(route.transportStopCtx)
	select {
	case <-ctx.Done():
		c.getPendingWaitPool().removeAndClose(data.TransferMsg.ID)
		return Message{}, normalizeStreamDeadlineError(ctx.Err())
	case <-stopCh:
		return Message{}, errServiceShutdown
	case <-transportStopCh:
		c.getPendingWaitPool().removeAndClose(data.TransferMsg.ID)
		if route.sessionStopCtx != nil && route.sessionStopCtx.Err() != nil {
			return Message{}, errServiceShutdown
		}
		return Message{}, transportDetachedSessionEpochError()
	case msg, ok := <-data.Reply:
		if !ok {
			return msg, pendingWaitClosedErrorWith(stopCh, clientTransportDetachedError(c))
		}
		return msg, nil
	}
}

func (c *ClientCommon) SendObjCtx(ctx context.Context, key string, val interface{}) (Message, error) {
	return c.sendObjCtxAtRoute(ctx, c.clientSessionRouteSnapshot(), key, val)
}

func (c *ClientCommon) sendObjCtxAtRoute(ctx context.Context, route clientSessionRoute, key string, val interface{}) (Message, error) {
	data, err := c.sequenceEn(val)
	if err != nil {
		return Message{}, err
	}
	return c.sendCtxAtRoute(route, TransferMsg{
		Key:   key,
		Value: data,
		Type:  MSG_SYNC_ASK,
	}, ctx)
}

func (c *ClientCommon) SendObj(key string, val interface{}) error {
	data, err := encode(val)
	if err != nil {
		return err
	}
	_, err = c.send(TransferMsg{
		Key:   key,
		Value: data,
		Type:  MSG_ASYNC,
	})
	return err
}

func (c *ClientCommon) SendCtx(ctx context.Context, key string, value MsgVal) (Message, error) {
	return c.sendCtx(TransferMsg{
		Key:   key,
		Value: value,
		Type:  MSG_SYNC_ASK,
	}, ctx)
}

func (c *ClientCommon) SendWait(key string, value MsgVal, timeout time.Duration) (Message, error) {
	return c.sendWait(TransferMsg{
		Key:   key,
		Value: value,
		Type:  MSG_SYNC_ASK,
	}, timeout)
}

func (c *ClientCommon) SendWaitObj(key string, value interface{}, timeout time.Duration) (Message, error) {
	data, err := c.sequenceEn(value)
	if err != nil {
		return Message{}, err
	}
	return c.SendWait(key, data, timeout)
}

func (c *ClientCommon) Reply(m Message, value MsgVal) error {
	return m.Reply(value)
}