Exemple #1
3
func UnixAudienceListener(sockaddr string) {
	fi, err := os.Stat(sockaddr)
	if err == nil {
		fmode := fi.Mode()
		if fmode&os.ModeType == os.ModeSocket {
			o.Warn("Removing stale socket at %s", sockaddr)
			os.Remove(sockaddr)
		} else {
			o.Fail("%s exists and is not a socket", sockaddr)
		}
	}
	laddr, err := net.ResolveUnixAddr("unix", sockaddr)
	o.MightFail(err, "Couldn't resolve audience socket address")
	l, err := net.ListenUnix("unix", laddr)
	o.MightFail(err, "Couldn't start audience unixsock listener")
	// Fudge the permissions on the unixsock!
	fi, err = os.Stat(sockaddr)
	if err == nil {
		os.Chmod(sockaddr, fi.Mode()|0777)
	} else {
		o.Warn("Couldn't fudge permission on audience socket: %s", err)
	}

	// make sure we clean up the unix socket when we die.
	defer l.Close()
	defer os.Remove(sockaddr)
	AudienceListener(l)
}
Exemple #2
1
func TestQmpInitTimeout(t *testing.T) {
	ctx, qc := testQmpEnvironment()

	go qmpHandler(ctx)

	t.Log("connecting to ", qc.qmpSockName)

	ss, err := net.ListenUnix("unix", &net.UnixAddr{qc.qmpSockName, "unix"})
	if err != nil {
		t.Error("fail to setup connect to qmp socket", err.Error())
	}

	c, err := ss.Accept()
	if err != nil {
		t.Error("cannot accept qmp socket", err.Error())
	}
	defer ss.Close()
	defer c.Close()

	t.Log("connected")

	time.Sleep(11 * time.Second)

	ev := <-ctx.Hub
	if ev.Event() != hypervisor.ERROR_INIT_FAIL {
		t.Error("should got an fail event")
	}

	t.Log("finished timeout test")
}
func unix_coll(_, address string) (Listener, error) {
	var err error

	r := new(unix_receiver)
	r.network = "unix"
	r.address = address

	r.listener, err = net.ListenUnix("unix", &net.UnixAddr{address, "unix"})
	for err != nil {
		switch err.(type) {
		case *net.OpError:
			if err.(*net.OpError).Err.Error() != "bind: address already in use" {
				return nil, err
			}

		default:
			return nil, err
		}

		if _, r_err := os.Stat(address); r_err != nil {
			return nil, err
		}
		os.Remove(address)

		r.listener, err = net.ListenUnix("unix", &net.UnixAddr{address, "unix"})
	}

	return r, nil
}
Exemple #4
0
func create_socket(l *log.Logger, socket string, uid, gid int, end <-chan struct{}, wg *sync.WaitGroup) *Listener {
	conn, err := net.ListenUnix("unix", &net.UnixAddr{socket, "unix"})
	for err != nil {
		switch err.(type) {
		case *net.OpError:
			if err.(*net.OpError).Err.Error() != "bind: address already in use" {
				l.Printf("Listen %s : %s", socket, err)
			}

		default:
			l.Printf("Listen %s : %s", socket, err)
		}

		if _, r_err := os.Stat(socket); r_err != nil {
			l.Printf("Lstat %s : %s", socket, err)
		}
		os.Remove(socket)

		conn, err = net.ListenUnix("unix", &net.UnixAddr{socket, "unix"})
	}
	os.Chown(socket, uid, gid)

	wg.Add(1)
	return &Listener{conn, end, wg}
}
Exemple #5
0
func newUnixServer(keys string, uuid string) (Server, error) {
	var err error

	abstract := getKey(keys, "abstract")
	path := getKey(keys, "path")

	s := new(unixServer)
	s.uuid = uuid
	switch {
	case abstract == "" && path == "":
		return nil, errors.New("dbus: invalid address (neither path nor abstract set)")
	case abstract != "" && path == "":
		s.listener, err = net.ListenUnix("unix", &net.UnixAddr{Name: "@" + abstract, Net: "unix"})
		if err != nil {
			return nil, err
		}
		return s, nil
	case abstract == "" && path != "":
		s.listener, err = net.ListenUnix("unix", &net.UnixAddr{Name: path, Net: "unix"})
		if err != nil {
			return nil, err
		}
		return s, nil
	default:
		return nil, errors.New("dbus: invalid address (both path and abstract set)")
	}
}
Exemple #6
0
func UnixAudienceListener(sockaddr string, sockmode os.FileMode, sockuid int, sockgid int) {
	fi, err := os.Stat(sockaddr)
	if err == nil {
		if (fi.Mode() & os.ModeSocket) != 0 {
			os.Remove(sockaddr)
		} else {
			o.Fail("%s exists and is not a socket", sockaddr)
		}
	}
	err = os.MkdirAll(path.Dir(sockaddr), 0755)
	o.MightFail(err, "Couldn't create socket directory")
	laddr, err := net.ResolveUnixAddr("unix", sockaddr)
	o.MightFail(err, "Couldn't resolve audience socket address")
	old_umask := syscall.Umask(0777)
	defer syscall.Umask(old_umask)
	l, err := net.ListenUnix("unix", laddr)
	o.MightFail(err, "Couldn't start audience unixsock listener")
	if sockuid >= 0 || sockgid >= 0 {
		err = os.Chown(sockaddr, sockuid, sockgid)
		o.MightFail(err, "Couldn't chown audience unixsock listener")
	}
	err = os.Chmod(sockaddr, sockmode)
	o.MightFail(err, "Couldn't chmod audience unixsock listener")

	// make sure we clean up the unix socket when we die.
	defer l.Close()
	defer os.Remove(sockaddr)
	AudienceListener(l)
}
Exemple #7
0
func StartClientHandler(tree *ProcessTree, quit chan bool) {
	path, _ := filepath.Abs(zeusSockName)
	addr, err := net.ResolveUnixAddr("unix", path)
	if err != nil {
		panic("Can't open socket.")
	}
	listener, err := net.ListenUnix("unix", addr)
	if err != nil {
		ErrorCantCreateListener()
	}
	defer listener.Close()

	connections := make(chan *unixsocket.Usock)
	go func() {
		for {
			if conn, err := listener.AcceptUnix(); err != nil {
				errorUnableToAcceptSocketConnection()
				time.Sleep(500 * time.Millisecond)
			} else {
				connections <- unixsocket.NewUsock(conn)
			}
		}
	}()

	for {
		select {
		case <-quit:
			quit <- true
			return
		case conn := <-connections:
			go handleClientConnection(tree, conn)
		}
	}
}
Exemple #8
0
func daemonIpc(done <-chan struct{}) {
	if _, err := os.Stat(Config.ClueGetter.IPC_Socket); !os.IsNotExist(err) {
		err = os.Remove(Config.ClueGetter.IPC_Socket)
		if err != nil {
			Log.Fatal(fmt.Sprintf("IPC Socket %s already exists and could not be removed: %s",
				Config.ClueGetter.IPC_Socket, err.Error()))
		}
	}

	l, err := net.ListenUnix("unix", &net.UnixAddr{Config.ClueGetter.IPC_Socket, "unix"})
	if err != nil {
		Log.Fatal(err)
	}

	go func() {
		<-done
		l.Close() // Also removes socket file
	}()

	for {
		conn, err := l.AcceptUnix()
		if err != nil {
			_, open := <-done
			if !open {
				Log.Info("IPC Socket shutting down")
				break
			}
			Log.Fatal("Critical error on IPC Socket: %s", err)
		}

		go daemonIpcHandleConn(conn)
	}
}
Exemple #9
0
// ListenUnix announces on the local network address laddr. The network net
// must be a: "unix" or "unixpacket". It returns an inherited net.Listener for
// the matching network and address, or creates a new one using net.ListenUnix.
func (n *Net) ListenUnix(nett string, laddr *net.UnixAddr) (*net.UnixListener, error) {
	if err := n.inherit(); err != nil {
		return nil, err
	}

	n.mutex.Lock()
	defer n.mutex.Unlock()

	// look for an inherited listener
	for i, l := range n.inherited {
		if l == nil { // we nil used inherited listeners
			continue
		}
		if isSameAddr(l.Addr(), laddr) {
			n.inherited[i] = nil
			n.active = append(n.active, l)
			return l.(*net.UnixListener), nil
		}
	}

	// make a fresh listener
	l, err := net.ListenUnix(nett, laddr)
	if err != nil {
		return nil, err
	}
	n.active = append(n.active, l)
	return l, nil
}
Exemple #10
0
// unixListener returns the listener used for registrations (over unix sock)
func unixListener() (net.Listener, error) {
	s := os.Getenv("LISTEN_FDS")
	if s != "" {
		// socket activated
		lfds, err := strconv.ParseInt(s, 10, 16)
		if err != nil {
			return nil, errwrap.Wrap(errors.New("error parsing LISTEN_FDS env var"), err)
		}
		if lfds < 1 {
			return nil, fmt.Errorf("LISTEN_FDS < 1")
		}

		return net.FileListener(os.NewFile(uintptr(listenFdsStart), "listen"))
	} else {
		dir := filepath.Dir(common.MetadataServiceRegSock)
		err := os.MkdirAll(dir, 0755)
		if err != nil {
			return nil, errwrap.Wrap(fmt.Errorf("failed to create %v", dir), err)
		}

		return net.ListenUnix("unix", &net.UnixAddr{
			Net:  "unix",
			Name: common.MetadataServiceRegSock,
		})
	}
}
Exemple #11
0
func main() {
	flag.Parse()

	// Create unix socket
	addr, err := net.ResolveUnixAddr("unix", *socketPath)
	if err != nil {
		log.Fatal(err)
	}
	l, err := net.ListenUnix("unix", addr)
	if err != nil {
		log.Fatal(err)
	}

	// Create server that listens on the socket
	s := agent.NewServer(l, &accpeter{})

	// Setup signal handler to stop Server on various signals
	s.StopOnSignals(os.Interrupt, syscall.SIGTERM)

	log.Println("Server listening on", addr.String())
	err = s.Serve()
	if err != nil {
		log.Fatal(err)
	}
	log.Println("Server stopped")
}
Exemple #12
0
// ListenUnix announces on the local network address laddr. The network net
// must be a: "unix" or "unixpacket". It returns an inherited net.Listener for
// the matching network and address, or creates a new one using net.ListenUnix.
func (n *nimbleNet) ListenUnix(nett string, laddr *net.UnixAddr) (*net.UnixListener, error) {
	if err := n.getInheritedListeners(); err != nil {
		return nil, iodine.New(err, nil)
	}

	n.mutex.Lock()
	defer n.mutex.Unlock()

	// look for an inherited listener
	for i, l := range n.inheritedListeners {
		if l == nil { // we nil used inherited listeners
			continue
		}
		equal := nimbleAddr{l.Addr()}.IsEqual(laddr)
		if equal {
			n.inheritedListeners[i] = nil
			n.activeListeners = append(n.activeListeners, l)
			return l.(*net.UnixListener), nil
		}
	}

	// make a fresh listener
	l, err := net.ListenUnix(nett, laddr)
	if err != nil {
		return nil, iodine.New(err, nil)
	}
	n.activeListeners = append(n.activeListeners, l)
	return l, nil
}
Exemple #13
0
Fichier : ipc.go Projet : drptbl/oz
func NewServer(address string, factory MsgFactory, log *logging.Logger, handlers ...interface{}) (*MsgServer, error) {
	md, err := createDispatcher(log, handlers...)
	if err != nil {
		return nil, err
	}

	listener, err := net.ListenUnix("unix", &net.UnixAddr{address, "unix"})
	if err != nil {
		md.close()
		return nil, err
	}
	if err := setPassCred(listener); err != nil {
		return nil, errors.New("Failed to set SO_PASSCRED on listening socket: " + err.Error())
	}
	done := make(chan bool)
	idGen := newIdGen(done)
	return &MsgServer{
		log:      log,
		disp:     md,
		factory:  factory,
		listener: listener,
		done:     done,
		idGen:    idGen,
	}, nil
}
Exemple #14
0
// StartUnixListener starts up a unix domain socket listener for reconnects to
// be sent through
func (irc *Bot) StartUnixListener() {
	unaddr, err := net.ResolveUnixAddr("unix", irc.unixastr)
	if err != nil {
		panic(err)
	}
	list, err := net.ListenUnix("unix", unaddr)
	if err != nil {
		panic(err)
	}

	irc.unixlist = list
	con, err := list.AcceptUnix()
	if err != nil {
		fmt.Println("unix listener error: ", err)
		return
	}
	list.Close()

	fi, err := irc.con.(*net.TCPConn).File()
	if err != nil {
		panic(err)
	}

	err = sendfd.SendFD(con, fi)
	if err != nil {
		panic(err)
	}

	select {
	case <-irc.Incoming:
	default:
		close(irc.Incoming)
	}
	close(irc.outgoing)
}
func startIpc(cfg IpcConfig, codec codec.Codec, api shared.EthereumApi) error {
	os.Remove(cfg.Endpoint) // in case it still exists from a previous run

	l, err := net.ListenUnix("unix", &net.UnixAddr{Name: cfg.Endpoint, Net: "unix"})
	if err != nil {
		return err
	}
	os.Chmod(cfg.Endpoint, 0600)

	go func() {
		for {
			conn, err := l.AcceptUnix()
			if err != nil {
				glog.V(logger.Error).Infof("Error accepting ipc connection - %v\n", err)
				continue
			}

			id := newIpcConnId()
			glog.V(logger.Debug).Infof("New IPC connection with id %06d started\n", id)

			go handle(id, conn, api, codec)
		}

		os.Remove(cfg.Endpoint)
	}()

	glog.V(logger.Info).Infof("IPC service started (%s)\n", cfg.Endpoint)

	return nil
}
// Open opens the transport.
func (c Config) Open() (transports.Transport, error) {
	if c.Name == "" {
		c.Name = path.Join(os.TempDir(), "telehash-"+randomString(8)+".sock")
	}

	if c.Mode == 0 {
		c.Mode = 0700
	}
	c.Mode &= os.ModePerm
	c.Mode |= os.ModeSocket

	laddr, err := net.ResolveUnixAddr("unix", c.Name)
	if err != nil {
		return nil, err
	}

	listener, err := net.ListenUnix("unix", laddr)
	if err != nil {
		return nil, err
	}

	err = os.Chmod(laddr.Name, c.Mode)
	if err != nil {
		listener.Close()
		os.Remove(laddr.Name)
		return nil, err
	}

	return &transport{(*unixAddr)(laddr), listener}, nil
}
Exemple #17
0
// InitPlugin registers REST endpoints to handle requests from Mesos CNI plugins
func InitPlugin(netPlugin *plugin.NetPlugin) {

	cniLog = log.WithField("plugin", "mesos")
	cniLog.Infof("starting Mesos CNI server")
	router := mux.NewRouter()

	// register handlers for cni plugin
	subRtr := router.Headers("Content-Type", "application/json").Subrouter()
	subRtr.HandleFunc(cniapi.MesosNwIntfAdd, httpWrapper(mesosNwIntfAdd)).Methods("POST")
	subRtr.HandleFunc(cniapi.MesosNwIntfDel, httpWrapper(mesosNwIntfDel)).Methods("POST")
	router.HandleFunc("/{*}", unknownReq)

	sockFile := cniapi.ContivMesosSocket
	os.Remove(sockFile)
	os.MkdirAll(cniapi.PluginPath, 0700)

	cniDriverInit(netPlugin)

	go func() {
		lsock, err := net.ListenUnix("unix", &net.UnixAddr{Name: sockFile, Net: "unix"})
		if err != nil {
			cniLog.Errorf("Mesos CNI server failed:  %s", err)
			return
		}

		cniLog.Infof("Mesos CNI server is listening on %s", sockFile)
		http.Serve(lsock, router)
		lsock.Close()
		cniLog.Infof("Mesos CNI server socket %s closed ", sockFile)
	}()
}
Exemple #18
0
func serveFpr(addr string, s *siegfried.Siegfried) {
	// remove the socket file if it exists
	if _, err := os.Stat(addr); err == nil {
		os.Remove(addr)
	}
	uaddr, err := net.ResolveUnixAddr("unix", addr)
	if err != nil {
		log.Fatalf("FPR error: failed to get address: %v", err)
	}
	lis, err := net.ListenUnix("unix", uaddr)
	if err != nil {
		log.Fatalf("FPR error: failed to listen: %v", err)
	}
	buf := make([]byte, 4024)
	for {
		conn, err := lis.Accept()
		if err != nil {
			log.Fatalf("FPR error: bad connection: %v", err)
		}
		l, err := conn.Read(buf)
		if err != nil {
			conn.Write([]byte("error reading from connection: " + err.Error()))
		}
		conn.Write(fpridentify(s, string(buf[:l])))
		conn.Close()
	}
}
// NewUserNetwork returns a Network implementation using the QEMU user-space
// network stack. This doesn't provide the same level of isolation, but the
// meta-data service should be sufficiently isolated.
func NewUserNetwork(socketFolder string) (*UserNetwork, error) {
	n := &UserNetwork{
		socketFile: filepath.Join(socketFolder, "meta-"+slugid.Nice()+".sock"),
	}
	n.server = &graceful.Server{
		Timeout: 35 * time.Second,
		Server: &http.Server{
			Addr:    metaDataIP + ":80",
			Handler: http.HandlerFunc(n.dispatchRequest),
		},
		NoSignalHandling: true,
	}

	// Start listening (we handle listener error as a special thing)
	listener, err := net.ListenUnix("unix", &net.UnixAddr{
		Name: n.socketFile,
		Net:  "unix",
	})
	if err != nil {
		return nil, fmt.Errorf("Failed to listen on %s error: %s", n.socketFile, err)
	}

	// Start serving
	serverDone := make(chan struct{})
	n.serverDone = serverDone
	go func(n *UserNetwork, done chan<- struct{}) {
		err := n.server.Serve(listener)
		close(done)
		if err != nil {
			panic(fmt.Sprint("Fatal: meta-data service listener failed, error: ", err))
		}
	}(n, serverDone)

	return n, nil
}
Exemple #20
0
func main() {
	if len(os.Args) != 2 {
		println("need one argument")
		return
	}
	ua, err := net.ResolveUnixAddr("unix", os.Args[1])
	if err != nil {
		println("resolve unix", err.Error())
		return
	}
	ul, err := net.ListenUnix("unix", ua)
	if err != nil {
		println("listen unix", err.Error())
		return
	}
	//for {
	uc, err := ul.AcceptUnix()
	if err != nil {
		println("accept", err.Error())
		panic("accept")
	}
	go func() {
		r := rand.Int()
		for {
			uc.Write([]byte(fmt.Sprintf("%d\n", r)))
			time.Sleep(time.Second)
		}
	}()
	//}
	ul.Close()
	<-(chan int)(nil)
}
Exemple #21
0
func (p *Proxy) Listen() error {
	err := p.cleanup()
	if err != nil {
		return err
	}

	addr, err := net.ResolveUnixAddr("unix", "/var/run/docker.sock")
	if err != nil {
		return err
	}

	raw, err := net.ListenUnix("unix", addr)
	if err != nil {
		return err
	}

	listener := &stoppableListener{
		UnixListener: raw,
		done:         p.done,
	}

	err = os.Chmod("/var/run/docker.sock", 0777)
	if err != nil {
		return err
	}

	server := http.Server{
		Handler: http.HandlerFunc(p.handler),
	}

	return server.Serve(listener)
}
Exemple #22
0
// Create socket and channel for nagios notify
func GetNotifyChan(nagiosSocketFileName string) <-chan io.ReadCloser {
	notifyesChan := make(chan io.ReadCloser, 100)
	// create listener
	go func() {
		// remove socket
		os.Remove(nagiosSocketFileName)
		// create socket
		listen, err := net.ListenUnix("unix", &net.UnixAddr{nagiosSocketFileName, "unix"})
		if err := os.Chmod(nagiosSocketFileName, 0777); err != nil {
			log.Panic(err)
		}
		if err != nil {
			log.Panic(err)
		}
		// remove socket on normal halt
		defer os.Remove(nagiosSocketFileName)
		// accept connection and send it in channel
		for {
			conn, err := listen.AcceptUnix()
			if err != nil {
				log.Panic(err)
			}
			notifyesChan <- conn
		}
	}()
	return notifyesChan
}
Exemple #23
0
// ListenUnix announces on the local network address laddr. The network net
// must be a: "unix" or "unixpacket". It returns an inherited net.Listener for
// the matching network and address, or creates a new one using net.ListenUnix.
func (n *minNet) ListenUnix(nett string, laddr *net.UnixAddr) (net.Listener, *probe.Error) {
	if err := n.getInheritedListeners(); err != nil {
		return nil, err.Trace()
	}

	n.mutex.Lock()
	defer n.mutex.Unlock()

	// look for an inherited listener
	for i, l := range n.inheritedListeners {
		if l == nil { // we nil used inherited listeners
			continue
		}
		equal := minAddr{l.Addr()}.IsEqual(laddr)
		if equal {
			n.inheritedListeners[i] = nil
			n.activeListeners = append(n.activeListeners, l)
			return l.(*net.UnixListener), nil
		}
	}

	// make a fresh listener
	l, err := net.ListenUnix(nett, laddr)
	if err != nil {
		return nil, probe.NewError(err)
	}
	n.activeListeners = append(n.activeListeners, rateLimitedListener(l, n.connLimit))
	return l, nil
}
Exemple #24
0
// setupTestServer creates a listener for the rest requests.
func setupTestServer() {

	router := mux.NewRouter()

	// register handlers for cni
	t := router.Headers("Content-Type", "application/json").Methods("POST").Subrouter()
	t.HandleFunc(cniapi.EPAddURL, httpWrapper(stubAddPod))
	t.HandleFunc(cniapi.EPDelURL, httpWrapper(stubDeletePod))

	driverPath := cniapi.ContivCniSocket
	os.Remove(driverPath)
	os.MkdirAll(cniapi.PluginPath, 0700)

	go func() {
		l, err := net.ListenUnix("unix", &net.UnixAddr{Name: driverPath, Net: "unix"})
		if err != nil {
			panic(err)
		}

		logger.Infof("k8s test plugin listening on %s", driverPath)
		http.Serve(l, router)
		l.Close()
		logger.Infof("k8s test plugin closing %s", driverPath)
	}()

}
Exemple #25
0
func (t *UnixInput) Init(config interface{}) error {
	var err error
	t.config = config.(*UnixInputConfig)
	if !strings.HasPrefix(t.config.Address, "@") {
		return fmt.Errorf("only ephemeral sockets supported - prefix your path with '@'")
	}
	address, err := net.ResolveUnixAddr("unix", t.config.Address)
	if err != nil {
		return fmt.Errorf("ResolveUnixAddress failed: %s\n", err.Error())
	}
	t.listener, err = net.ListenUnix("unix", address)
	if err != nil {
		return fmt.Errorf("ListenUnix failed: %s\n", err.Error())
	}
	// We're already listening, make sure we clean up if init fails later on.
	closeIt := true
	defer func() {
		if closeIt {
			t.listener.Close()
		}
	}()
	t.stopChan = make(chan bool)
	closeIt = false
	return nil
}
Exemple #26
0
func main() {
	e := New()
	sckt, err := net.ListenUnix("unix", &net.UnixAddr{socketPath, "unix"})
	if err != nil {
		panic(err)
	}
	defer os.Remove(socketPath)

	defer e.Conn().Close()

	l := e.Loop(sckt)

	err = e.LoadConfig(ConfigPath)

	if err != nil {
		e.Println(err.Error())
	}

EVT:
	for {
		select {
		case <-l.pre:
			<-l.post
		case msg := <-l.comm:
			if verbose {
				e.Println(msg)
			}
		case <-l.quit:
			break EVT
		}
	}

	e.Println("EXITING......\n")
}
Exemple #27
0
// createListener creates a new net.UnixListener
func (ul *UnixListener) createListener() error {
	// create directory structure if it does not exist yet
	directory := filepath.Dir(ul.Addr())
	// TODO: Decide on permissions
	if err := os.MkdirAll(directory, os.ModePerm); err != nil {
		log.WithFields(log.Fields{
			"directory": directory,
			"perm":      os.ModePerm,
			"error":     err,
		}).Error("failed to create directory for socket")
		return err
	}

	listener, err := net.ListenUnix("unix", ul.addr)
	if err != nil {
		log.WithFields(log.Fields{
			"addr":  ul.Addr(),
			"error": err,
		}).Error("failed to create listener")
		return err
	}

	ul.listener = listener
	return nil
}
Exemple #28
0
// NewWorker starts an http server listening on an abstract domain socket
// which will be created with the specified name.
func NewWorker(config Config) (worker.Worker, error) {
	if err := config.Validate(); err != nil {
		return nil, errors.Trace(err)
	}
	if runtime.GOOS != "linux" {
		return nil, errors.NotSupportedf("os %q", runtime.GOOS)
	}

	path := "@" + config.SocketName
	addr, err := net.ResolveUnixAddr("unix", path)
	if err != nil {
		return nil, errors.Annotate(err, "unable to resolve unix socket")
	}

	l, err := net.ListenUnix("unix", addr)
	if err != nil {
		return nil, errors.Annotate(err, "unable to listen on unix socket")
	}
	logger.Debugf("introspection worker listening on %q", path)

	w := &socketListener{
		listener: l,
		reporter: config.Reporter,
		done:     make(chan struct{}),
	}
	go w.serve()
	go w.run()
	return w, nil
}
Exemple #29
0
func (s *Server) Start() error {
	c, _ := projects.ConfigDir()
	socketpath := filepath.Join(c, "projects.socket")

	addr, err := net.ResolveUnixAddr("unix", socketpath)

	if err != nil {
		return err
	}

	listener, e := net.ListenUnix("unix", addr)
	if e != nil {
		return e
	}

	var opts []grpc.ServerOption

	grpcServer := grpc.NewServer(opts...)
	messages.RegisterProjectsServer(grpcServer, &projectServer{s.core})
	messages.RegisterResourcesServer(grpcServer, &resourcesServer{s.core})
	messages.RegisterEventsServer(grpcServer, &eventsServer{s.core})
	//s.core.Log.Infof("project daemon started and listening on %s", socketpath)
	s.server = grpcServer
	s.listener = listener

	s.tomb.Go(func() error { return grpcServer.Serve(listener) })
	return nil
}
Exemple #30
0
func (srv *Server) listenUnix(addr string) (listener, error) {
	laddr, err := net.ResolveUnixAddr("unix", addr)
	if err != nil {
		return nil, err
	}
	return net.ListenUnix("unix", laddr)
}