github.com/gogf/gf@v1.16.9/net/gudp/gudp_server.go (about)

     1  // Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
     2  //
     3  // This Source Code Form is subject to the terms of the MIT License.
     4  // If a copy of the MIT was not distributed with this file,
     5  // You can obtain one at https://github.com/gogf/gf.
     6  
     7  package gudp
     8  
     9  import (
    10  	"github.com/gogf/gf/errors/gcode"
    11  	"github.com/gogf/gf/errors/gerror"
    12  	"net"
    13  
    14  	"github.com/gogf/gf/container/gmap"
    15  	"github.com/gogf/gf/os/glog"
    16  	"github.com/gogf/gf/util/gconv"
    17  )
    18  
    19  const (
    20  	defaultServer = "default"
    21  )
    22  
    23  // Server is the UDP server.
    24  type Server struct {
    25  	conn    *Conn       // UDP server connection object.
    26  	address string      // UDP server listening address.
    27  	handler func(*Conn) // Handler for UDP connection.
    28  }
    29  
    30  var (
    31  	// serverMapping is used for instance name to its UDP server mappings.
    32  	serverMapping = gmap.NewStrAnyMap(true)
    33  )
    34  
    35  // GetServer creates and returns a UDP server instance with given name.
    36  func GetServer(name ...interface{}) *Server {
    37  	serverName := defaultServer
    38  	if len(name) > 0 && name[0] != "" {
    39  		serverName = gconv.String(name[0])
    40  	}
    41  	if s := serverMapping.Get(serverName); s != nil {
    42  		return s.(*Server)
    43  	}
    44  	s := NewServer("", nil)
    45  	serverMapping.Set(serverName, s)
    46  	return s
    47  }
    48  
    49  // NewServer creates and returns a UDP server.
    50  // The optional parameter <name> is used to specify its name, which can be used for
    51  // GetServer function to retrieve its instance.
    52  func NewServer(address string, handler func(*Conn), name ...string) *Server {
    53  	s := &Server{
    54  		address: address,
    55  		handler: handler,
    56  	}
    57  	if len(name) > 0 && name[0] != "" {
    58  		serverMapping.Set(name[0], s)
    59  	}
    60  	return s
    61  }
    62  
    63  // SetAddress sets the server address for UDP server.
    64  func (s *Server) SetAddress(address string) {
    65  	s.address = address
    66  }
    67  
    68  // SetHandler sets the connection handler for UDP server.
    69  func (s *Server) SetHandler(handler func(*Conn)) {
    70  	s.handler = handler
    71  }
    72  
    73  // Close closes the connection.
    74  // It will make server shutdowns immediately.
    75  func (s *Server) Close() error {
    76  	return s.conn.Close()
    77  }
    78  
    79  // Run starts listening UDP connection.
    80  func (s *Server) Run() error {
    81  	if s.handler == nil {
    82  		err := gerror.NewCode(gcode.CodeMissingConfiguration, "start running failed: socket handler not defined")
    83  		glog.Error(err)
    84  		return err
    85  	}
    86  	addr, err := net.ResolveUDPAddr("udp", s.address)
    87  	if err != nil {
    88  		glog.Error(err)
    89  		return err
    90  	}
    91  	conn, err := net.ListenUDP("udp", addr)
    92  	if err != nil {
    93  		glog.Error(err)
    94  		return err
    95  	}
    96  	s.conn = NewConnByNetConn(conn)
    97  	s.handler(s.conn)
    98  	return nil
    99  }