func (m *mux) transportSettings(b engine.Backend) (*engine.TransportSettings, error) {
s, err := b.TransportSettings()
if err != nil {
return nil, err
}
// Apply global defaults if options are not set
if s.Timeouts.Dial == 0 {
s.Timeouts.Dial = m.options.DialTimeout
}
if s.Timeouts.Read == 0 {
s.Timeouts.Read = m.options.ReadTimeout
}
return s, nil
}
func (b *backend) updateSettings(be engine.Backend) error {
olds := b.backend.HTTPSettings()
news := be.HTTPSettings()
// Nothing changed in transport options
if news.Equals(olds) {
return nil
}
s, err := b.mux.transportSettings(be)
if err != nil {
return err
}
t := newTransport(s)
b.transport.CloseIdleConnections()
b.transport = t
for _, f := range b.frontends {
f.updateTransport(t)
}
return nil
}
func (s *EngineSuite) BackendCRUD(c *C) {
b := engine.Backend{Id: "b1", Type: engine.HTTP, Settings: engine.HTTPBackendSettings{}}
c.Assert(s.Engine.UpsertBackend(b), IsNil)
s.expectChanges(c, &engine.BackendUpserted{Backend: b})
bk := engine.BackendKey{Id: b.Id}
out, err := s.Engine.GetBackend(bk)
c.Assert(err, IsNil)
c.Assert(out, DeepEquals, &b)
bs, err := s.Engine.GetBackends()
c.Assert(len(bs), Equals, 1)
c.Assert(bs[0], DeepEquals, b)
b.Settings = engine.HTTPBackendSettings{Timeouts: engine.HTTPBackendTimeouts{Read: "1s"}}
c.Assert(s.Engine.UpsertBackend(b), IsNil)
s.expectChanges(c, &engine.BackendUpserted{Backend: b})
b.Settings = engine.HTTPBackendSettings{
Timeouts: engine.HTTPBackendTimeouts{Read: "1s"},
TLS: &engine.TLSSettings{PreferServerCipherSuites: true},
}
c.Assert(s.Engine.UpsertBackend(b), IsNil)
s.expectChanges(c, &engine.BackendUpserted{Backend: b})
err = s.Engine.DeleteBackend(bk)
c.Assert(err, IsNil)
s.expectChanges(c, &engine.BackendDeleted{
BackendKey: bk,
})
}
func ensureEndpointConfiguredForVulcand(client *vClient.Client, endpoints api.Endpoints) {
name := endpoints.Name + "." + endpoints.Namespace
backend := engine.Backend{Id: name, Type: "http",
Settings: engine.HTTPBackendSettings{
Timeouts: engine.HTTPBackendTimeouts{Read: "5s", Dial: "5s", TLSHandshake: "10s"},
KeepAlive: engine.HTTPBackendKeepAlive{Period: "30s", MaxIdleConnsPerHost: 12}}}
err := client.UpsertBackend(backend)
if err != nil {
log.Println("Encountered error when creating backend in vulcand: " + err.Error())
}
// add servers to the backend
for _, element := range endpoints.Subsets {
for _, address := range element.Addresses {
url := "http://" + address.IP + ":" + strconv.Itoa(element.Ports[0].Port)
log.Println("Attempting to add server to backend " + backend.GetUniqueId().Id + " using url: " + url)
err = client.UpsertServer(backend.GetUniqueId(), engine.Server{Id: url, URL: url}, time.Second*5)
if err != nil {
log.Println("Encountered error when adding server to backend: " + err.Error())
}
}
}
// make sure there's a frontend
frontend := engine.Frontend{Id: name, Type: "http", Route: "Path(`/`)", BackendId: name}
err = client.UpsertFrontend(frontend, time.Second*5)
if err != nil {
log.Println("Encountered error when creating frontend in vulcand: " + err.Error())
}
}