func notify(appName string, messages []interface{}) {
factory, err := queue.Factory()
if err != nil {
log.Errorf("Error on logs notify: %s", err.Error())
return
}
q, err := factory.Get(logQueueName(appName))
if err != nil {
log.Errorf("Error on logs notify: %s", err.Error())
return
}
pubSubQ, ok := q.(queue.PubSubQ)
if !ok {
log.Debugf("Queue does not support pubsub, logs only in database.")
return
}
for _, msg := range messages {
bytes, err := json.Marshal(msg)
if err != nil {
log.Errorf("Error on logs notify: %s", err.Error())
continue
}
err = pubSubQ.Pub(bytes)
if err != nil {
log.Errorf("Error on logs notify: %s", err.Error())
}
}
}
func NewLogListener(a *App, filterLog Applog) (*LogListener, error) {
factory, err := queue.Factory()
if err != nil {
return nil, err
}
pubSubQ, err := factory.PubSub(logQueueName(a.Name))
if err != nil {
return nil, err
}
subChan, err := pubSubQ.Sub()
if err != nil {
return nil, err
}
c := make(chan Applog, 10)
go func() {
defer close(c)
for msg := range subChan {
applog := Applog{}
err := json.Unmarshal(msg, &applog)
if err != nil {
log.Errorf("Unparsable log message, ignoring: %s", string(msg))
continue
}
if (filterLog.Source == "" || filterLog.Source == applog.Source) &&
(filterLog.Unit == "" || filterLog.Unit == applog.Unit) {
c <- applog
}
}
}()
l := LogListener{C: c, q: pubSubQ}
return &l, nil
}
func (s *S) SetUpTest(c *check.C) {
s.provisioner.Reset()
repositorytest.Reset()
dbtest.ClearAllCollections(s.conn.Apps().Database)
s.createUserAndTeam(c)
platform := Platform{Name: "python"}
s.conn.Platforms().Insert(platform)
s.defaultPlan = Plan{
Name: "default-plan",
Memory: 1024,
Swap: 1024,
CpuShare: 100,
Default: true,
}
err := s.conn.Plans().Insert(s.defaultPlan)
c.Assert(err, check.IsNil)
s.Pool = "pool1"
opts := provision.AddPoolOptions{Name: s.Pool}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
repository.Manager().CreateUser(s.user.Email)
factory, err := queue.Factory()
c.Assert(err, check.IsNil)
factory.Reset()
}
func (s *S) SetUpTest(c *check.C) {
routertest.FakeRouter.Reset()
repositorytest.Reset()
var err error
s.conn, err = db.Conn()
c.Assert(err, check.IsNil)
dbtest.ClearAllCollections(s.conn.Apps().Database)
s.logConn, err = db.LogConn()
c.Assert(err, check.IsNil)
s.createUserAndTeam(c)
s.provisioner = provisiontest.NewFakeProvisioner()
app.Provisioner = s.provisioner
app.AuthScheme = nativeScheme
p := app.Platform{Name: "zend"}
s.conn.Platforms().Insert(p)
s.Pool = "test1"
opts := provision.AddPoolOptions{Name: "test1", Default: true}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
repository.Manager().CreateUser(s.user.Email)
repository.Manager().CreateUser(s.adminuser.Email)
factory, err := queue.Factory()
c.Assert(err, check.IsNil)
factory.Reset()
}
func getQueue() (queue.Q, error) {
queueName := "tsuru-app"
qfactory, err := queue.Factory()
if err != nil {
return nil, err
}
return qfactory.Get(queueName)
}
func setQueue() {
var err error
qfactory, err = queue.Factory()
if err != nil {
log.Fatalf("Failed to get the queue instance: %s", err)
}
_handler, err = qfactory.Handler(handle, queueName)
if err != nil {
log.Fatalf("Failed to create the queue handler: %s", err)
}
}
func (s *S) SetUpTest(c *check.C) {
// Reset fake routers twice, first time will remove registered failures and
// allow pending enqueued tasks to run, second time (after queue is reset)
// will remove any routes added by executed queue tasks.
routertest.FakeRouter.Reset()
routertest.HCRouter.Reset()
queue.ResetQueue()
routertest.FakeRouter.Reset()
routertest.HCRouter.Reset()
err := rebuild.RegisterTask(func(appName string) (rebuild.RebuildApp, error) {
a, err := GetByName(appName)
if err == ErrAppNotFound {
return nil, nil
}
return a, err
})
c.Assert(err, check.IsNil)
config.Set("docker:router", "fake")
s.provisioner.Reset()
repositorytest.Reset()
dbtest.ClearAllCollections(s.conn.Apps().Database)
s.createUserAndTeam(c)
platform := Platform{Name: "python"}
s.conn.Platforms().Insert(platform)
s.defaultPlan = Plan{
Name: "default-plan",
Memory: 1024,
Swap: 1024,
CpuShare: 100,
Default: true,
Router: "fake",
}
err = s.conn.Plans().Insert(s.defaultPlan)
c.Assert(err, check.IsNil)
s.Pool = "pool1"
opts := provision.AddPoolOptions{Name: s.Pool, Default: true}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
repository.Manager().CreateUser(s.user.Email)
factory, err := queue.Factory()
c.Assert(err, check.IsNil)
factory.Reset()
}
func notify(appName string, messages []interface{}) {
factory, err := queue.Factory()
if err != nil {
log.Errorf("Error on logs notify: %s", err.Error())
return
}
pubSubQ, err := factory.PubSub(logQueueName(appName))
if err != nil {
log.Errorf("Error on logs notify: %s", err.Error())
return
}
for _, msg := range messages {
bytes, err := json.Marshal(msg)
if err != nil {
log.Errorf("Error on logs notify: %s", err.Error())
continue
}
err = pubSubQ.Pub(bytes)
if err != nil {
log.Errorf("Error on logs notify: %s", err.Error())
}
}
}
