comments

Author: pedroAkos

pkg/neti/basicTcpService.go

@@ -140,6 +140,7 @@ func (b *basicTcpService) accept(bid []byte, conn HostConn) {
 	}
 }
 
+// InitBaseTcpService creates a new basic tcp service
 func InitBaseTcpService(listenAddr string, logger *log.Logger) NetService {
 	net := NewTcpNet(logger)
 	net.RegisterMessage(MessageWrap{})

pkg/neti/basicUdpService.go

@@ -117,6 +117,7 @@ func (b *basicUdpService) deliver(msg MessageWrap, conn *ServiceHostConn, err er
 	return errors.New(fmt.Sprintf("Listener with Id %v is not registered, entries: %v", conn.ServiceId, b.listeners))
 }
 
+// InitBaseUdpService creates a new basicUdpService
 func InitBaseUdpService(listenAddr string, buffsize int) NetService {
 	net := NewUdpNet(buffsize)
 	net.RegisterMessage(MessageWrap{})

pkg/neti/configuration.go

@@ -7,27 +7,31 @@ import (
 	"github.com/spf13/viper"
 )
 
+// Configuration is the configuration for the network
 type Configuration struct {
-	iface 	string
-	ip		 	string
-	port 		int
+	iface string
+	ip    string
+	port  int
 
-	buffSize	int
+	buffSize int
 
-	logger		*logrus.Logger
+	logger *logrus.Logger
 }
 
+// String returns a string representation of the configuration
 func (c Configuration) String() string {
 	return fmt.Sprintf("{iface: %v, ip: %v, port: %v, buffsize: %v}", c.iface, c.ip, c.port, c.buffSize)
 }
 
+// SetPFlags sets the pflags for the configuration
 func SetPFlags() {
 	pflag.String("net.ip", "", "IP address to bind")
 	pflag.String("net.iface", "lo0", "Network interface to bind")
 	pflag.Int("net.port", 10000, "Port to bind")
 	pflag.String("net.loglvl", "info", "Log Level for network")
 }
 
+// LoadConfiguration loads the configuration from viper
 func LoadConfiguration(viper *viper.Viper) Configuration {
 	c := Configuration{}
 	c.ip = viper.GetString("net.ip")
@@ -54,14 +58,17 @@ func LoadConfiguration(viper *viper.Viper) Configuration {
 	return c
 }
 
+// Address returns the addresses for the configuration
 func (c Configuration) Address() string {
 	return fmt.Sprintf("%s:%d", c.ip, c.port)
 }
 
+// BuffSize returns the buffer size for the configuration (used for UDP connections)
 func (c Configuration) BuffSize() int {
 	return c.buffSize
 }
 
+// WithPort returns a new configuration with the port changed
 func (c Configuration) WithPort(port int) string {
 	return fmt.Sprintf("%v:%v", c.ip, port)
 }

pkg/neti/messages.go

@@ -5,33 +5,40 @@ import (
 	"fmt"
 )
 
+// MessageWrap is a wrapper for messages that are sent over the network.
 type MessageWrap struct {
 	Id   string
 	Msg  Message
 	code uint16
 	buff *bytes.Buffer
 }
 
+// String returns a string representation of the message.
 func (m MessageWrap) String() string {
 	return fmt.Sprintf("%v{cid: %v mcode: %v}", m.Name(), m.Id, m.code)
 }
 
+// Name returns the name of the message.
 func (m MessageWrap) Name() string {
 	return "MessageWrap"
 }
 
+// Code returns the code of the message.
 func (m MessageWrap) Code() uint16 {
 	return 0
 }
 
+// Buff returns the buffer of the message.
 func (m MessageWrap) Buff() *bytes.Buffer {
 	return m.buff
 }
 
+// MessageCode is a code for a message.
 func (m MessageWrap) MessageCode() uint16 {
 	return m.code
 }
 
+// Serialize serializes the message.
 func (m MessageWrap) Serialize(buff *bytes.Buffer) error {
 	_ = EncodeStringToBuffer(m.Id, buff)
 	_ = EncodeNumberToBuffer(m.Msg.Code(), buff)
@@ -43,6 +50,7 @@ func (m MessageWrap) Serialize(buff *bytes.Buffer) error {
 	return nil
 }
 
+// Deserialize deserializes the message.
 func (m MessageWrap) Deserialize(buff *bytes.Buffer) (Message, error) {
 	m.Id, _ = DecodeStringFromBuffer(buff)
 	_ = DecodeNumberFromBuffer(&m.code, buff)

pkg/neti/network.go

@@ -11,6 +11,7 @@ import (
 
 type MessageDeserializer func(*bytes.Buffer) (Message, error)
 
+// Message is the interface that wraps the basic Message methods.
 type Message interface {
 	String() string
 	Name() string
@@ -19,6 +20,8 @@ type Message interface {
 	Deserialize(buff *bytes.Buffer) (Message, error)
 }
 
+// HostConn is the interface that wraps the basic HostConn methods.
+// This represents a connection to a host.
 type HostConn interface {
 	fmt.Stringer
 	Addr() net.Addr
@@ -45,6 +48,11 @@ type SentMessage struct {
 	Err  error
 }
 
+// Net is the interface that wraps the basic Net methods.
+// This represents a network. It can be a TCP, UDP, etc.
+// It can be used to send and receive messages.
+// It can be used to listen for new connections.
+// It can be used to connect to other hosts.
 type Net interface {
 	RegisterMessage(message Message)
 	Listen(addr string) (<-chan HostConn, error)
@@ -76,7 +84,8 @@ func readFully(reader io.Reader, toRead int) ([]byte, error) {
 	return b, err
 }
 
-//taken from https://gist.github.com/schwarzeni/f25031a3123f895ff3785970921e962c
+// GetInterfaceIpv4Addr returns the IPv4 address of the interface with the given name.
+// taken from https://gist.github.com/schwarzeni/f25031a3123f895ff3785970921e962c
 func GetInterfaceIpv4Addr(interfaceName string) (addr string, err error) {
 	var (
 		ief      *net.Interface

pkg/neti/service.go

@@ -13,6 +13,10 @@ const (
 	TCP TransportType = 2
 )
 
+// NetClient is an interface for a network client for a NetService.
+// Register the messages that the client can receive and send.
+// It can be used to send and receive messages.
+// It can be used to connect to other hosts.
 type NetClient interface {
 	RegisterMessage(message Message)                         //Register Message in the NetClient (Known how to deserialize)
 	RecvFrom(conn *ServiceHostConn) (Message, error)         //Receive Message from ServiceHostConn
@@ -24,25 +28,32 @@ type NetClient interface {
 	Id() string                                              //NodeID of NetClient
 }
 
+// NetService is an interface for a network service for a NetClient.
+// Register in the NetService the client id to get a NetClient.
+// NetService multiplexes the connections to the NetClient.
 type NetService interface {
 	RegisterListener(id string) NetClient
 	GetConfiguration() Configuration
 }
 
+// ServiceHostConn is a HostConn that multiplexes the connections to the NetClient.
 type ServiceHostConn struct {
 	Conn      HostConn
 	ServiceId string
 	Msg       Message
 }
 
+// String returns the string representation of the ServiceHostConn.
 func (s *ServiceHostConn) String() string {
 	return fmt.Sprintf("%v %v", s.ServiceId, s.Conn.String())
 }
 
+// Addr returns the address of the ServiceHostConn.
 func (s *ServiceHostConn) Addr() net.Addr {
 	return s.Conn.Addr()
 }
 
+// Send sends the  bytes to the Host on the other end of the ServiceHostConn.
 func (s *ServiceHostConn) Send(b []byte) error {
 	buff := new(bytes.Buffer)
 	if err := EncodeStringToBuffer(s.ServiceId, buff); err != nil {
@@ -54,6 +65,7 @@ func (s *ServiceHostConn) Send(b []byte) error {
 	return s.Conn.Send(buff.Bytes())
 }
 
+// Receive receives the bytes from the Host on the other end of the ServiceHostConn.
 func (s *ServiceHostConn) Receive() ([]byte, error) {
 	b, err := s.Conn.Receive()
 	buff := bytes.NewBuffer(b)
@@ -66,6 +78,7 @@ func (s *ServiceHostConn) Receive() ([]byte, error) {
 	return DecodeBytesFromBuffer(buff)
 }
 
+// Close closes the ServiceHostConn.
 func (s *ServiceHostConn) Close() error {
 	return s.Conn.Close()
 }

pkg/neti/simService.go

@@ -100,6 +100,8 @@ type simService struct {
 	listenners map[string]*simClient
 }
 
+// NewSimUDPService creates a new SimUDPService
+// This is a service that can be used to simulate a network.
 func NewSimUDPService() NetService {
 	return &simService{
 		protos:     make(map[string]uint64),

pkg/neti/utils.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 )
 
+// EncodeString encodes a string to a byte array
 func EncodeString(s string) ([]byte, error) {
 	b := new(bytes.Buffer)
 	err := EncodeStringToBuffer(s, b)
@@ -17,16 +18,19 @@ func EncodeString(s string) ([]byte, error) {
 	return b.Bytes(), nil
 }
 
+// DecodeString decodes a string from a byte array
 func DecodeString(buf []byte) (string, error) {
 	b := bytes.NewBuffer(buf)
 	return DecodeStringFromBuffer(b)
 }
 
+// EncodeStringToBuffer encodes a string to a buffer
 func EncodeStringToBuffer(s string, buffer *bytes.Buffer) error {
 	sb := []byte(s)
 	return EncodeBytesToBuffer(sb, buffer)
 }
 
+// DecodeStringFromBuffer decodes a string from a buffer
 func DecodeStringFromBuffer(buffer *bytes.Buffer) (string, error) {
 	sb, err := DecodeBytesFromBuffer(buffer)
 	if err != nil {
@@ -36,6 +40,7 @@ func DecodeStringFromBuffer(buffer *bytes.Buffer) (string, error) {
 	return string(sb), nil
 }
 
+// EncodeBytesToBuffer encodes a byte array to a buffer
 func EncodeBytesToBuffer(b []byte, buffer *bytes.Buffer) error {
 	err := binary.Write(buffer, binary.BigEndian, uint16(len(b)))
 	if err != nil {
@@ -55,6 +60,7 @@ func EncodeBytesToBuffer(b []byte, buffer *bytes.Buffer) error {
 	return nil
 }
 
+// DecodeBytesFromBuffer decodes a byte array from a buffer
 func DecodeBytesFromBuffer(buffer *bytes.Buffer) ([]byte, error) {
 	var bLen uint16
 	err := binary.Read(buffer, binary.BigEndian, &bLen)
@@ -78,13 +84,16 @@ func DecodeBytesFromBuffer(buffer *bytes.Buffer) ([]byte, error) {
 	return b, nil
 }
 
+// EncodeNumberToBuffer encodes a number to a buffer
 func EncodeNumberToBuffer(n interface{}, buffer *bytes.Buffer) error {
 	if err := binary.Write(buffer, binary.BigEndian, n); err != nil {
 		panic(err)
 	}
 	return nil
 }
 
+// DecodeNumberFromBuffer decodes a number from a buffer
+// Note that nPointer must be a pointer to the type of the number
 func DecodeNumberFromBuffer(nPointer interface{}, buffer *bytes.Buffer) error {
 	if err := binary.Read(buffer, binary.BigEndian, nPointer); err != nil {
 		panic(err)