Skip to content

Commit 87586b4

Browse files
prometherionprometherion
committed
MINOR: handlers for http-after-response keyword
1 parent e0ce329 commit 87586b4

2 files changed

Lines changed: 223 additions & 0 deletions

File tree

‎configure_data_plane.go‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -407,6 +407,13 @@ func configureAPI(api *operations.DataPlaneAPI) http.Handler {
407407
api.HTTPRequestRuleGetHTTPRequestRulesHandler = &handlers.GetHTTPRequestRulesHandlerImpl{Client: client}
408408
api.HTTPRequestRuleReplaceHTTPRequestRuleHandler = &handlers.ReplaceHTTPRequestRuleHandlerImpl{Client: client, ReloadAgent: ra}
409409

410+
// setup http after response rule handlers
411+
api.HTTPAfterResponseRuleCreateHTTPAfterResponseRuleHandler = &handlers.CreateHTTPAfterResponseRuleHandlerImpl{Client: client, ReloadAgent: ra}
412+
api.HTTPAfterResponseRuleDeleteHTTPAfterResponseRuleHandler = &handlers.DeleteHTTPAfterResponseRuleHandlerImpl{Client: client, ReloadAgent: ra}
413+
api.HTTPAfterResponseRuleGetHTTPAfterResponseRuleHandler = &handlers.GetHTTPAfterResponseRuleHandlerImpl{Client: client}
414+
api.HTTPAfterResponseRuleGetHTTPAfterResponseRulesHandler = &handlers.GetHTTPAfterResponseRulesHandlerImpl{Client: client}
415+
api.HTTPAfterResponseRuleReplaceHTTPAfterResponseRuleHandler = &handlers.ReplaceHTTPAfterResponseRuleHandlerImpl{Client: client, ReloadAgent: ra}
416+
410417
// setup http response rule handlers
411418
api.HTTPResponseRuleCreateHTTPResponseRuleHandler = &handlers.CreateHTTPResponseRuleHandlerImpl{Client: client, ReloadAgent: ra}
412419
api.HTTPResponseRuleDeleteHTTPResponseRuleHandler = &handlers.DeleteHTTPResponseRuleHandlerImpl{Client: client, ReloadAgent: ra}

‎handlers/http_after_response_rule.go‎

Lines changed: 216 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,216 @@
1+
package handlers
2+
3+
import (
4+
"github.com/go-openapi/runtime/middleware"
5+
client_native "github.com/haproxytech/client-native/v3"
6+
"github.com/haproxytech/client-native/v3/models"
7+
8+
"github.com/haproxytech/dataplaneapi/haproxy"
9+
"github.com/haproxytech/dataplaneapi/misc"
10+
"github.com/haproxytech/dataplaneapi/operations/http_after_response_rule"
11+
)
12+
13+
type CreateHTTPAfterResponseRuleHandlerImpl struct {
14+
Client client_native.HAProxyClient
15+
ReloadAgent *haproxy.ReloadAgent
16+
}
17+
18+
func (c CreateHTTPAfterResponseRuleHandlerImpl) Handle(params http_after_response_rule.CreateHTTPAfterResponseRuleParams, _ interface{}) middleware.Responder {
19+
t, v := "", int64(0)
20+
21+
if params.TransactionID != nil {
22+
t = *params.TransactionID
23+
}
24+
25+
if params.Version != nil {
26+
v = *params.Version
27+
}
28+
29+
if t != "" && *params.ForceReload {
30+
e := &models.Error{
31+
Message: misc.StringP("Both force_reload and transaction specified, specify only one"),
32+
Code: misc.Int64P(int(misc.ErrHTTPBadRequest)),
33+
}
34+
return http_after_response_rule.NewCreateHTTPAfterResponseRuleDefault(int(*e.Code)).WithPayload(e)
35+
}
36+
37+
configuration, err := c.Client.Configuration()
38+
if err != nil {
39+
e := misc.HandleError(err)
40+
return http_after_response_rule.NewCreateHTTPAfterResponseRuleDefault(int(*e.Code)).WithPayload(e)
41+
}
42+
43+
if err = configuration.CreateHTTPAfterResponseRule(params.ParentType, params.ParentName, params.Data, t, v); err != nil {
44+
e := misc.HandleError(err)
45+
return http_after_response_rule.NewCreateHTTPAfterResponseRuleDefault(int(*e.Code)).WithPayload(e)
46+
}
47+
48+
if params.TransactionID == nil {
49+
if *params.ForceReload {
50+
if err = c.ReloadAgent.ForceReload(); err != nil {
51+
e := misc.HandleError(err)
52+
return http_after_response_rule.NewCreateHTTPAfterResponseRuleDefault(int(*e.Code)).WithPayload(e)
53+
}
54+
55+
return http_after_response_rule.NewCreateHTTPAfterResponseRuleCreated().WithPayload(params.Data)
56+
}
57+
58+
return http_after_response_rule.NewCreateHTTPAfterResponseRuleAccepted().WithReloadID(c.ReloadAgent.Reload()).WithPayload(params.Data)
59+
}
60+
61+
return http_after_response_rule.NewCreateHTTPAfterResponseRuleAccepted().WithPayload(params.Data)
62+
}
63+
64+
type DeleteHTTPAfterResponseRuleHandlerImpl struct {
65+
Client client_native.HAProxyClient
66+
ReloadAgent *haproxy.ReloadAgent
67+
}
68+
69+
func (d DeleteHTTPAfterResponseRuleHandlerImpl) Handle(params http_after_response_rule.DeleteHTTPAfterResponseRuleParams, _ interface{}) middleware.Responder {
70+
t, v := "", int64(0)
71+
72+
if params.TransactionID != nil {
73+
t = *params.TransactionID
74+
}
75+
76+
if params.Version != nil {
77+
v = *params.Version
78+
}
79+
80+
if t != "" && *params.ForceReload {
81+
e := &models.Error{
82+
Message: misc.StringP("Both force_reload and transaction specified, specify only one"),
83+
Code: misc.Int64P(int(misc.ErrHTTPBadRequest)),
84+
}
85+
return http_after_response_rule.NewDeleteHTTPAfterResponseRuleDefault(int(*e.Code)).WithPayload(e)
86+
}
87+
88+
configuration, err := d.Client.Configuration()
89+
if err != nil {
90+
e := misc.HandleError(err)
91+
return http_after_response_rule.NewDeleteHTTPAfterResponseRuleDefault(int(*e.Code)).WithPayload(e)
92+
}
93+
94+
if err = configuration.DeleteHTTPAfterResponseRule(params.Index, params.ParentType, params.ParentName, t, v); err != nil {
95+
e := misc.HandleError(err)
96+
return http_after_response_rule.NewDeleteHTTPAfterResponseRuleDefault(int(*e.Code)).WithPayload(e)
97+
}
98+
99+
if params.TransactionID == nil {
100+
if *params.ForceReload {
101+
if err = d.ReloadAgent.ForceReload(); err != nil {
102+
e := misc.HandleError(err)
103+
return http_after_response_rule.NewDeleteHTTPAfterResponseRuleDefault(int(*e.Code)).WithPayload(e)
104+
}
105+
106+
return http_after_response_rule.NewDeleteHTTPAfterResponseRuleNoContent()
107+
}
108+
109+
return http_after_response_rule.NewDeleteHTTPAfterResponseRuleAccepted().WithReloadID(d.ReloadAgent.Reload())
110+
}
111+
112+
return http_after_response_rule.NewDeleteHTTPAfterResponseRuleAccepted()
113+
}
114+
115+
type GetHTTPAfterResponseRuleHandlerImpl struct {
116+
Client client_native.HAProxyClient
117+
}
118+
119+
func (g GetHTTPAfterResponseRuleHandlerImpl) Handle(params http_after_response_rule.GetHTTPAfterResponseRuleParams, _ interface{}) middleware.Responder {
120+
var t string
121+
122+
if params.TransactionID != nil {
123+
t = *params.TransactionID
124+
}
125+
126+
configuration, err := g.Client.Configuration()
127+
if err != nil {
128+
e := misc.HandleError(err)
129+
return http_after_response_rule.NewGetHTTPAfterResponseRuleDefault(int(*e.Code)).WithPayload(e)
130+
}
131+
132+
v, rule, err := configuration.GetHTTPAfterResponseRule(params.Index, params.ParentType, params.ParentName, t)
133+
if err != nil {
134+
e := misc.HandleError(err)
135+
return http_after_response_rule.NewGetHTTPAfterResponseRuleDefault(int(*e.Code)).WithPayload(e)
136+
}
137+
138+
return http_after_response_rule.NewGetHTTPAfterResponseRuleOK().WithPayload(&http_after_response_rule.GetHTTPAfterResponseRuleOKBody{Version: v, Data: rule})
139+
}
140+
141+
type GetHTTPAfterResponseRulesHandlerImpl struct {
142+
Client client_native.HAProxyClient
143+
}
144+
145+
func (g GetHTTPAfterResponseRulesHandlerImpl) Handle(params http_after_response_rule.GetHTTPAfterResponseRulesParams, _ interface{}) middleware.Responder {
146+
var t string
147+
148+
if params.TransactionID != nil {
149+
t = *params.TransactionID
150+
}
151+
152+
configuration, err := g.Client.Configuration()
153+
if err != nil {
154+
e := misc.HandleError(err)
155+
return http_after_response_rule.NewGetHTTPAfterResponseRulesDefault(int(*e.Code)).WithPayload(e)
156+
}
157+
158+
v, rules, err := configuration.GetHTTPAfterResponseRules(params.ParentType, params.ParentName, t)
159+
if err != nil {
160+
e := misc.HandleError(err)
161+
return http_after_response_rule.NewGetHTTPAfterResponseRulesDefault(int(*e.Code)).WithPayload(e)
162+
}
163+
164+
return http_after_response_rule.NewGetHTTPAfterResponseRulesOK().WithPayload(&http_after_response_rule.GetHTTPAfterResponseRulesOKBody{Version: v, Data: rules})
165+
}
166+
167+
type ReplaceHTTPAfterResponseRuleHandlerImpl struct {
168+
Client client_native.HAProxyClient
169+
ReloadAgent *haproxy.ReloadAgent
170+
}
171+
172+
func (r ReplaceHTTPAfterResponseRuleHandlerImpl) Handle(params http_after_response_rule.ReplaceHTTPAfterResponseRuleParams, _ interface{}) middleware.Responder {
173+
t, v := "", int64(0)
174+
175+
if params.TransactionID != nil {
176+
t = *params.TransactionID
177+
}
178+
179+
if params.Version != nil {
180+
v = *params.Version
181+
}
182+
183+
if t != "" && *params.ForceReload {
184+
e := &models.Error{
185+
Message: misc.StringP("Both force_reload and transaction specified, specify only one"),
186+
Code: misc.Int64P(int(misc.ErrHTTPBadRequest)),
187+
}
188+
return http_after_response_rule.NewReplaceHTTPAfterResponseRuleDefault(int(*e.Code)).WithPayload(e)
189+
}
190+
191+
configuration, err := r.Client.Configuration()
192+
if err != nil {
193+
e := misc.HandleError(err)
194+
return http_after_response_rule.NewReplaceHTTPAfterResponseRuleDefault(int(*e.Code)).WithPayload(e)
195+
}
196+
197+
if err = configuration.EditHTTPAfterResponseRule(params.Index, params.ParentType, params.ParentName, params.Data, t, v); err != nil {
198+
e := misc.HandleError(err)
199+
return http_after_response_rule.NewReplaceHTTPAfterResponseRuleDefault(int(*e.Code)).WithPayload(e)
200+
}
201+
202+
if params.TransactionID == nil {
203+
if *params.ForceReload {
204+
if err = r.ReloadAgent.ForceReload(); err != nil {
205+
e := misc.HandleError(err)
206+
return http_after_response_rule.NewReplaceHTTPAfterResponseRuleDefault(int(*e.Code)).WithPayload(e)
207+
}
208+
209+
return http_after_response_rule.NewReplaceHTTPAfterResponseRuleOK().WithPayload(params.Data)
210+
}
211+
212+
return http_after_response_rule.NewReplaceHTTPAfterResponseRuleAccepted().WithReloadID(r.ReloadAgent.Reload()).WithPayload(params.Data)
213+
}
214+
215+
return http_after_response_rule.NewReplaceHTTPAfterResponseRuleAccepted().WithPayload(params.Data)
216+
}

0 commit comments

Comments
 (0)