1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
package homematic
import (
"context"
"fmt"
"io"
"net"
"net/http"
"strconv"
"github.com/beevik/etree"
)
type Requester struct {
addr string
}
func NewRequester(addr string) Requester {
return Requester{
addr: addr,
}
}
func (req Requester) Request(request etree.Document) (*etree.Document, error) {
r, w := io.Pipe()
go func() {
request.Indent(2)
_, err := request.WriteTo(w)
_ = w.CloseWithError(err)
}()
response, err := http.Post(req.addr, "application/xml", r)
if err != nil {
return nil, fmt.Errorf("HTTP POST failed: %w", err)
}
doc := etree.NewDocument()
_, err = doc.ReadFrom(response.Body)
if err != nil {
return nil, fmt.Errorf("Failed to decode response: %w", err)
}
return doc, nil
}
func (req Requester) ListDevices() (Devices, error) {
var devices Devices
request := etree.NewDocument()
request.CreateProcInst("xml", `version="1.0" encoding="UTF-8"`)
call := request.CreateElement("methodCall")
call.CreateElement("methodName").CreateText("listDevices")
call.CreateElement("params")
response, err := req.Request(*request)
if err != nil {
return devices, fmt.Errorf("Could not request listDevices: %w", err)
}
for _, dev := range response.FindElements("/methodResponse/params/param/value/array/data/value/struct") {
doc := etree.NewDocumentWithRoot(dev.Copy())
device := Device{}
device.LoadXML(doc)
devices = append(devices, device)
}
return devices, nil
}
func (req Requester) GetValue(address string) (bool, error) {
request := etree.NewDocument()
request.CreateProcInst("xml", `version="1.0" encoding="UTF-8"`)
methodCall := request.CreateElement("methodCall")
methodName := methodCall.CreateElement("methodName")
methodName.CreateText("getValue")
params := methodCall.CreateElement("params")
params.CreateElement("param").CreateElement("value").CreateElement("string").CreateText(address)
params.CreateElement("param").CreateElement("value").CreateElement("string").CreateText("STATE")
response, err := req.Request(*request)
if err != nil {
return false, fmt.Errorf("Could not request getValue: %w", err)
}
value := response.FindElement("/methodResponse/params/param/value/i4")
if value == nil {
return false, fmt.Errorf("Could not get value from response")
}
integer, err := strconv.Atoi(value.Text())
if err != nil {
return false, fmt.Errorf("Could not convert state value to int: %w", err)
}
switch integer {
case 0:
return false, nil
case 1:
return true, nil
default:
return false, fmt.Errorf("Cannot cast integer %d to bool", integer)
}
}
type Responder struct {
ip net.IP
port int
handler func(http.ResponseWriter, *http.Request)
}
func NewResponder(ip net.IP, port int, handler func(http.ResponseWriter, *http.Request)) Responder {
return Responder{
ip: ip,
port: port,
handler: handler,
}
}
func (resp Responder) Start() (context.CancelFunc, int, error) {
listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", resp.ip, resp.port))
if err != nil {
return nil, 0, fmt.Errorf("Could not listen: %w", err)
}
port := listener.Addr().(*net.TCPAddr).Port
m := http.NewServeMux()
m.HandleFunc("/", resp.handler)
s := http.Server{
Handler: m,
}
go s.Serve(listener)
ctx, cancel := context.WithCancel(context.Background())
go func() {
<-ctx.Done()
s.Close()
listener.Close()
}()
return cancel, port, nil
}
|
