func dbQueryRowScan(db *sql.DB, q string, args []interface{}, outargs []interface{}) error {
for {
err := db.QueryRow(q, args...).Scan(outargs...)
if err == nil {
return nil
}
if !isDbLockedError(err) {
shared.Debugf("DbQuery: query %q error %q\n", q, err)
return err
}
shared.Debugf("DbQueryRowScan: query %q args %q, DB was locked\n", q, args)
shared.PrintStack()
time.Sleep(1 * time.Second)
}
}
func dbBegin(db *sql.DB) (*sql.Tx, error) {
for {
tx, err := db.Begin()
if err == nil {
return tx, nil
}
if !isDbLockedError(err) {
shared.Debugf("DbBegin: error %q\n", err)
return nil, err
}
shared.Debugf("DbBegin: DB was locked\n")
shared.PrintStack()
time.Sleep(1 * time.Second)
}
}
func txCommit(tx *sql.Tx) error {
for {
err := tx.Commit()
if err == nil {
return nil
}
if !isDbLockedError(err) {
shared.Debugf("Txcommit: error %q\n", err)
return err
}
shared.Debugf("Txcommit: db was locked\n")
shared.PrintStack()
time.Sleep(1 * time.Second)
}
}
/*
* . q is the database query
* . inargs is an array of interfaces containing the query arguments
* . outfmt is an array of interfaces containing the right types of output
* arguments, i.e.
* var arg1 string
* var arg2 int
* outfmt := {}interface{}{arg1, arg2}
*
* The result will be an array (one per output row) of arrays (one per output argument)
* of interfaces, containing pointers to the actual output arguments.
*/
func dbQueryScan(db *sql.DB, q string, inargs []interface{}, outfmt []interface{}) ([][]interface{}, error) {
for {
result, err := doDbQueryScan(db, q, inargs, outfmt)
if err == nil {
return result, nil
}
if !isDbLockedError(err) {
shared.Debugf("DbQuery: query %q error %q\n", q, err)
return nil, err
}
shared.Debugf("DbQueryscan: query %q inargs %q, DB was locked\n", q, inargs)
shared.PrintStack()
time.Sleep(1 * time.Second)
}
}
func dbExec(db *sql.DB, q string, args ...interface{}) (sql.Result, error) {
for {
result, err := db.Exec(q, args...)
if err == nil {
return result, nil
}
if !isDbLockedError(err) {
shared.Debugf("DbExec: query %q error %q\n", q, err)
return nil, err
}
shared.Debugf("DbExec: query %q args %q, DB was locked\n", q, args)
shared.PrintStack()
time.Sleep(1 * time.Second)
}
}
func dbExec(db *sql.DB, q string, args ...interface{}) (sql.Result, error) {
for i := 0; i < 100; i++ {
result, err := db.Exec(q, args...)
if err == nil {
return result, nil
}
if !isDbLockedError(err) {
shared.Debugf("DbExec: query %q error %q", q, err)
return nil, err
}
time.Sleep(100 * time.Millisecond)
}
shared.Debugf("DbExec: query %q args %q, DB still locked", q, args)
shared.PrintStack()
return nil, fmt.Errorf("DB is locked")
}
/*
* . q is the database query
* . inargs is an array of interfaces containing the query arguments
* . outfmt is an array of interfaces containing the right types of output
* arguments, i.e.
* var arg1 string
* var arg2 int
* outfmt := {}interface{}{arg1, arg2}
*
* The result will be an array (one per output row) of arrays (one per output argument)
* of interfaces, containing pointers to the actual output arguments.
*/
func dbQueryScan(db *sql.DB, q string, inargs []interface{}, outfmt []interface{}) ([][]interface{}, error) {
for i := 0; i < 100; i++ {
result, err := doDbQueryScan(db, q, inargs, outfmt)
if err == nil {
return result, nil
}
if !isDbLockedError(err) {
shared.Debugf("DbQuery: query %q error %q", q, err)
return nil, err
}
time.Sleep(100 * time.Millisecond)
}
shared.Debugf("DbQueryscan: query %q inargs %q, DB still locked", q, inargs)
shared.PrintStack()
return nil, fmt.Errorf("DB is locked")
}
func txCommit(tx *sql.Tx) error {
for i := 0; i < 100; i++ {
err := tx.Commit()
if err == nil {
return nil
}
if !isDbLockedError(err) {
shared.Debugf("Txcommit: error %q", err)
return err
}
time.Sleep(100 * time.Millisecond)
}
shared.Debugf("Txcommit: db still locked")
shared.PrintStack()
return fmt.Errorf("DB is locked")
}
func dbBegin(db *sql.DB) (*sql.Tx, error) {
for i := 0; i < 100; i++ {
tx, err := db.Begin()
if err == nil {
return tx, nil
}
if !isDbLockedError(err) {
shared.Debugf("DbBegin: error %q", err)
return nil, err
}
time.Sleep(100 * time.Millisecond)
}
shared.Debugf("DbBegin: DB still locked")
shared.PrintStack()
return nil, fmt.Errorf("DB is locked")
}
func containersGet(d *Daemon, r *http.Request) Response {
for {
result, err := doContainersGet(d, d.isRecursionRequest(r))
if err == nil {
return SyncResponse(true, result)
}
if !shared.IsDbLockedError(err) {
shared.Debugf("DBERR: containersGet: error %q\n", err)
return InternalError(err)
}
// 1 s may seem drastic, but we really don't want to thrash
// perhaps we should use a random amount
shared.Debugf("DBERR: containersGet, db is locked\n")
shared.PrintStack()
time.Sleep(1 * time.Second)
}
}
func dbQueryRowScan(db *sql.DB, q string, args []interface{}, outargs []interface{}) error {
for {
err := db.QueryRow(q, args...).Scan(outargs...)
if err == nil {
return nil
}
if isNoMatchError(err) {
return err
}
if !isDbLockedError(err) {
shared.Log.Debug("DbQuery: query error", log.Ctx{"query": q, "args": args, "err": err})
return err
}
shared.Debugf("DbQueryRowScan: query %q args %q, DB was locked\n", q, args)
shared.PrintStack()
time.Sleep(1 * time.Second)
}
}
func dbQueryRowScan(db *sql.DB, q string, args []interface{}, outargs []interface{}) error {
for i := 0; i < 100; i++ {
err := db.QueryRow(q, args...).Scan(outargs...)
if err == nil {
return nil
}
if isNoMatchError(err) {
return err
}
if !isDbLockedError(err) {
return err
}
time.Sleep(100 * time.Millisecond)
}
shared.Debugf("DbQueryRowScan: query %q args %q, DB still locked", q, args)
shared.PrintStack()
return fmt.Errorf("DB is locked")
}
func containersGet(d *Daemon, r *http.Request) Response {
for i := 0; i < 100; i++ {
result, err := doContainersGet(d, d.isRecursionRequest(r))
if err == nil {
return SyncResponse(true, result)
}
if !isDbLockedError(err) {
shared.LogDebugf("DBERR: containersGet: error %q", err)
return InternalError(err)
}
// 1 s may seem drastic, but we really don't want to thrash
// perhaps we should use a random amount
time.Sleep(100 * time.Millisecond)
}
shared.LogDebugf("DBERR: containersGet, db is locked")
shared.PrintStack()
return InternalError(fmt.Errorf("DB is locked"))
}
func run() error {
if len(os.Args) > 1 {
switch os.Args[1] {
case "forkstart":
return startContainer(os.Args[1:])
case "forkmigrate":
return migration.MigrateContainer(os.Args[1:])
/*
case "forkputfile" and "forkgetfile" handled specially in copyfile.go
*/
}
}
gnuflag.Usage = func() {
fmt.Printf("Usage: lxd [options]\n\nOptions:\n")
gnuflag.PrintDefaults()
}
gnuflag.Parse(true)
if *help {
// The user asked for help via --help, so we shouldn't print to
// stderr.
gnuflag.SetOut(os.Stdout)
gnuflag.Usage()
return nil
}
if *version {
fmt.Println(shared.Version)
return nil
}
// Configure logging
syslog := ""
if *syslogFlag {
syslog = "lxd"
}
err := shared.SetLogger(syslog, *logfile, *verbose, *debug)
if err != nil {
fmt.Printf("%s", err)
return nil
}
if gnuflag.NArg() != 0 {
gnuflag.Usage()
return fmt.Errorf("Unknown arguments")
}
if *cpuProfile != "" {
f, err := os.Create(*cpuProfile)
if err != nil {
fmt.Printf("Error opening cpu profile file: %s\n", err)
return nil
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
if *memProfile != "" {
go memProfiler()
}
neededPrograms := []string{"setfacl", "rsync", "tar", "xz"}
for _, p := range neededPrograms {
_, err := exec.LookPath(p)
if err != nil {
return err
}
}
if *printGoroutines > 0 {
go func() {
for {
time.Sleep(time.Duration(*printGoroutines) * time.Second)
shared.PrintStack()
}
}()
}
d, err := startDaemon()
if err != nil {
if d != nil && d.db != nil {
d.db.Close()
}
return err
}
var ret error
var wg sync.WaitGroup
wg.Add(1)
go func() {
ch := make(chan os.Signal)
signal.Notify(ch, syscall.SIGPWR)
sig := <-ch
shared.Log.Info(
fmt.Sprintf("Received '%s signal', shutting down containers.", sig))
ret = d.Stop()
containersShutdown(d)
wg.Done()
}()
go func() {
ch := make(chan os.Signal)
signal.Notify(ch, syscall.SIGINT)
signal.Notify(ch, syscall.SIGQUIT)
signal.Notify(ch, syscall.SIGTERM)
sig := <-ch
shared.Log.Info(fmt.Sprintf("Received '%s signal', exiting.\n", sig))
ret = d.Stop()
wg.Done()
}()
wg.Wait()
return ret
}
func cmdDaemon() error {
if *argCPUProfile != "" {
f, err := os.Create(*argCPUProfile)
if err != nil {
fmt.Printf("Error opening cpu profile file: %s\n", err)
return nil
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
if *argMemProfile != "" {
go memProfiler(*argMemProfile)
}
neededPrograms := []string{"setfacl", "rsync", "tar", "xz"}
for _, p := range neededPrograms {
_, err := exec.LookPath(p)
if err != nil {
return err
}
}
if *argPrintGoroutinesEvery > 0 {
go func() {
for {
time.Sleep(time.Duration(*argPrintGoroutinesEvery) * time.Second)
shared.PrintStack()
}
}()
}
d := &Daemon{
group: *argGroup,
SetupMode: shared.PathExists(shared.VarPath(".setup_mode"))}
err := d.Init()
if err != nil {
if d != nil && d.db != nil {
d.db.Close()
}
return err
}
var ret error
var wg sync.WaitGroup
wg.Add(1)
go func() {
ch := make(chan os.Signal)
signal.Notify(ch, syscall.SIGPWR)
sig := <-ch
shared.Log.Info(
fmt.Sprintf("Received '%s signal', shutting down containers.", sig))
containersShutdown(d)
ret = d.Stop()
wg.Done()
}()
go func() {
<-d.shutdownChan
shared.Log.Info(
fmt.Sprintf("Asked to shutdown by API, shutting down containers."))
containersShutdown(d)
ret = d.Stop()
wg.Done()
}()
go func() {
ch := make(chan os.Signal)
signal.Notify(ch, syscall.SIGINT)
signal.Notify(ch, syscall.SIGQUIT)
signal.Notify(ch, syscall.SIGTERM)
sig := <-ch
shared.Log.Info(fmt.Sprintf("Received '%s signal', exiting.", sig))
ret = d.Stop()
wg.Done()
}()
wg.Wait()
return ret
}
func run() error {
gnuflag.Usage = func() {
fmt.Printf("Usage: lxd [command] [options]\n\nOptions:\n")
gnuflag.PrintDefaults()
fmt.Printf("\nCommands:\n")
fmt.Printf(" shutdown\n")
fmt.Printf(" Perform a clean shutdown of LXD and all running containers\n")
fmt.Printf(" activateifneeded\n")
fmt.Printf(" Check if LXD should be started (at boot) and if so, spawn it through socket activation\n")
fmt.Printf("\nInternal commands (don't call directly):\n")
fmt.Printf(" forkgetfile\n")
fmt.Printf(" Grab a file from a running container\n")
fmt.Printf(" forkputfile\n")
fmt.Printf(" Pushes a file to a running container\n")
fmt.Printf(" forkstart\n")
fmt.Printf(" Start a container\n")
fmt.Printf(" forkmigrate\n")
fmt.Printf(" Restore a container after migration\n")
}
gnuflag.Parse(true)
if *help {
// The user asked for help via --help, so we shouldn't print to
// stderr.
gnuflag.SetOut(os.Stdout)
gnuflag.Usage()
return nil
}
if *version {
fmt.Println(shared.Version)
return nil
}
if len(shared.VarPath("unix.sock")) > 107 {
return fmt.Errorf("LXD_DIR is too long, must be < %d", 107-len("unix.sock"))
}
// Configure logging
syslog := ""
if *syslogFlag {
syslog = "lxd"
}
err := shared.SetLogger(syslog, *logfile, *verbose, *debug)
if err != nil {
fmt.Printf("%s", err)
return nil
}
// Process sub-commands
if len(os.Args) > 1 {
// "forkputfile" and "forkgetfile" are handled specially in copyfile.go
switch os.Args[1] {
case "forkstart":
return startContainer(os.Args[1:])
case "forkmigrate":
return MigrateContainer(os.Args[1:])
case "shutdown":
return cleanShutdown()
case "activateifneeded":
return activateIfNeeded()
}
}
if gnuflag.NArg() != 0 {
gnuflag.Usage()
return fmt.Errorf("Unknown arguments")
}
if *cpuProfile != "" {
f, err := os.Create(*cpuProfile)
if err != nil {
fmt.Printf("Error opening cpu profile file: %s\n", err)
return nil
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
if *memProfile != "" {
go memProfiler()
}
neededPrograms := []string{"setfacl", "rsync", "tar", "xz"}
for _, p := range neededPrograms {
_, err := exec.LookPath(p)
if err != nil {
return err
}
}
if *printGoroutines > 0 {
go func() {
for {
time.Sleep(time.Duration(*printGoroutines) * time.Second)
shared.PrintStack()
}
}()
}
d, err := startDaemon()
if err != nil {
if d != nil && d.db != nil {
d.db.Close()
}
return err
}
var ret error
var wg sync.WaitGroup
wg.Add(1)
go func() {
ch := make(chan os.Signal)
signal.Notify(ch, syscall.SIGPWR)
sig := <-ch
shared.Log.Info(
fmt.Sprintf("Received '%s signal', shutting down containers.", sig))
containersShutdown(d)
ret = d.Stop()
wg.Done()
}()
go func() {
ch := make(chan os.Signal)
signal.Notify(ch, syscall.SIGINT)
signal.Notify(ch, syscall.SIGQUIT)
signal.Notify(ch, syscall.SIGTERM)
sig := <-ch
shared.Log.Info(fmt.Sprintf("Received '%s signal', exiting.\n", sig))
ret = d.Stop()
wg.Done()
}()
wg.Wait()
return ret
}
func run() error {
gnuflag.Usage = func() {
fmt.Printf("Usage: lxd [command] [options]\n\nOptions:\n")
gnuflag.PrintDefaults()
fmt.Printf("\nCommands:\n")
fmt.Printf(" shutdown\n")
fmt.Printf(" Perform a clean shutdown of LXD and all running containers\n")
fmt.Printf(" activateifneeded\n")
fmt.Printf(" Check if LXD should be started (at boot) and if so, spawn it through socket activation\n")
fmt.Printf("\nInternal commands (don't call directly):\n")
fmt.Printf(" forkgetfile\n")
fmt.Printf(" Grab a file from a running container\n")
fmt.Printf(" forkputfile\n")
fmt.Printf(" Pushes a file to a running container\n")
fmt.Printf(" forkstart\n")
fmt.Printf(" Start a container\n")
fmt.Printf(" forkmigrate\n")
fmt.Printf(" Restore a container after migration\n")
}
gnuflag.Parse(true)
if *help {
// The user asked for help via --help, so we shouldn't print to
// stderr.
gnuflag.SetOut(os.Stdout)
gnuflag.Usage()
return nil
}
if *version {
fmt.Println(shared.Version)
return nil
}
// Configure logging
syslog := ""
if *syslogFlag {
syslog = "lxd"
}
err := shared.SetLogger(syslog, *logfile, *verbose, *debug)
if err != nil {
fmt.Printf("%s", err)
return nil
}
// Process sub-commands
if len(os.Args) > 1 {
// "forkputfile" and "forkgetfile" are handled specially in copyfile.go
switch os.Args[1] {
case "forkstart":
return startContainer(os.Args[1:])
case "forkmigrate":
return MigrateContainer(os.Args[1:])
case "shutdown":
return cleanShutdown()
case "activateifneeded":
return activateIfNeeded()
}
}
if gnuflag.NArg() != 0 {
gnuflag.Usage()
return fmt.Errorf("Unknown arguments")
}
if *cpuProfile != "" {
f, err := os.Create(*cpuProfile)
if err != nil {
fmt.Printf("Error opening cpu profile file: %s\n", err)
return nil
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
if *memProfile != "" {
go memProfiler()
}
neededPrograms := []string{"setfacl", "rsync", "tar", "xz"}
for _, p := range neededPrograms {
_, err := exec.LookPath(p)
if err != nil {
return err
}
}
_, err = exec.LookPath("apparmor_parser")
if err == nil && shared.IsDir("/sys/kernel/security/apparmor") {
aaEnabled = true
} else {
shared.Log.Warn("apparmor_parser binary not found or apparmor " +
"fs not mounted. AppArmor disabled.")
}
if aaEnabled && os.Getenv("LXD_SECURITY_APPARMOR") == "false" {
aaEnabled = false
shared.Log.Warn("per-container apparmor profiles have been manually disabled")
}
runningInUserns = shared.RunningInUserNS()
if aaEnabled && runningInUserns {
aaEnabled = false
shared.Log.Warn("per-container apparmor profiles disabled because we are in a user namespace")
}
/* Can we create devices? */
checkCanMknod()
if *printGoroutines > 0 {
go func() {
for {
time.Sleep(time.Duration(*printGoroutines) * time.Second)
shared.PrintStack()
}
}()
}
d, err := startDaemon()
if err != nil {
if d != nil && d.db != nil {
d.db.Close()
}
return err
}
var ret error
var wg sync.WaitGroup
wg.Add(1)
go func() {
ch := make(chan os.Signal)
signal.Notify(ch, syscall.SIGPWR)
sig := <-ch
shared.Log.Info(
fmt.Sprintf("Received '%s signal', shutting down containers.", sig))
containersShutdown(d)
ret = d.Stop()
wg.Done()
}()
go func() {
ch := make(chan os.Signal)
signal.Notify(ch, syscall.SIGINT)
signal.Notify(ch, syscall.SIGQUIT)
signal.Notify(ch, syscall.SIGTERM)
sig := <-ch
shared.Log.Info(fmt.Sprintf("Received '%s signal', exiting.\n", sig))
ret = d.Stop()
wg.Done()
}()
wg.Wait()
return ret
}
