gitee.com/sy_183/go-common@v1.0.5-0.20231205030221-958cfe129b47/ipc/cgo/shm-server/server.go

package shmServer

import (
	"errors"
	"fmt"
	"gitee.com/sy_183/go-common/container"
	semPkg "gitee.com/sy_183/go-common/ipc/cgo/sem"
	"gitee.com/sy_183/go-common/ipc/cgo/sem/queue"
	"gitee.com/sy_183/go-common/lifecycle"
	"io"
	"net"
	"os"
	"sync"
	"sync/atomic"
	"time"
	"unsafe"
)

type selector struct {
	qcs []struct {
		queue32 *queue.Queue32
		channel *Channel
	}
}

type Server struct {
	lifecycle.Lifecycle
	runner *lifecycle.DefaultLifecycle
	closed atomic.Bool

	addr     *net.UDPAddr
	conn     *net.UDPConn
	allocSem semPkg.NamedSem
	useSem   semPkg.NamedSem

	channels     container.SyncMap[AddrId, *Channel]
	selector     atomic.Pointer[selector]
	selectorLock sync.Mutex

	errorHandlers [][]ErrorHandler
}

func NewServer(addr *net.UDPAddr) *Server {
	net.ListenUnix()
}

func loadErrorHandler(p *ErrorHandler) ErrorHandler {
	up := atomic.LoadUintptr((*uintptr)(unsafe.Pointer(p)))
	return *(*ErrorHandler)(unsafe.Pointer(&up))
}

func storeErrorHandler(p *ErrorHandler, handler ErrorHandler) {
	up := *(*uintptr)(unsafe.Pointer(&handler))
	atomic.StoreUintptr((*uintptr)(unsafe.Pointer(p)), up)
}

func (s *Server) locateErrorHandler(typ ErrType) (main, sub *ErrorHandler) {
	mt := int(typ >> 8)
	st := int(typ & 0xff)
	if mt < len(s.errorHandlers) {
		if mhs := s.errorHandlers[mt]; mt == 0 {
			return &mhs[0], nil
		} else if mt < len(mhs) {
			return &mhs[st], &mhs[0]
		}
	}
	return nil, nil
}

func (s *Server) getErrorHandler(typ ErrType) (main, sub ErrorHandler) {
	mp, sp := s.locateErrorHandler(typ)
	if mp != nil {
		main = loadErrorHandler(mp)
	}
	if sp != nil {
		sub = loadErrorHandler(sp)
	}
	return
}

func (s *Server) handleError(typ ErrType, err error, args ...any) {
	main, sub := s.getErrorHandler(typ)
	if sub != nil {
		sub(typ, err, args...)
		return
	}
	if main != nil {
		main(typ, err, args...)
	}
	return
}

func (s *Server) ErrorHandler(typ ErrType) ErrorHandler {
	if mp, sp := s.locateErrorHandler(typ); sp != nil {
		return loadErrorHandler(sp)
	} else if mp != nil {
		return loadErrorHandler(mp)
	}
	return nil
}

func (s *Server) SetErrorHandler(typ ErrType, handler ErrorHandler) {
	if mp, sp := s.locateErrorHandler(typ); sp != nil {
		storeErrorHandler(sp, handler)
	} else if mp != nil {
		storeErrorHandler(mp, handler)
	}
}

func (s *Server) updateSelectChannel() {
	qcs := s.selector.Load().qcs[:0:0]
	s.selectorLock.Lock()
	defer s.selectorLock.Unlock()
	s.channels.Range(func(id AddrId, ch *Channel) bool {
		if q := ch.loadQueue(); q != nil {
			qcs = append(qcs, struct {
				queue32 *queue.Queue32
				channel *Channel
			}{queue32: q, channel: ch})
		}
		return true
	})
	s.selector.Store(&selector{qcs: qcs})
}

