latest

Makefile

@@ -1,6 +1,8 @@
-GOPATH := $(shell pwd)
-
 default: run
 
-run: src/*.go
+run: *.go */*.go
-	go run src/*.go
+	go run main.go
+
+fmt:
+	go fmt *.go
+	go fmt sircd/*.go

main.go

@@ -1,15 +1,15 @@
 package main
 
-import "log"
+import "github.com/sirupsen/logrus"
-import "os"
+import "github.com/sneak/sircd/sircd"
-import "sircd"
 import "time"
 
 func main() {
-    l := log.New(os.Stdout, "", log.Ldate | log.Lmicroseconds | log.Lshortfile)
+	var log = logrus.New()
-    l.Println("sircd starting up")
+	log.SetLevel(log.DebugLevel)
+	log.Println("sircd starting up")
 	s := sircd.NewSircd()
-    s.SetLogger(l)
+	s.SetLogger(log)
 	go s.Start()
 	for s.Running {
 		time.Sleep(1 * time.Second)

sircd/client.go

@@ -1,40 +1,54 @@
 package sircd
 
 import (
-	"log"
-	"net"
 	"bytes"
+	"github.com/google/uuid"
+	"github.com/sirupsen/logrus"
+	"net"
 )
 
-func newClientIRCConnection(conn net.Conn, log *log.Logger) *clientIRCConnection {
+func newIrcClient(conn net.Conn, log *logrus.Logger, mc chan *ircMessage) *ircClient {
-    c := new(clientIRCConnection)
+	c := new(ircClient)
+	c.Id = uuid.New().String()
 	c.conn = conn
 	c.log = log
+	c.mc = mc
 	c.inputBytes = new(bytes.Buffer)
 	c.outputBytes = new(bytes.Buffer)
-    c.ReadSocket()
 	return c
 }
 
-type clientIRCConnection struct {
+type ircClient struct {
-	Id          uint64
+	Id          string
 	conn        net.Conn
-	log         *log.Logger
+	log         *logrus.Logger
+	session     *ircUserSession
 	inputBytes  *bytes.Buffer
 	outputBytes *bytes.Buffer
+	mc          chan *ircMessage
 }
 
-func (c *clientIRCConnection) ReadSocket() {
+type ircMessage struct {
+	from *ircClient
+	//received
+	//command
+}
+
+func (c *ircClient) Close() {
+	//client cleanup
+	c.log.Infof("client %d disconnect", c.Id)
+}
+
+func (c *ircClient) AppendInputBuffer(input []byte) {
 	// Read the incoming connection into the buffer.
-    buf := make([]byte, 1024*1024)
+	c.log.Printf("conn<%s>: got %d bytes from net", c.Id, len(input))
-    bytesRead, err := c.conn.Read(buf)
+	c.inputBytes.Write(input)
-	c.log.Printf("conn<%d>: read %d bytes from net", c.Id, bytesRead)
+	c.log.Debugf("conn<%s> buffer now %d bytes total", c.inputBytes.Len())
-	if err != nil {
+	c.ParseMessages()
-		c.log.Println("Error reading:", err.Error())
-	}
-    c.inputBytes.Write(buf)
 }
 
-func (c *clientIRCConnection) ParseMessages() {
+func (c *ircClient) ParseMessages() {
-    c.log.Fatalln("not implemented")
+	c.log.Debugln("my input buffer is %d", c.inputBytes.Len())
+	c.log.Debugln("my input buffer is: '%s'", c.inputBytes.String())
+	//c.log.Fatalln("not implemented")
 }

sircd/main.go

@@ -0,0 +1,30 @@
+package sircd
+
+func (s *sircd) processIRCMessage(m *ircMessage) {
+	s.log.Info("not implemented")
+	//for client, _ := range s.ircClients {
+	//}
+}
+
+/*
+
+import "net"
+		case publish := <-publishes:
+			for conn, _ := range conns {
+				go func(conn net.Conn) {
+					totalWritten := 0
+					for totalWritten < len(publish) {
+						writtenThisCall, err := conn.Write(publish[totalWritten:])
+						if err != nil {
+							deadConns <- conn
+							break
+						}
+						totalWritten += writtenThisCall
+					}
+				}(conn)
+			}
+		}
+	}
+	listener.Close()
+}
+*/

sircd/server.go

