services/agent/internal/lockfile/lockfile.go

// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package lockfile provides methods to associate process ids (PIDs) with a file.
package lockfile

import (
	"bytes"
	"fmt"
	"io/ioutil"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"strconv"
	"syscall"

	"v.io/x/lib/vlog"
)

const (
	lockSuffix = "lock"
	tempSuffix = "templock"
)

// CreateLockfile associates the provided file with the process ID of the
// caller.
//
// file should not contain any useful content because CreateLockfile may
// delete and recreate it.
//
// Only one active process can be associated with a file at a time. Thus, if
// another active process is currently associated with file, then
// CreateLockfile will return an error.
func CreateLockfile(file string) error {
	f, err := ioutil.TempFile(filepath.Dir(file), filepath.Base(file)+"-"+tempSuffix)
	if err != nil {
		return err
	}
	defer f.Close()
	defer os.Remove(f.Name())
	cmd := makePsCommand(os.Getpid())
	cmd.Stdout = f
	cmd.Stderr = nil
	if err = cmd.Run(); err != nil {
		return err
	}
	lockfile := file + "-" + lockSuffix
	err = os.Link(f.Name(), lockfile)
	if err == nil {
		return nil
	}

	// Check for a stale lock
	lockProcessInfo, err := ioutil.ReadFile(lockfile)
	if err != nil {
		return err
	}
	if err, running := stillRunning(lockProcessInfo); running {
		return fmt.Errorf("process is already running:\n%s", lockProcessInfo)
	} else if err != nil {
		return err
	}

	// Delete the file if the old process left one behind.
	if err = os.Remove(file); !os.IsNotExist(err) {
		return err
	}

	// Note(ribrdb): There's a race here between checking the file contents
	// and deleting the file, but I don't think it will be an issue in normal
	// usage.
	return os.Rename(f.Name(), lockfile)
}

var pidRegex = regexp.MustCompile("\n\\s*(\\d+)")

func stillRunning(expected []byte) (error, bool) {
	match := pidRegex.FindSubmatch(expected)
	if match == nil {
		// Corrupt lockfile. Just delete it.
		return nil, false
	}
	pid, err := strconv.Atoi(string(match[1]))
	if err != nil {
		return nil, false
	}
	// Go's os turns the standard errors into indecipherable ones,
	// so use syscall directly.
	if err := syscall.Kill(pid, syscall.Signal(0)); err != nil {
		if errno, ok := err.(syscall.Errno); ok && errno == syscall.ESRCH {
			return nil, false
		}
	}
	cmd := makePsCommand(pid)
	out, err := cmd.Output()
	if err != nil {
		return err, false
	}
	return nil, bytes.Equal(expected, out)
}

// RemoveLockfile removes file and the corresponding lock on it.
func RemoveLockfile(file string) {
	path := file + "-" + lockSuffix
	if err := os.Remove(path); err != nil {
		vlog.Infof("Unable to remove lockfile %q: %v", path, err)
	}
	if err := os.Remove(file); err != nil {
		vlog.Infof("Unable to remove %q: %v", path, err)
	}
}

func makePsCommand(pid int) *exec.Cmd {
	return exec.Command("ps", "-o", "pid,ppid,lstart,user,comm", "-p", strconv.Itoa(pid))
}