func getPorts() ([]OsSerialPort, error) {
resolver, err := bonjour.NewResolver(nil)
if err != nil {
log.Println("Failed to initialize resolver:", err.Error())
return nil, err
}
results := make(chan *bonjour.ServiceEntry)
timeout := make(chan bool, 1)
go func(exitCh chan<- bool) {
time.Sleep(timeoutConst * time.Second)
exitCh <- true
close(results)
}(resolver.Exit)
arrPorts := []OsSerialPort{}
go func(results chan *bonjour.ServiceEntry, exitCh chan<- bool) {
for e := range results {
arrPorts = append(arrPorts, OsSerialPort{Name: e.AddrIPv4.String(), IdProduct: e.Instance, IdVendor: strings.Join(e.Text[:], " "), NetworkPort: true})
}
timeout <- true
}(results, resolver.Exit)
err = resolver.Browse("_arduino._tcp", "", results)
if err != nil {
log.Println("Failed to browse:", err.Error())
return nil, err
}
// wait for some kind of timeout and return arrPorts
select {
case <-timeout:
return arrPorts, nil
}
}
func main() {
resolver, err := bonjour.NewResolver(nil)
if err != nil {
log.Println("Failed to initialize resolver:", err.Error())
os.Exit(1)
}
results := make(chan *bonjour.ServiceEntry)
t1 := time.Now()
go func(results chan *bonjour.ServiceEntry, exitCh chan<- bool) {
for e := range results {
log.Printf("%s", e.Instance)
fmt.Printf("duration: %s\n", time.Now().Sub(t1)/time.Millisecond)
exitCh <- true
time.Sleep(1e9)
os.Exit(0)
}
}(results, resolver.Exit)
err = resolver.Browse("_ssh._tcp", "local.", results)
if err != nil {
log.Println("Failed to browse:", err.Error())
}
select {}
}
func main() {
resolver, err := bonjour.NewResolver(nil)
if err != nil {
log.Println("Failed to initialize resolver:", err.Error())
os.Exit(1)
}
results := make(chan *bonjour.ServiceEntry)
go func(results chan *bonjour.ServiceEntry, exitCh chan<- bool) {
for e := range results {
log.Printf("%s", e.Instance)
exitCh <- true
time.Sleep(1e9)
os.Exit(0)
}
}(results, resolver.Exit)
err = resolver.Browse("_chromecast._tcp", "local.", results)
if err != nil {
log.Println("Failed to browse:", err.Error())
}
select {}
}
func getPorts() ([]OsSerialPort, error) {
resolver, err := bonjour.NewResolver(nil)
if err != nil {
log.Println("Failed to initialize resolver:", err.Error())
return nil, err
}
results := make(chan *bonjour.ServiceEntry)
timeout := make(chan bool, 1)
go func(exitCh chan<- bool) {
time.Sleep(timeoutConst * time.Second)
exitCh <- true
close(results)
}(resolver.Exit)
arrPorts := []OsSerialPort{}
go func(results chan *bonjour.ServiceEntry, exitCh chan<- bool) {
for e := range results {
var boardInfosSlice []string
for _, element := range e.Text {
if strings.Contains(element, "board=yun") {
boardInfosSlice = append(boardInfosSlice, "arduino:avr:yun")
}
}
arrPorts = append(arrPorts, OsSerialPort{Name: e.AddrIPv4.String(), FriendlyName: e.Instance, NetworkPort: true, RelatedNames: boardInfosSlice})
}
timeout <- true
}(results, resolver.Exit)
err = resolver.Browse("_arduino._tcp", "", results)
if err != nil {
log.Println("Failed to browse:", err.Error())
return nil, err
}
// wait for some kind of timeout and return arrPorts
select {
case <-timeout:
return arrPorts, nil
}
}
// mainLoop initiates all ports and handles the traffic
func mainLoop() {
openPorts()
defer closePorts()
waitCh := make(chan bool)
go func() {
for {
v := <-outCh
if v && waitCh != nil {
waitCh <- true
}
if !v {
log.Println("OUT port is closed. Interrupting execution")
exitCh <- syscall.SIGTERM
break
}
}
}()
log.Println("Waiting for port connections to establish... ")
select {
case <-waitCh:
log.Println("Output port connected")
waitCh = nil
case <-time.Tick(30 * time.Second):
log.Println("Timeout: port connections were not established within provided interval")
exitCh <- syscall.SIGTERM
return
}
log.Println("Waiting for configuration IP...")
var options *bonjour.ServiceRecord
for {
ip, err := inPort.RecvMessageBytes(0)
if err != nil {
continue
}
if !runtime.IsValidIP(ip) || !runtime.IsPacket(ip) {
continue
}
if err = json.Unmarshal(ip[1], &options); err != nil {
log.Println("Error decoding options:", err.Error())
continue
}
inPort.Close()
break
}
resolver, err = bonjour.NewResolver(nil)
utils.AssertError(err)
entries := make(chan *bonjour.ServiceEntry)
err = resolver.Browse(options.Service, options.Domain, entries)
utils.AssertError(err)
log.Println("Started...")
for e := range entries {
data, err := json.Marshal(e)
if err != nil {
log.Println("Error encoding entry:", err.Error())
continue
}
outPort.SendMessage(runtime.NewPacket(data))
}
}