@@ -1,20 +1,21 @@
 package sircd
 
 import (
-	"log"
+	"github.com/sirupsen/logrus"
 	"net"
-	"os"
-    "container/list"
 )
 
 type sircd struct {
 	Running      bool
-	log         *log.Logger
+	log          *logrus.Logger
 	netName      string
 	ircPort      uint16
 	httpPort     uint16
 	ircListener  net.Listener
-	ircClients  *list.List
+	ircClients   map[*ircClient]bool
+	newClients   chan *ircClient
+	deadClients  chan *ircClient
+	messageQueue chan *ircMessage
 }
 
 const (
@@ -26,55 +27,84 @@ const (
 func NewSircd() *sircd {
 	s := new(sircd)
 	s.Running = true
-    s.ircClients = list.New()
+	s.ircClients = make(map[*ircClient]bool)
 	return s
 }
 
-func (s *sircd) SetLogger(l *log.Logger) {
+func (s *sircd) SetLogger(l *logrus.Logger) {
 	s.log = l
 }
 
-func (s *sircd) startIRCServer() {
+func (s *sircd) Start() {
+
+	s.newClients = make(chan *ircClient, 128)
+	s.deadClients = make(chan *ircClient, 128)
+	s.messageQueue = make(chan *ircMessage, 128)
+
 	var err error
 	s.ircListener, err = net.Listen(CONN_TYPE, CONN_HOST+":"+CONN_PORT)
 	if err != nil {
-		log.Println("Error listening:", err.Error())
+		s.log.Fatalln("Error listening:", err.Error())
-		os.Exit(1)
 	}
-	defer s.ircListener.Close()
 	s.log.Println("Listening for irc on " + CONN_HOST + ":" + CONN_PORT)
 
-	for {
+	go func() {
-		// Listen for an incoming connection.
 		conn, err := s.ircListener.Accept()
 		if err != nil {
-			s.log.Fatalf("Error accepting: ", err.Error())
+			s.log.Panicf("Error accepting: ", err.Error())
-		}
-		// Handle connections in a new goroutine.
-		go s.handleIRCConnection(conn)
 		}
+		s.newClients <- newIrcClient(conn, s.log, s.messageQueue)
+	}()
 
+	go s.mainloop()
 }
 
-func (s *sircd) processIRC() {
+func (s *sircd) mainloop() {
 	for {
-        s.readFromClients()
+		select {
+		case client := <-s.newClients:
+			s.ircClients[client] = true
+			s.log.Println("new irc client: %s", client.Id)
+			go func() {
+				buf := make([]byte, 1024*1024)
+				for {
+					nbyte, err := client.conn.Read(buf)
+					if err != nil {
+						s.deadClients <- client
+						break
+					} else {
+						fragment := make([]byte, nbyte)
+						copy(fragment, buf[:nbyte])
+						// this will populate the message channel
+						client.AppendInputBuffer(fragment)
+					}
+				}
+			}()
+		case deadClient := <-s.deadClients:
+			delete(s.ircClients, deadClient)
+			deadClient.Close()
+		case message := <-s.messageQueue:
+			s.processIRCMessage(message)
+		}
 	}
 }
 
-func (s *sircd) readFromClients() {
+/*
-    for e := s.ircClients.Front(); e != nil; e = e.Next() {
+		case publish := <-publishes:
-        client := e.Value.(clientIRCConnection)
+			for conn, _ := range conns {
-        client.ReadSocket()
+				go func(conn net.Conn) {
-        client.ParseMessages()
+					totalWritten := 0
+					for totalWritten < len(publish) {
+						writtenThisCall, err := conn.Write(publish[totalWritten:])
+						if err != nil {
+							deadConns <- conn
+							break
 						}
-}
+						totalWritten += writtenThisCall
-
+					}
-func (s *sircd) Start() {
+				}(conn)
-	go s.startIRCServer()
+			}
-}
+		}
-
+	}
-func (s *sircd) handleIRCConnection(conn net.Conn) {
+	listener.Close()
-	c := newClientIRCConnection(conn, s.log)
+*/
-    s.ircClients.PushBack(c)
-}

sircd/session.go

@@ -0,0 +1,9 @@
+package sircd
+
+type ircNick string
+type ircRealName string
+
+type ircUserSession struct {
+	nick     ircNick
+	realname ircRealName
+}