func containersRestart(d *Daemon) error {
q := fmt.Sprintf("SELECT name FROM containers WHERE type=? AND power_state=1")
inargs := []interface{}{cTypeRegular}
var name string
outfmt := []interface{}{name}
result, err := shared.DbQueryScan(d.db, q, inargs, outfmt)
if err != nil {
return err
}
_, err = shared.DbExec(d.db, "UPDATE containers SET power_state=0")
if err != nil {
return err
}
for _, r := range result {
container, err := newLxdContainer(string(r[0].(string)), d)
if err != nil {
return err
}
err = templateApply(container, "start")
if err != nil {
return err
}
container.c.Start()
}
return nil
}
func certificateFingerprintDelete(d *Daemon, r *http.Request) Response {
fingerprint := mux.Vars(r)["fingerprint"]
for i, cert := range d.clientCerts {
if fingerprint == shared.GenerateFingerprint(&cert) {
fingerprint := shared.GenerateFingerprint(&cert)
d.clientCerts = append(d.clientCerts[:i], d.clientCerts[i+1:]...)
_, err := shared.DbExec(d.db, "DELETE FROM certificates WHERE fingerprint=?", fingerprint)
if err != nil {
return SmartError(err)
}
return EmptySyncResponse
}
}
return NotFound
}
func containerDeleteSnapshots(d *Daemon, cname string) error {
prefix := fmt.Sprintf("%s/", cname)
length := len(prefix)
q := "SELECT name, id FROM containers WHERE type=? AND SUBSTR(name,1,?)=?"
var id int
var sname string
inargs := []interface{}{cTypeSnapshot, length, prefix}
outfmt := []interface{}{sname, id}
results, err := shared.DbQueryScan(d.db, q, inargs, outfmt)
if err != nil {
return err
}
var ids []int
backing_fs, err := shared.GetFilesystem(shared.VarPath("lxc", cname))
if err != nil && !os.IsNotExist(err) {
shared.Debugf("Error cleaning up snapshots: %s\n", err)
return err
}
for _, r := range results {
sname = r[0].(string)
id = r[1].(int)
ids = append(ids, id)
cdir := shared.VarPath("lxc", cname, "snapshots", sname)
if backing_fs == "btrfs" {
exec.Command("btrfs", "subvolume", "delete", cdir).Run()
}
os.RemoveAll(cdir)
}
for _, id := range ids {
_, err = shared.DbExec(d.db, "DELETE FROM containers WHERE id=?", id)
if err != nil {
return err
}
}
return nil
}
func containersShutdown(d *Daemon) error {
q := fmt.Sprintf("SELECT name FROM containers WHERE type=?")
inargs := []interface{}{cTypeRegular}
var name string
outfmt := []interface{}{name}
result, err := shared.DbQueryScan(d.db, q, inargs, outfmt)
if err != nil {
return err
}
var wg sync.WaitGroup
for _, r := range result {
container, err := newLxdContainer(string(r[0].(string)), d)
if err != nil {
return err
}
_, err = shared.DbExec(d.db, "UPDATE containers SET power_state=1 WHERE name=?", container.name)
if err != nil {
return err
}
if container.c.State() != lxc.STOPPED {
wg.Add(1)
go func() {
container.c.Shutdown(time.Second * 30)
container.c.Stop()
wg.Done()
}()
}
wg.Wait()
}
return nil
}
// Insert an alias into the database.
func dbAddAlias(db *sql.DB, name string, imageId int, desc string) error {
stmt := `INSERT into images_aliases (name, image_id, description) values (?, ?, ?)`
_, err := shared.DbExec(db, stmt, name, imageId, desc)
return err
}
func aliasDelete(d *Daemon, r *http.Request) Response {
name := mux.Vars(r)["name"]
_, _ = shared.DbExec(d.db, "DELETE FROM images_aliases WHERE name=?", name)
return EmptySyncResponse
}