Esempio n. 1
0
func BackupAction(c *cli.Context) {
	CheckUid(c.Command.Name)
	a := getAgent(c)

	if err := a.TrackMetrics(); err != nil {
		fmt.Println(err)
	}

	if _, err := lock.Lock(LockPath); err != nil {
		log.Fatal(err)
	}

	if err := a.RunTasks(); err != nil {
		log.Fatal(err)
	} else {
		fmt.Println("Completed!")
	}

}
Esempio n. 2
0
func lockFile(path string) (io.Closer, error) {
	retry := 100 * time.Microsecond
	startTime := time.Now()
	for {
		if locker, err := filelock.Lock(path); err == nil {
			return locker, nil
		}
		total := time.Since(startTime)
		if total > maxRetryDuration {
			return nil, errgo.New("file locked for too long; giving up")
		}
		// Always have at least one try at the end of the interval.
		if remain := maxRetryDuration - total; retry > remain {
			retry = remain
		}
		time.Sleep(retry)
		retry *= 2
	}
}
Esempio n. 3
0
func (s *Server) Listen(addr string) error {
	s.Info("Initializing state dir", "dir", s.stateDir)

	if err := os.MkdirAll(string(s.stateDir), 0755); err != nil {
		return err
	}

	closer, err := lock.Lock(s.stateDir.LockFile())

	if err != nil {
		return err
	}

	defer closer.Close()

	c := Config{
		Addr: addr,
	}

	if err := writeConfigFile(c, s.stateDir); err != nil {
		return err
	}

	s.Info("Registering plugins")

	s.plugins = listAllPlugins()

	for _, p := range s.plugins {
		s.Info("Plugin found", "plugin", p.name, "path", p.path)

		if err := p.initialize(s.stateDir); err != nil {
			return err
		}

		s.registerRoutes(p.Routes())
	}

	return s.Server.Listen(addr)
}
Esempio n. 4
0
File: file.go Progetto: uabassguy/ql
func newFileFromOSFile(f lldb.OSFile) (fi *file, err error) {
	nm := lockName(f.Name())
	lck, err := lock.Lock(nm)
	if err != nil {
		if lck != nil {
			lck.Close()
		}
		return nil, err
	}

	close := true
	defer func() {
		if close && lck != nil {
			lck.Close()
		}
	}()

	var w *os.File
	closew := false
	wn := walName(f.Name())
	w, err = os.OpenFile(wn, os.O_CREATE|os.O_EXCL|os.O_RDWR, 0666)
	closew = true
	defer func() {
		if closew {
			nm := w.Name()
			w.Close()
			os.Remove(nm)
			w = nil
		}
	}()

	if err != nil {
		if !os.IsExist(err) {
			return nil, err
		}

		closew = false
		w, err = os.OpenFile(wn, os.O_RDWR, 0666)
		if err != nil {
			return nil, err
		}

		closew = true
		st, err := w.Stat()
		if err != nil {
			return nil, err
		}

		if st.Size() != 0 {
			return nil, fmt.Errorf("non empty WAL file %s exists", wn)
		}
	}

	info, err := f.Stat()
	if err != nil {
		return nil, err
	}

	switch sz := info.Size(); {
	case sz == 0:
		b := make([]byte, 16)
		copy(b, []byte(magic))
		if _, err := f.Write(b); err != nil {
			return nil, err
		}

		filer := lldb.Filer(lldb.NewOSFiler(f))
		filer = lldb.NewInnerFiler(filer, 16)
		if filer, err = lldb.NewACIDFiler(filer, w); err != nil {
			return nil, err
		}

		a, err := lldb.NewAllocator(filer, &lldb.Options{})
		if err != nil {
			return nil, err
		}

		a.Compress = true
		s := &file{
			a:     a,
			codec: newGobCoder(),
			f0:    f,
			f:     filer,
			lck:   lck,
			name:  f.Name(),
			wal:   w,
		}
		if err = s.BeginTransaction(); err != nil {
			return nil, err
		}

		h, err := s.Create()
		if err != nil {
			return nil, err
		}

		if h != 1 { // root
			log.Panic("internal error")
		}

		if h, err = s.a.Alloc(make([]byte, 8)); err != nil {
			return nil, err
		}

		if h != 2 { // id
			log.Panic("internal error")
		}

		close, closew = false, false
		return s, s.Commit()
	default:
		b := make([]byte, 16)
		if _, err := f.Read(b); err != nil {
			return nil, err
		}

		if string(b[:len(magic)]) != magic {
			return nil, fmt.Errorf("unknown file format")
		}

		filer := lldb.Filer(lldb.NewOSFiler(f))
		filer = lldb.NewInnerFiler(filer, 16)
		if filer, err = lldb.NewACIDFiler(filer, w); err != nil {
			return nil, err
		}

		a, err := lldb.NewAllocator(filer, &lldb.Options{})
		if err != nil {
			return nil, err
		}

		bid, err := a.Get(nil, 2) // id
		if err != nil {
			return nil, err
		}

		if len(bid) != 8 {
			return nil, fmt.Errorf("corrupted id |% x|", bid)
		}

		id := int64(0)
		for _, v := range bid {
			id = (id << 8) | int64(v)
		}

		a.Compress = true
		s := &file{
			a:     a,
			codec: newGobCoder(),
			f0:    f,
			f:     filer,
			id:    id,
			lck:   lck,
			name:  f.Name(),
			wal:   w,
		}

		close, closew = false, false
		return s, nil
	}
}
Esempio n. 5
0
File: lock.go Progetto: rht/ipget
func Lock(confdir string) (io.Closer, error) {
	c, err := lock.Lock(path.Join(confdir, LockFile))
	return c, err
}