func MakeFrontend(route string, backendId string) engine.Frontend {
f, err := engine.NewHTTPFrontend(UID("frontend"), backendId, route, engine.HTTPFrontendSettings{})
if err != nil {
panic(err)
}
return *f
}
func (r *vulcandRouter) SetCName(cname, name string) error {
usedName, err := router.Retrieve(name)
if err != nil {
return err
}
if !router.ValidCName(cname, r.domain) {
return router.ErrCNameNotAllowed
}
frontendName := r.frontendName(cname)
if found, _ := r.client.GetFrontend(engine.FrontendKey{Id: frontendName}); found != nil {
return router.ErrCNameExists
}
frontend, err := engine.NewHTTPFrontend(
frontendName,
r.backendName(usedName),
fmt.Sprintf(`Host(%q)`, cname),
engine.HTTPFrontendSettings{},
)
if err != nil {
return &router.RouterError{Err: err, Op: "set-cname"}
}
err = r.client.UpsertFrontend(*frontend, engine.NoTTL)
if err != nil {
return &router.RouterError{Err: err, Op: "set-cname"}
}
return nil
}
func (s *ApiSuite) TestMiddlewareCRUD(c *C) {
b, err := engine.NewHTTPBackend("b1", engine.HTTPBackendSettings{})
c.Assert(err, IsNil)
c.Assert(s.client.UpsertBackend(*b), IsNil)
f, err := engine.NewHTTPFrontend("f1", b.Id, `Path("/")`, engine.HTTPFrontendSettings{})
c.Assert(err, IsNil)
fk := engine.FrontendKey{Id: f.Id}
c.Assert(s.client.UpsertFrontend(*f, 0), IsNil)
cl := s.makeConnLimit("c1", 10, "client.ip", 2, f)
c.Assert(s.client.UpsertMiddleware(fk, cl, 0), IsNil)
ms, err := s.client.GetMiddlewares(fk)
c.Assert(err, IsNil)
c.Assert(ms[0], DeepEquals, cl)
cl = s.makeConnLimit("c1", 10, "client.ip", 3, f)
c.Assert(s.client.UpsertMiddleware(fk, cl, 0), IsNil)
mk := engine.MiddlewareKey{Id: cl.Id, FrontendKey: fk}
v, err := s.client.GetMiddleware(mk)
c.Assert(err, IsNil)
c.Assert(v, DeepEquals, &cl)
c.Assert(s.client.DeleteMiddleware(mk), IsNil)
_, err = s.client.GetMiddleware(mk)
c.Assert(err, FitsTypeOf, &engine.NotFoundError{})
}
func (s *ApiSuite) TestFrontendCRUD(c *C) {
b, err := engine.NewHTTPBackend("b1", engine.HTTPBackendSettings{})
c.Assert(err, IsNil)
c.Assert(s.client.UpsertBackend(*b), IsNil)
f, err := engine.NewHTTPFrontend("f1", b.Id, `Path("/")`, engine.HTTPFrontendSettings{})
c.Assert(err, IsNil)
fk := engine.FrontendKey{Id: f.Id}
c.Assert(s.client.UpsertFrontend(*f, 0), IsNil)
fs, err := s.client.GetFrontends()
c.Assert(err, IsNil)
c.Assert(fs[0], DeepEquals, *f)
out, err := s.client.GetFrontend(fk)
c.Assert(err, IsNil)
c.Assert(out, DeepEquals, f)
settings := f.HTTPSettings()
settings.Hostname = `localhost`
f.Settings = settings
f.Route = `Path("/v2")`
c.Assert(s.client.UpsertFrontend(*f, 0), IsNil)
c.Assert(s.client.DeleteFrontend(fk), IsNil)
out, err = s.client.GetFrontend(fk)
c.Assert(err, FitsTypeOf, &engine.NotFoundError{})
}
func (kv *kube2vulcand) addVulcandFrontend(i instance) error {
route := fmt.Sprintf("Host(`%s.<whatever>`)", i.Name)
frontend, err := vulcandng.NewHTTPFrontend(i.Name, i.Name, route, vulcandng.HTTPFrontendSettings{})
if err != nil {
glog.Errorf("addVulcandFrontend: Failed to create HTTPFrontend : ", err)
return err
}
return kv.vulcandClient.UpsertFrontend(*frontend, 0)
}
func (cmd *Command) upsertFrontendAction(c *cli.Context) {
settings, err := getFrontendSettings(c)
if err != nil {
cmd.printError(err)
return
}
f, err := engine.NewHTTPFrontend(c.String("id"), c.String("b"), c.String("route"), settings)
if err != nil {
cmd.printError(err)
return
}
if err := cmd.client.UpsertFrontend(*f, c.Duration("ttl")); err != nil {
cmd.printError(err)
return
}
cmd.printOk("frontend upserted")
}
func (r *vulcandRouter) SetCName(cname, name string) error {
usedName, err := router.Retrieve(name)
if err != nil {
return err
}
frontendName := r.frontendName(cname)
if found, _ := r.client.GetFrontend(engine.FrontendKey{Id: frontendName}); found != nil {
return router.ErrRouteExists
}
frontend, err := engine.NewHTTPFrontend(
frontendName,
r.backendName(usedName),
fmt.Sprintf(`Host(%q)`, cname),
engine.HTTPFrontendSettings{},
)
if err != nil {
return err
}
return r.client.UpsertFrontend(*frontend, engine.NoTTL)
}
func (r *vulcandRouter) AddBackend(name string) error {
backendName := r.backendName(name)
frontendName := r.frontendName(r.frontendHostname(name))
backendKey := engine.BackendKey{Id: backendName}
frontendKey := engine.FrontendKey{Id: frontendName}
if found, _ := r.client.GetBackend(backendKey); found != nil {
return router.ErrBackendExists
}
if found, _ := r.client.GetFrontend(frontendKey); found != nil {
return router.ErrBackendExists
}
backend, err := engine.NewHTTPBackend(
backendName,
engine.HTTPBackendSettings{},
)
if err != nil {
return err
}
err = r.client.UpsertBackend(*backend)
if err != nil {
return err
}
frontend, err := engine.NewHTTPFrontend(
frontendName,
backend.Id,
fmt.Sprintf(`Host(%q)`, r.frontendHostname(name)),
engine.HTTPFrontendSettings{},
)
if err != nil {
return err
}
err = r.client.UpsertFrontend(*frontend, engine.NoTTL)
if err != nil {
r.client.DeleteBackend(backendKey)
return err
}
return router.Store(name, name, routerName)
}
func newVulcandFrontend(id, backendID, routeExpr string) (*vulcand.Frontend, error) {
return vulcand.NewHTTPFrontend(id, backendID, routeExpr, vulcand.HTTPFrontendSettings{})
}