func (s *S) TestListFilterMany(c *check.C) {
var allEvts []event.Event
var create = func(opts *event.Opts) {
evt, err := event.New(opts)
c.Assert(err, check.IsNil)
allEvts = append(allEvts, *evt)
}
var createi = func(opts *event.Opts) {
evt, err := event.NewInternal(opts)
c.Assert(err, check.IsNil)
allEvts = append(allEvts, *evt)
}
var checkFilters = func(f *event.Filter, expected interface{}) {
evts, err := event.List(f)
c.Assert(err, check.IsNil)
c.Assert(evts, eventtest.EvtEquals, expected)
}
create(&event.Opts{
Target: event.Target{Type: "app", Value: "myapp"},
Kind: permission.PermAppUpdateEnvSet,
Owner: s.token,
Allowed: event.Allowed(permission.PermAppReadEvents, permission.Context(permission.CtxApp, "myapp")),
})
time.Sleep(100 * time.Millisecond)
t0 := time.Now().UTC()
create(&event.Opts{
Target: event.Target{Type: "app", Value: "myapp2"},
Kind: permission.PermAppUpdateEnvSet,
Owner: s.token,
Allowed: event.Allowed(permission.PermAppAdmin),
})
t05 := time.Now().UTC()
time.Sleep(100 * time.Millisecond)
create(&event.Opts{
Target: event.Target{Type: "app2", Value: "myapp"},
Kind: permission.PermAppUpdateEnvSet,
Owner: s.token,
Allowed: event.Allowed(permission.PermAppAdmin),
})
t1 := time.Now().UTC()
time.Sleep(100 * time.Millisecond)
createi(&event.Opts{
Target: event.Target{Type: "node", Value: "http://10.0.1.1"},
InternalKind: "healer",
Allowed: event.Allowed(permission.PermAppAdmin),
})
createi(&event.Opts{
Target: event.Target{Type: "node", Value: "http://10.0.1.2"},
InternalKind: "healer",
Allowed: event.Allowed(permission.PermAppAdmin),
})
createi(&event.Opts{
Target: event.Target{Type: "nodex", Value: "http://10.0.1.3"},
InternalKind: "healer",
Allowed: event.Allowed(permission.PermAppAdmin),
})
err := event.MarkAsRemoved(event.Target{Type: "nodex", Value: "http://10.0.1.3"})
c.Assert(err, check.IsNil)
allEvts[len(allEvts)-2].Done(nil)
allEvts[len(allEvts)-3].Done(errors.New("my err"))
checkFilters(&event.Filter{Sort: "_id"}, allEvts[:len(allEvts)-1])
checkFilters(&event.Filter{Running: boolPtr(false), Sort: "_id"}, allEvts[len(allEvts)-3:len(allEvts)-1])
checkFilters(&event.Filter{Running: boolPtr(true), Sort: "_id"}, allEvts[:len(allEvts)-3])
checkFilters(&event.Filter{ErrorOnly: true, Sort: "_id"}, allEvts[len(allEvts)-3])
checkFilters(&event.Filter{Target: event.Target{Type: "app"}, Sort: "_id"}, []event.Event{allEvts[0], allEvts[1]})
checkFilters(&event.Filter{Target: event.Target{Type: "app", Value: "myapp"}}, allEvts[0])
checkFilters(&event.Filter{KindType: event.KindTypeInternal, Sort: "_id"}, allEvts[3:len(allEvts)-1])
checkFilters(&event.Filter{KindType: event.KindTypePermission, Sort: "_id"}, allEvts[:3])
checkFilters(&event.Filter{KindType: event.KindTypePermission, KindName: "kind"}, nil)
checkFilters(&event.Filter{KindType: event.KindTypeInternal, KindName: "healer", Sort: "_id"}, allEvts[3:len(allEvts)-1])
checkFilters(&event.Filter{OwnerType: event.OwnerTypeUser, Sort: "_id"}, allEvts[:3])
checkFilters(&event.Filter{OwnerType: event.OwnerTypeInternal, Sort: "_id"}, allEvts[3:len(allEvts)-1])
checkFilters(&event.Filter{OwnerType: event.OwnerTypeUser, OwnerName: s.token.GetUserName(), Sort: "_id"}, allEvts[:3])
checkFilters(&event.Filter{Since: t0, Sort: "_id"}, allEvts[1:len(allEvts)-1])
checkFilters(&event.Filter{Until: t05, Sort: "_id"}, allEvts[:2])
checkFilters(&event.Filter{Since: t0, Until: t1, Sort: "_id"}, allEvts[1:3])
checkFilters(&event.Filter{Limit: 2, Sort: "_id"}, allEvts[:2])
checkFilters(&event.Filter{Limit: 1, Sort: "-_id"}, allEvts[len(allEvts)-2])
checkFilters(&event.Filter{Target: event.Target{Type: "nodex"}}, allEvts[:0])
checkFilters(&event.Filter{Target: event.Target{Type: "nodex"}, IncludeRemoved: true}, allEvts[5:6])
checkFilters(&event.Filter{AllowedTargets: []event.TargetFilter{}, Sort: "_id"}, allEvts[:0])
checkFilters(&event.Filter{AllowedTargets: []event.TargetFilter{
{Type: "app"},
}, Sort: "_id"}, allEvts[:2])
checkFilters(&event.Filter{AllowedTargets: []event.TargetFilter{
{Type: "app", Values: []string{}},
}, Sort: "_id"}, allEvts[:0])
checkFilters(&event.Filter{AllowedTargets: []event.TargetFilter{
{Type: "app", Values: []string{"myapp", "myapp2"}},
}, Sort: "_id"}, allEvts[:2])
checkFilters(&event.Filter{AllowedTargets: []event.TargetFilter{
{Type: "app", Values: []string{"myapp"}},
{Type: "node", Values: []string{"http://10.0.1.2"}},
}, Sort: "_id"}, []event.Event{allEvts[0], allEvts[4]})
checkFilters(&event.Filter{Permissions: []permission.Permission{
{Scheme: permission.PermAll, Context: permission.Context(permission.CtxGlobal, "")},
}, Sort: "_id"}, allEvts[:len(allEvts)-1])
checkFilters(&event.Filter{Permissions: []permission.Permission{
{Scheme: permission.PermAll},
}, Sort: "_id"}, allEvts[:0])
checkFilters(&event.Filter{Permissions: []permission.Permission{
{Scheme: permission.PermAppRead, Context: permission.Context(permission.CtxApp, "myapp")},
{Scheme: permission.PermAppRead, Context: permission.Context(permission.CtxApp, "invalid-app")},
}, Sort: "_id"}, allEvts[:1])
checkFilters(&event.Filter{Permissions: []permission.Permission{
{Scheme: permission.PermAppRead, Context: permission.Context(permission.CtxApp, "invalid-app")},
}, Sort: "_id"}, allEvts[:0])
}
// Delete deletes an app.
func Delete(app *App, w io.Writer) error {
isSwapped, swappedWith, err := router.IsSwapped(app.GetName())
if err != nil {
return errors.Wrap(err, "unable to check if app is swapped")
}
if isSwapped {
return errors.Errorf("application is swapped with %q, cannot remove it", swappedWith)
}
appName := app.Name
if w == nil {
w = ioutil.Discard
}
fmt.Fprintf(w, "---- Removing application %q...\n", appName)
var hasErrors bool
defer func() {
var problems string
if hasErrors {
problems = " Some errors occurred during removal."
}
fmt.Fprintf(w, "---- Done removing application.%s\n", problems)
}()
logErr := func(msg string, err error) {
msg = fmt.Sprintf("%s: %s", msg, err)
fmt.Fprintf(w, "%s\n", msg)
log.Errorf("[delete-app: %s] %s", appName, msg)
hasErrors = true
}
prov, err := app.getProvisioner()
if err != nil {
return err
}
err = prov.Destroy(app)
if err != nil {
logErr("Unable to destroy app in provisioner", err)
}
r, err := app.Router()
if err == nil {
err = r.RemoveBackend(app.Name)
}
if err != nil {
logErr("Failed to remove router backend", err)
}
err = router.Remove(app.Name)
if err != nil {
logErr("Failed to remove router backend from database", err)
}
err = app.unbind()
if err != nil {
logErr("Unable to unbind app", err)
}
err = repository.Manager().RemoveRepository(appName)
if err != nil {
logErr("Unable to remove app from repository manager", err)
}
token := app.Env["TSURU_APP_TOKEN"].Value
err = AuthScheme.AppLogout(token)
if err != nil {
logErr("Unable to remove app token in destroy", err)
}
owner, err := auth.GetUserByEmail(app.Owner)
if err == nil {
err = auth.ReleaseApp(owner)
}
if err != nil {
logErr("Unable to release app quota", err)
}
logConn, err := db.LogConn()
if err == nil {
defer logConn.Close()
err = logConn.Logs(appName).DropCollection()
}
if err != nil {
logErr("Unable to remove logs collection", err)
}
conn, err := db.Conn()
if err == nil {
defer conn.Close()
err = conn.Apps().Remove(bson.M{"name": appName})
}
if err != nil {
logErr("Unable to remove app from db", err)
}
err = event.MarkAsRemoved(event.Target{Type: event.TargetTypeApp, Value: appName})
if err != nil {
logErr("Unable to mark old events as removed", err)
}
return nil
}