input_linux.go 2.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101
  1. package door
  2. import (
  3. "log"
  4. "sync/atomic"
  5. "syscall"
  6. )
  7. func Reader(handle int, d *Door) {
  8. // I don't need the select anymore. Let the read block.
  9. // defer d.wg.Done()
  10. defer func() {
  11. log.Printf("~Reader2\n")
  12. if d.ReaderCanClose {
  13. d.wg.Done()
  14. }
  15. }()
  16. defer func() {
  17. if err := recover(); err != nil {
  18. log.Printf("Reader: %#v\n", err)
  19. }
  20. }()
  21. var buffer []byte = make([]byte, 1)
  22. for {
  23. var read int
  24. var err error
  25. read, err = syscall.Read(handle, buffer)
  26. if err != nil {
  27. log.Printf("Reader ERR: %#v\n", err)
  28. close(d.readerChannel)
  29. if !d.Disconnect() {
  30. log.Println("Reader close writerChannel")
  31. // d.Disconnected = true
  32. atomic.StoreInt32(&d.Disconnected, 1)
  33. d.closeChannel <- struct{}{}
  34. // close(d.writerChannel)
  35. return
  36. }
  37. // break
  38. return
  39. }
  40. if read == 1 {
  41. d.readerChannel <- buffer[0]
  42. } else {
  43. log.Printf("READ FAILED %d\n", read)
  44. close(d.readerChannel)
  45. if !d.Disconnect() {
  46. log.Println("Reader close writerChannel")
  47. // d.Disconnected = true
  48. atomic.StoreInt32(&d.Disconnected, 1)
  49. d.closeChannel <- struct{}{}
  50. //close(d.writerChannel)
  51. return
  52. }
  53. // break
  54. return
  55. }
  56. }
  57. }
  58. /*
  59. func Reader(handle int, readerChannel *chan byte) {
  60. // I don't need the select anymore. Let the read block.
  61. defer func() {
  62. if err := recover(); err != nil {
  63. log.Printf("Reader: %#v\n", err)
  64. }
  65. }()
  66. buffer := make([]byte, 1)
  67. for {
  68. // blocking read in go routine
  69. // why doesn't this end when I close the handle?
  70. read, err := syscall.Read(handle, buffer)
  71. if err != nil {
  72. log.Printf("Reader ERR: %#v\n", err)
  73. close(*readerChannel)
  74. break
  75. }
  76. if read == 1 {
  77. *readerChannel <- buffer[0]
  78. } else {
  79. log.Printf("READ FAILED %d\n", read)
  80. close(*readerChannel)
  81. break
  82. }
  83. }
  84. }
  85. // This doesn't work. Closing the handle does not unblock the syscall.Read above.
  86. func CloseReader(handle int) {
  87. defer func() {
  88. if err := recover(); err != nil {
  89. log.Printf("CloseReader: %#v\n", err)
  90. }
  91. }()
  92. syscall.Close(handle)
  93. }
  94. */