// Delete deletes an app.
//
// Delete an app is a process composed of three steps:
//
// 1. Destroy the app unit
// 2. Unbind all service instances from the app
// 3. Remove the app from the database
func Delete(app *App) error {
appName := app.Name
wg := asyncDestroyAppProvisioner(app)
wg.Add(1)
defer wg.Done()
go func() {
defer ReleaseApplicationLock(appName)
wg.Wait()
logConn, err := db.LogConn()
if err != nil {
log.Errorf("Unable to delete app %s from db: %s", appName, err.Error())
}
defer logConn.Close()
conn, err := db.Conn()
if err != nil {
log.Errorf("Unable to delete app %s from db: %s", appName, err.Error())
}
defer conn.Close()
err = logConn.Logs(appName).DropCollection()
if err != nil {
log.Errorf("Ignored error dropping logs collection for app %s: %s", appName, err.Error())
}
err = conn.Apps().Remove(bson.M{"name": appName})
if err != nil {
log.Errorf("Error trying to destroy app %s from db: %s", appName, err.Error())
}
err = markDeploysAsRemoved(appName)
if err != nil {
log.Errorf("Error trying to mark old deploys as removed for app %s: %s", appName, err.Error())
}
}()
err := repository.Manager().RemoveRepository(appName)
if err != nil {
log.Errorf("failed to remove app %q from repository manager: %s", appName, err)
}
token := app.Env["TSURU_APP_TOKEN"].Value
err = AuthScheme.Logout(token)
if err != nil {
log.Errorf("Unable to remove app token in destroy: %s", err.Error())
}
owner, err := auth.GetUserByEmail(app.Owner)
if err != nil {
log.Errorf("Unable to get app owner in destroy: %s", err.Error())
} else {
err = auth.ReleaseApp(owner)
if err != nil {
log.Errorf("Unable to release app quota: %s", err.Error())
}
}
return nil
}
// Delete deletes an app.
//
// Delete an app is a process composed of four steps:
//
// 1. Destroy the app unit
// 2. Unbind all service instances from the app
// 4. Remove the app from the database
func Delete(app *App) error {
gURL := repository.ServerURL()
(&gandalf.Client{Endpoint: gURL}).RemoveRepository(app.Name)
if len(app.Units) > 0 {
Provisioner.Destroy(app)
app.unbind()
}
token := app.Env["TSURU_APP_TOKEN"].Value
auth.DeleteToken(token)
if owner, err := auth.GetUserByEmail(app.Owner); err == nil {
auth.ReleaseApp(owner)
}
conn, err := db.Conn()
if err != nil {
return err
}
defer conn.Close()
return conn.Apps().Remove(bson.M{"name": app.Name})
}
// Delete deletes an app.
//
// Delete an app is a process composed of three steps:
//
// 1. Destroy the app unit
// 2. Unbind all service instances from the app
// 3. Remove the app from the database
func Delete(app *App) error {
appName := app.Name
wg := asyncDestroyAppProvisioner(app)
wg.Add(1)
defer wg.Done()
go func() {
defer ReleaseApplicationLock(appName)
wg.Wait()
conn, err := db.Conn()
if err != nil {
log.Errorf("Unable to delete app %s from db: %s", appName, err.Error())
}
defer conn.Close()
err = conn.Logs(appName).DropCollection()
if err != nil {
log.Errorf("Ignored error dropping logs collection for app %s: %s", appName, err.Error())
}
err = conn.Apps().Remove(bson.M{"name": appName})
if err != nil {
log.Errorf("Error trying to destroy app %s from db: %s", appName, err.Error())
}
}()
gandalfClient := gandalf.Client{Endpoint: repository.ServerURL()}
gandalfClient.RemoveRepository(appName)
token := app.Env["TSURU_APP_TOKEN"].Value
err := AuthScheme.Logout(token)
if err != nil {
log.Errorf("Unable to remove app token in destroy: %s", err.Error())
}
owner, err := auth.GetUserByEmail(app.Owner)
if err != nil {
log.Errorf("Unable to get app owner in destroy: %s", err.Error())
} else {
err = auth.ReleaseApp(owner)
if err != nil {
log.Errorf("Unable to release app quota: %s", err.Error())
}
}
return nil
}
// Delete deletes an app.
//
// Delete an app is a process composed of three steps:
//
// 1. Destroy the app unit
// 2. Unbind all service instances from the app
// 3. Remove the app from the database
func Delete(app *App) error {
gURL := repository.ServerURL()
(&gandalf.Client{Endpoint: gURL}).RemoveRepository(app.Name)
if len(app.Units()) > 0 {
Provisioner.Destroy(app)
app.unbind()
}
token := app.Env["TSURU_APP_TOKEN"].Value
AuthScheme.Logout(token)
if owner, err := auth.GetUserByEmail(app.Owner); err == nil {
auth.ReleaseApp(owner)
}
conn, err := db.Conn()
if err != nil {
return err
}
defer conn.Close()
err = conn.Logs(app.Name).DropCollection()
if err != nil {
log.Errorf("Ignored error dropping logs collection for app %s", app.Name)
}
return conn.Apps().Remove(bson.M{"name": app.Name})
}
func (s *S) TestReserveUserAppForwardAppNotPointer(c *gocheck.C) {
user := auth.User{
Email: "*****@*****.**",
Quota: quota.Quota{Limit: 1},
}
err := user.Create()
c.Assert(err, gocheck.IsNil)
defer s.conn.Users().Remove(bson.M{"email": user.Email})
app := App{
Name: "clap",
Platform: "django",
}
expected := map[string]string{"user": user.Email, "app": app.Name}
previous, err := reserveUserApp.Forward(action.FWContext{Params: []interface{}{app, user}})
c.Assert(err, gocheck.IsNil)
c.Assert(previous, gocheck.DeepEquals, expected)
err = auth.ReserveApp(&user)
_, ok := err.(*quota.QuotaExceededError)
c.Assert(ok, gocheck.Equals, true)
err = auth.ReleaseApp(&user)
c.Assert(err, gocheck.IsNil)
err = auth.ReserveApp(&user)
c.Assert(err, gocheck.IsNil)
}
// Delete deletes an app.
func Delete(app *App, w io.Writer) error {
isSwapped, swappedWith, err := router.IsSwapped(app.GetName())
if err != nil {
return fmt.Errorf("unable to check if app is swapped: %s", err)
}
if isSwapped {
return fmt.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
}
err = Provisioner.Destroy(app)
if err != nil {
logErr("Unable to destroy app in provisioner", 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 = markDeploysAsRemoved(appName)
if err != nil {
logErr("Unable to mark old deploys as removed", err)
}
return nil
}
default:
return nil, errors.New("Third parameter must be auth.User or *auth.User.")
}
usr, err := auth.GetUserByEmail(user.Email)
if err != nil {
return nil, err
}
if err := auth.ReserveApp(usr); err != nil {
return nil, err
}
return map[string]string{"app": app.Name, "user": user.Email}, nil
},
Backward: func(ctx action.BWContext) {
m := ctx.FWResult.(map[string]string)
if user, err := auth.GetUserByEmail(m["user"]); err == nil {
auth.ReleaseApp(user)
}
},
MinParams: 2,
}
// insertApp is an action that inserts an app in the database in Forward and
// removes it in the Backward.
//
// The first argument in the context must be an App or a pointer to an App.
var insertApp = action.Action{
Name: "insert-app",
Forward: func(ctx action.FWContext) (action.Result, error) {
var app *App
switch ctx.Params[0].(type) {
case *App:
