func (s *ApiSuite) SetUpTest(c *C) {
newProxy := func(id int) (proxy.Proxy, error) {
return proxy.New(id, stapler.New(), proxy.Options{})
}
s.ng = memng.New(registry.GetRegistry())
sv := supervisor.New(newProxy, s.ng, make(chan error), supervisor.Options{})
app := scroll.NewApp()
InitProxyController(s.ng, sv, app)
s.testServer = httptest.NewServer(app.GetHandler())
s.client = NewClient(s.testServer.URL, registry.GetRegistry())
}
func (s *MemSuite) SetUpTest(c *C) {
engine := New(registry.GetRegistry())
s.suite.ChangesC = make(chan interface{})
s.stopC = make(chan bool)
go engine.Subscribe(s.suite.ChangesC, s.stopC)
s.suite.Engine = engine
}
func New(vulcanURL string, reg *plugin.Registry, ctx context.Context) (*vulcan, error) {
if _, er := url.Parse(vulcanURL); er != nil {
return nil, er
}
if reg == nil {
reg = registry.GetRegistry()
}
client := api.NewClient(vulcanURL, reg)
if client == nil {
return nil, errors.New("Failed to create vulcand client")
}
return &vulcan{Client: *client, c: ctx}, nil
}
func (s *EtcdSuite) SetUpTest(c *C) {
// Initiate a backend with a registry
key, err := secret.KeyFromString(s.key)
c.Assert(err, IsNil)
box, err := secret.NewBox(key)
c.Assert(err, IsNil)
engine, err := New(
s.nodes,
s.etcdPrefix,
registry.GetRegistry(),
Options{
EtcdConsistency: s.consistency,
Box: box,
})
c.Assert(err, IsNil)
s.ng = engine.(*ng)
s.client = s.ng.client
s.kapi = s.ng.kapi
// Delete all values under the given prefix
_, err = s.kapi.Get(s.context, s.etcdPrefix, &etcd.GetOptions{Recursive: false, Sort: false})
if err != nil {
// There's no key like this
if !notFound(err) {
// We haven't expected this error, oops
c.Assert(err, IsNil)
}
} else {
_, err = s.ng.kapi.Delete(s.context, s.etcdPrefix, &etcd.DeleteOptions{Recursive: true})
c.Assert(err, IsNil)
}
s.changesC = make(chan interface{})
s.stopC = make(chan bool)
go s.ng.Subscribe(s.changesC, s.stopC)
s.suite.ChangesC = s.changesC
s.suite.Engine = engine
}