func (s *Server) start(lifecycle.Lifecycle) (err error) {
	// 监听UDP
	conn, err := net.ListenUDP("udp", s.addr)
	if err != nil {
		s.handleError(ErrTypeUdpListen, err, s)
		return err
	}
	s.conn = conn
	defer func() {
		if err != nil {
			if err := s.conn.Close(); err != nil {
				s.handleError(ErrTypeUdpClose, err, s)
			}
			s.conn = nil
		}
	}()

	ads := addrToString(s.addr)

	// 打开可申请空间的信号量
	allocName := fmt.Sprintf("go-shm-server_%s_alloc", ads)
	allocSem, err := semPkg.Open(allocName, os.O_CREATE|os.O_EXCL, 0644, 0)
	if err != nil {
		s.handleError(ErrTypeSemOpen, err, s, allocName)
		return err
	}
	s.allocSem = allocSem
	defer func() {
		if err != nil {
			if err := s.allocSem.Unlink(); err != nil {
				s.handleError(ErrTypeSemUnlink, err, s, s.allocSem.Name())
			}
			s.allocSem = semPkg.NamedSem{}
		}
	}()

	// 打开可使用空间的信号量
	useName := fmt.Sprintf("go-shm-server_%s_use", ads)
	useSem, err := semPkg.Open(useName, os.O_CREATE|os.O_EXCL, 0644, 0)
	if err != nil {
		s.handleError(ErrTypeSemOpen, err, s, useName)
		return err
	}
	s.useSem = useSem
	return nil
}

func (s *Server) read(buf []byte) (data []byte, addr *net.UDPAddr, close bool, err error) {
	if err := s.conn.SetReadDeadline(time.Now().Add(time.Second)); err != nil {
		s.handleError(ErrTypeUdpSetReadDeadline, err, s)
	}

	n, addr, err := s.conn.ReadFromUDP(buf)
	if err != nil {
		if netErr, is := err.(net.Error); is && netErr.Timeout() {
			if s.closed.Load() {
				return nil, nil, true, err
			}
			return nil, nil, false, nil
		} else if err == io.EOF {
			return nil, nil, true, nil
		} else if opErr, is := err.(*net.OpError); is && errors.Is(opErr.Err, net.ErrClosed) {
			return nil, nil, true, nil
		}
		s.handleError(ErrTypeUdpRead, err, s)
		return nil, nil, true, err
	}

	return buf[:n], addr, false, nil
}

func (s *Server) run(lifecycle.Lifecycle) error {
	go func() {
		if err := s.useSem.Wait(); err != nil {
			s.handleError(ErrTypeSemWait, err, s, s.useSem.Name())
			return
		}

		sel := s.selector.Load()
		for _, qc := range sel.qcs {
			q := qc.queue32
			view, ok := q.WantTryUse(q.Cap())
			if ok {

			}
		}
	}()

	var buf [maxPacketLength]byte
	var basePacket BasePacket
	var addrId AddrId

	for {
		data, addr, closed, err := s.read(buf[:])
		if closed {
			return err
		}

		if err, et := basePacket.Unmarshal(data); err != nil {
			s.handleError(et, err, s)
			continue
		}
		addrId.Unmarshal(addr.IP, addr.Port)
		channel, _ := s.channels.Load(addrId)

		switch basePacket.command {
		case CommandOpenRequest:
			if channel == nil {
				channel = newChannel(addrId)
			}
			s.conn.
				channel.handelOpen(OpenRequest{basePacket})
		case CommandAllocRequest:
			packet := AllocRequest{BasePacket: basePacket}
			if err, et := packet.Unmarshal(data); err != nil {
				s.handleError(et, err, s)
				continue
			}
			channel.handleAlloc(packet)
		case CommandKeepaliveRequest:
			channel.handleKeepalive(KeepaliveRequest{basePacket})
		case CommandCloseRequest:
			channel.handleClose(CloseRequest{basePacket})
		case CommandOpenResponse,
			CommandAllocResponse,
			CommandKeepaliveResponse,
			CommandCloseResponse:
			continue
		}
	}
}

func (s *Server) close(lifecycle.Lifecycle) error {

}