Example #1
0
File: ami_test.go Project: Luit/ami
func fakeReadingAMI(t *testing.T, l *net.TCPListener, expect [][]byte) {
	lconn, err := l.Accept()
	if err != nil {
		t.Fail()
		t.Log("error accepting", err)
		return
	}
	err = lconn.SetDeadline(time.Now().Add(5 * time.Second))
	//TODO
	_, err = lconn.Write([]byte("Asterisk Call Manager/1.3\r\n"))
	if err != nil {
		t.Fail()
		t.Log("error writing", err)
		return
	}
	for _, a := range expect {
		b := make([]byte, 1024)
		n, err := lconn.Read(b)
		if err != nil {
			t.Fail()
			t.Log("error reading:", err)
		}
		b = b[:n]
		if !bytes.Equal(a, b) {
			t.Fail()
			t.Logf("read expected %#v, got %#v", string(a), string(b))
		}
	}
}
func accept_clients(listener *net.TCPListener, wg *sync.WaitGroup) {
	defer wg.Done()
	for {
		if server_state == STOPPED {
			return
		}
		listener.SetDeadline(time.Now().Add(time.Duration(time.Second)))
		conn, err := listener.Accept()
		if err != nil {
			netErr, ok := err.(net.Error)
			if ok && netErr.Timeout() && netErr.Temporary() {
				continue
			} else {
				logger.Printf("accept client error: %v\n", err)
				server_state = STOPPED
				return
			}
		}
		client := tsp_task_manager.ClientInfo{new_client_id, &conn}
		new_client_id++
		tsp_task_manager.AddNewClient(client)
		logger.Println("I'm accept client #", client.ID)
		go listen_client(client)
	}
}
Example #3
0
func NewTCPSink(laddr string) (*Sink, error) {
	c := new(Connection)
	s := new(Sink)
	s.packets = make(chan *Packet)
	s.Connection = c

	localAddr := c.getTCPAddr(laddr)

	var listener *net.TCPListener
	if c.err == nil {
		listener, s.err = net.ListenTCP("tcp", localAddr)
	}

	if s.err == nil {
		go func() {
			for {
				conn, err := listener.Accept()
				if err == nil {
					go s.receivePackets(conn, s.newCloseChannel())
				} else {
					logger.Warningf("Failed to accept new connection: %v", err)
				}
			}
		}()
	}
	return s, s.err
}
func accept_workers(listener *net.TCPListener, wg *sync.WaitGroup) {
	defer wg.Done()
	for {
		if server_state == STOPPED {
			return
		}
		listener.SetDeadline(time.Now().Add(time.Duration(time.Second)))
		conn, err := listener.Accept()
		if err != nil {
			netErr, ok := err.(net.Error)
			if ok && netErr.Timeout() && netErr.Temporary() {
				continue
			} else {
				logger.Printf("accept worker error: %v\n", err)
				server_state = STOPPED
				return
			}
		}
		worker := &tsp_task_manager.WorkerInfo{new_worker_id, &conn, -1}
		tsp_task_manager.AddNewWorker(worker)
		logger.Println("I'm accept worker #", new_worker_id)
		go listen_worker(worker)
		new_worker_id++
	}
}
Example #5
0
func (server *GoTelnet) acceptConnection(listener *net.TCPListener) {
	conn, _ := listener.Accept()
	server.chanForNextAccept <- true
	if server.preConnection != nil {
		(*server.preConnection).Close()
	}
	server.preConnection = &conn
	conn.Write([]byte("welcome to telnet debug server"))

	defer conn.Close()

	for {
		buf := make([]byte, 1024)
		readlen, ok := conn.Read(buf)
		if ok != nil {
			fmt.Fprintf(os.Stderr, "close connection when reading from socket: %s\n", ok.String())
			return
		}
		if readlen == 0 {
			fmt.Printf("Connection closed by remote host\n")
			return
		}
		if buf[0] == 13 {
			conn.Write([]byte(server.Promote + ">"))
		}
		if string(buf[0:3]) == "bye" {
			conn.Write(buf)
			break
		}
		server.commandHandler.Handle(string(buf))
	}
}
Example #6
0
File: server.go Project: royger/DAD
func connListener(conn chan net.Conn, listener *net.TCPListener) {
	for {
		c, err := listener.Accept()
		if err != nil {
			panic("Accept: ", err.String())
		}
		conn <- c
	}
}
Example #7
0
func echoListen(listener *net.TCPListener) {
	for {
		c, err := listener.Accept()
		if err == nil {
			fmt.Println("accepeted")
			go echo(c)
		}
	}
}
Example #8
0
func pingListen(listener *net.TCPListener, peer *peer.Peer) {
	for {
		c, err := listener.Accept()
		if err == nil {
			fmt.Println("accepted")
			go pong(c, peer)
		}
	}
}
Example #9
0
func (server *Server) acceptConnections(listener *net.TCPListener) {
	for {
		conn, err := listener.Accept()
		if err != nil {
			fmt.Printf("Failed accept TCP connection: %v", err)
			continue
		}

		go server.handleConnection(conn)
	}
}
Example #10
0
func connectionListener(listener *net.TCPListener) {
	for {
		conn, err := listener.Accept()
		if err != nil {
			core.Log(core.LogInfo, "Closed network connection")
			done <- true
			return
		}
		go handleConnection(conn)
	}
}
Example #11
0
func (svr *Server) handler(listener *net.TCPListener) {
	defer listener.Close()
	for {
		conn, err := listener.Accept()
		if err != nil {
			time.Sleep(1 * time.Second)
			svr.StartServer()
			return
		}

		go svr.handleClient(conn)
	}
}
Example #12
0
func (tcp *Tcp) serve(listeningPoint *net.TCPListener) {
	log.Info("Begin serving TCP on address " + listeningPoint.Addr().String())

	for {
		baseConn, err := listeningPoint.Accept()
		if err != nil {
			log.Severe("Failed to accept TCP conn on address " + listeningPoint.Addr().String() + "; " + err.Error())
			continue
		}

		conn := NewConn(baseConn, tcp.output)
		log.Debug("Accepted new TCP conn %p from %s on address %s", &conn, conn.baseConn.RemoteAddr(), conn.baseConn.LocalAddr())
		tcp.connTable.Notify(baseConn.RemoteAddr().String(), conn)
	}
}
Example #13
0
func (srv *Server) serve(ln *net.TCPListener) error {
	defer ln.Close()

	for {
		if cn, err := ln.Accept(); err != nil {
			if ne, ok := err.(net.Error); ok && ne.Temporary() {
				continue
			} else {
				return err
			}
		} else {
			conn := newConn(srv, cn)
			srv.ConnPool.Add(conn)
			go conn.serve()
		}
	}
}
Example #14
0
func (tc *Consumer) listen(listener *net.TCPListener) {
	for {
		if log.V(2) {
			log.Info("Accepting client connection")
		}
		connection, err := listener.Accept()
		if err != nil {
			log.Warning("%s", err)
			return
		}

		if log.V(2) {
			log.Info("Accepted client connection")
		}
		go tc.handleConnection(connection)
	}
}
Example #15
0
func (srv *Server) Serve(listener *net.TCPListener) error {
	defer listener.Close()

	for {
		conn, err := listener.Accept()
		fmt.Println("accept :", conn.RemoteAddr())
		if err != nil {
			return err
		}

		serveConn, err := srv.newConn(conn)
		if err != nil {
			continue
		}
		go serveConn.ServeConn()
	}

	panic("not reached")
}
Example #16
0
func handleCmd(ch chan string, l *net.TCPListener, reply chan string) {
	for {

		file := <-ch
		log.Printf("handCmd %s\n", file)

		reply <- "file ok"

		dc, err := l.Accept()
		if err != nil {
			log.Fatalf("net accept error: %s\n", err)
		}

		log.Printf("get data connection\n")

		go handleFile(file, dc, reply)

	}
}
Example #17
0
// Accepts inbound connections till the service is terminated. For each one it
// starts a new handler and hands the socket over.
func (r *Relay) acceptor(listener *net.TCPListener) {
	// Accept connections until termination request
	var errc chan error
	for errc == nil {
		select {
		case errc = <-r.quit:
			break
		case client := <-r.done:
			// A client terminated, remove from active list
			delete(r.clients, client)
			if err := client.report(); err != nil {
				log.Printf("relay: closing client error: %v.", err)
			}
		default:
			// Accept an incoming connection but without blocking for too long
			listener.SetDeadline(time.Now().Add(acceptPollRate))
			if sock, err := listener.Accept(); err == nil {
				if rel, err := r.acceptRelay(sock); err != nil {
					log.Printf("relay: accept failed: %v.", err)
				} else {
					r.clients[rel] = struct{}{}
				}
			} else if !err.(net.Error).Timeout() {
				log.Printf("relay: accept failed: %v, terminating.", err)
			}
		}
	}
	// In case of failure, wait for termination request
	if errc == nil {
		errc = <-r.quit
	}
	// Forcefully close all active client connections
	for rel, _ := range r.clients {
		rel.drop()
		<-r.done
	}
	for rel, _ := range r.clients {
		rel.report()
	}
	// Clean up and report
	errc <- listener.Close()
}
Example #18
0
func (s *Server) goAcceptConnection(listener *net.TCPListener) {
	s.wait.Add(1)
	go func(listener *net.TCPListener) {
	loop:
		for {
			select {
			case <-s.doneTcp:
				break loop
			default:
			}
			connection, err := listener.Accept()
			if err != nil {
				continue
			}

			s.goScanConnection(connection)
		}

		s.wait.Done()
	}(listener)
}
Example #19
0
func (r *ZookoServer) serverLoop(listener *net.TCPListener) {
	connections := make(chan net.Conn)

	// Loop forever, waiting for connections
	go func() {
		for {
			// Accept a Connection
			conn, err := listener.Accept()
			if err != nil {
				fmt.Println("Error getting Accept", err)
				continue
			}

			connections <- conn
		}
	}()

	for {
		select {
		case conn := <-connections:
			go r.handleClient(conn)
		}
	}
}
Example #20
0
File: mock.go Project: avsej/gocb
// Creates and runs a new mock instance
// The path is the path to the mock jar.
// nodes is the total number of cluster nodes (and thus the number of mock threads)
// replicas is the number of replica nodes (subset of the number of nodes) for each couchbase bucket.
// vbuckets is the number of vbuckets to use for each couchbase bucket
// specs should be a list of specifications of buckets to use..
func NewMock(path string, nodes uint, replicas uint, vbuckets uint, specs ...BucketSpec) (m *Mock, err error) {
	var lsn *net.TCPListener = nil
	chAccept := make(chan bool)
	m = &Mock{}

	defer func() {
		close(chAccept)
		if lsn != nil {
			lsn.Close()
		}
		exc := recover()

		if exc == nil {
			// No errors, everything is OK
			return
		}

		// Close mock on error, destroying resources
		m.Close()
		if mExc, ok := exc.(mockError); !ok {
			panic(mExc)
		} else {
			m = nil
			err = mExc
		}
	}()

	if lsn, err = net.ListenTCP("tcp", &net.TCPAddr{Port: 0}); err != nil {
		throwMockError("Couldn't set up listening socket", err)
	}
	_, ctlPort, _ := net.SplitHostPort(lsn.Addr().String())
	log.Printf("Listening for control connection at %s\n", ctlPort)

	go func() {
		defer func() {
			chAccept <- false
		}()
		if m.conn, err = lsn.Accept(); err != nil {
			throwMockError("Couldn't accept incoming control connection from mock", err)
			return
		}
	}()

	if len(specs) == 0 {
		specs = []BucketSpec{BucketSpec{Name: "default", Type: BCouchbase}}
	}

	options := []string{
		"-jar", path, "--harakiri-monitor", "localhost:" + ctlPort, "--port", "0",
		"--replicas", strconv.Itoa(int(replicas)),
		"--vbuckets", strconv.Itoa(int(vbuckets)),
		"--nodes", strconv.Itoa(int(nodes)),
		"--buckets", m.buildSpecStrings(specs),
	}

	log.Printf("Invoking java %s", strings.Join(options, " "))
	m.cmd = exec.Command("java", options...)

	m.cmd.Stdout = os.Stdout
	m.cmd.Stderr = os.Stderr

	if err = m.cmd.Start(); err != nil {
		m.cmd = nil
		throwMockError("Couldn't start command", err)
	}

	select {
	case <-chAccept:
		break

	case <-time.After(mockInitTimeout):
		throwMockError("Timed out waiting for initalization", errors.New("timeout"))
	}

	m.rw = bufio.NewReadWriter(bufio.NewReader(m.conn), bufio.NewWriter(m.conn))

	// Read the port buffer, which is delimited by a NUL byte
	if portBytes, err := m.rw.ReadBytes(0); err != nil {
		throwMockError("Couldn't get port information", err)
	} else {
		portBytes = portBytes[:len(portBytes)-1]
		if entryPort, err := strconv.Atoi(string(portBytes)); err != nil {
			throwMockError("Incorrectly formatted port from mock", err)
		} else {
			m.EntryPort = uint16(entryPort)
		}
	}

	log.Printf("Mock HTTP port at %d\n", m.EntryPort)
	return
}
Example #21
0
// Start creates the accept routine and begins to accept connections.
func (t *TCP) Start(context interface{}) error {
	log.Dev(context, "Start", "IPAddress[ %s ]", join(t.ipAddress, t.port))

	t.listenerMu.Lock()
	{
		// If the listener has been started already, return an error.
		if t.listener != nil {
			err := errors.New("This TCP has already been started")
			log.Error(context, "Start", err, "Completed")
			t.listenerMu.Unlock()
			return err
		}
	}
	t.listenerMu.Unlock()

	t.wg.Add(1)

	// We need to wait for the goroutine to initialize itself.
	var waitStart sync.WaitGroup
	waitStart.Add(1)

	// Start the connection accept routine.
	go func() {
		var listener *net.TCPListener

		for {
			t.listenerMu.Lock()
			{
				// Start a listener for the specified addr and port is one
				// does not exist.
				if t.listener == nil {
					var err error
					listener, err = net.ListenTCP(t.NetType, t.tcpAddr)
					if err != nil {
						log.Error(context, "Start", err, "Completed")
						panic(err)
					}

					t.listener = listener

					waitStart.Done()

					log.Dev(context, "accept-routine", "Waiting For Connections : IPAddress[ %s ]", join(t.ipAddress, t.port))
				}
			}
			t.listenerMu.Unlock()

			// Listen for new connections.
			conn, err := listener.Accept()
			if err != nil {
				shutdown := atomic.LoadInt32(&t.shuttingDown)

				if shutdown == 0 {
					log.Error(context, "accept-routine", err, "Completed")
				} else {
					t.listenerMu.Lock()
					{
						t.listener = nil
					}
					t.listenerMu.Unlock()
					break
				}

				// temporary is declared to test for the existance of
				// the method coming from the net package.
				type temporary interface {
					Temporary() bool
				}

				if e, ok := err.(temporary); ok && !e.Temporary() {
					t.listenerMu.Lock()
					{
						t.listener.Close()
						t.listener = nil
					}
					t.listenerMu.Unlock()

					// Don't want to add a flag. So setting this back to
					// 1 so when the listener is re-established, the call
					// to Done does not fail.
					waitStart.Add(1)
				}

				continue
			}

			// Check if we are being asked to drop all new connections.
			if drop := atomic.LoadInt32(&t.dropConns); drop == 1 {
				log.Dev(context, "accept-routine", "*******> DROPPING CONNECTION")
				conn.Close()
				continue
			}

			// Check if rate limit is enabled.
			if t.RateLimit != nil {
				now := time.Now()

				// We will only accept 1 connection per duration. Anything
				// connection above that must be dropped.
				if t.lastAcceptedConnection.Add(t.RateLimit()).After(now) {
					log.Dev(context, "accept-routine", "*******> DROPPING CONNECTION Local[ %v ] Remote[ %v ] DUE TO RATE LIMIT %v", conn.LocalAddr(), conn.RemoteAddr(), t.RateLimit())
					conn.Close()
					continue
				}

				// Since we accepted connection, mark the time.
				t.lastAcceptedConnection = now
			}

			// Add this new connection to the manager map.
			t.join(context, conn)
		}

		// Shutting down the routine.
		t.wg.Done()
		log.Dev(context, "accept-routine", "Shutdown : IPAddress[ %s ]", join(t.ipAddress, t.port))
	}()

	// Wait for the goroutine to initialize itself.
	waitStart.Wait()

	log.Dev(context, "Start", "Completed")
	return nil
}