Ejemplo n.º 1
0
// Deregister all previously allocated services.
func ServiceDeregister() {
	for _, ref := range services {
		C.DNSServiceRefDeallocate(ref)
	}
}
Ejemplo n.º 2
0
func main() {
	counterChannel := make(chan int)

	go func() {
		counter := 0

		for {
			<-time.After(1 * time.Second)
			fmt.Println("Counter at", counter)
			counterChannel <- counter
			counter++
		}
	}()

	receivers := make([]chan int, 0)
	lock := new(sync.Mutex)

	go func() {
		for {
			counter := <-counterChannel

			lock.Lock()
			for _, receiver := range receivers {
				fmt.Println("Sending to receiver")
				receiver <- counter
			}
			lock.Unlock()
		}
	}()

	websocketHandler := func(ws *websocket.Conn) {
		fmt.Println("Received websocket connection")

		receiver := make(chan int)
		lock.Lock()
		receivers = append(receivers, receiver)
		lock.Unlock()

		for {
			value := <-receiver
			websocket.JSON.Send(ws, value)
		}
	}

	http.Handle("/ws", websocket.Handler(websocketHandler))

	var listener net.Listener
	var err error

	if listener, err = net.Listen("tcp", "127.0.0.1:0"); err != nil {
		fmt.Println("Listen failed", err)
		return
	}

	var tcpAddr *net.TCPAddr
	if tcpAddr, err = net.ResolveTCPAddr("tcp", listener.Addr().String()); err != nil {
		fmt.Println("Couldn't resolve TCP address", err)
		return
	}

	fmt.Println("Listening on", fmt.Sprintf("http://localhost:%d", tcpAddr.Port))

	// network order
	port := (tcpAddr.Port&0xff)<<8 | (tcpAddr.Port&0xff00)>>8

	// Interface -1 means localhost
	var iface uint32 = 0
	iface -= 1

	serviceName := C.CString("woven")
	serviceType := C.CString("_woven._tcp")
	serviceDomain := C.CString("local.")

	var dnsRef C.DNSServiceRef
	if dnsErr := C.DNSServiceRegister(&dnsRef, 0,
		C.uint32_t(iface),
		serviceName,
		serviceType,
		serviceDomain, nil,
		C.uint16_t(port), 0, nil,
		nil, nil); dnsErr != 0 {
		fmt.Println("DNSServiceRegister failed", dnsErr)
		return
	}

	cleanup := func() {
		if dnsRef != nil {
			C.DNSServiceRefDeallocate(dnsRef)
			dnsRef = nil

			C.free(unsafe.Pointer(serviceDomain))
			C.free(unsafe.Pointer(serviceType))
			C.free(unsafe.Pointer(serviceName))

			dnsRef = nil
		}
	}

	defer cleanup()

	signalChannel := make(chan os.Signal)
	signal.Notify(signalChannel, syscall.SIGTERM)
	signal.Notify(signalChannel, os.Interrupt)
	go func() {
		<-signalChannel
		cleanup()
		os.Exit(1)
	}()

	if err = http.Serve(listener, nil); err != nil {
		fmt.Println("Serve failed", err)
		return
	}
}
Ejemplo n.º 3
0
func (ctx *Context) Release() {
	C.DNSServiceRefDeallocate(*(ctx.ref))
	deleteCallback(ctx.callbackIndex)
}