paulgorman.org

2018-03-06 22:13:08 -0500 EST

Asterisk file locking in Go

I recently looked into how Asterisk locks files. I’m working on a service written in Go that needs to mess with Asterisk voicemail files. I don’t want to step on Asterisk’s toes (or let it step on mine). This is a first take on a Go library for Asterisk-compatible file/directory locking.

The Go functions largely follow their Asterisk C counterparts. Go’s golang.org/x/sys/unix package provides an interface to the low-level operating system primitives. This Go package doesn’t provide much documentation, but we can refer to the OpenBSD man pages:

// Package asterisk provides functions to interoperate with Asterisk.
package asterisk

import (
	"fmt"
	"math/rand"
	"path"
	"time"

	"golang.org/x/sys/unix"
)

const maxRetries int = 12
const waitTime time.Duration = time.Millisecond * 500

func init() {
	rand.Seed(time.Now().UnixNano())
}

// LockPathLockfile locks a directory with a `.lock` file.
func LockPathLockfile(p string) error {
	var err error
	fs := path.Join(p, fmt.Sprintf(".lock-%08x", rand.Int31()))
	s := path.Join(p, ".lock")
	fd, err := unix.Open(fs, unix.O_WRONLY|unix.O_CREAT|unix.O_EXCL, 0600)
	if err != nil {
		return fmt.Errorf("LockPathLockfile can't open file descriptor for %s: %v", fs, err)
	}
	unix.Close(fd)
	for retries := 0; retries < maxRetries; retries++ {
		err = unix.Link(fs, s)
		if err == nil {
			break
		}
		err = fmt.Errorf("LockPathLockfile can't link lock files %s and %s: %v", fs, s, err)
		time.Sleep(waitTime)
	}
	unix.Unlink(fs)
	return err
}

// UnlockPathLockfile unlocks a directory locked by LockPathLockfile.
func UnlockPathLockfile(p string) error {
	var err error
	s := path.Join(p, ".lock")
	err = unix.Unlink(s)
	if err != nil {
		err = fmt.Errorf("UnlockPathLockfile can't unlink %s: %v", s, err)
	}
	return err
}

// LockPathFlock locks a directory using the `flock` system call on a `lock` file.
func LockPathFlock(p string) error {
	var err error
	fs := path.Join(p, "lock")
	fd, err := unix.Open(fs, unix.O_WRONLY|unix.O_CREAT, 0600)
	if err != nil {
		return fmt.Errorf("LockPathFlock can't open file descriptor for %s: %v", fs, err)
	}
	for retries := 0; retries < maxRetries; retries++ {
		err = unix.Flock(fd, unix.LOCK_EX|unix.LOCK_NB)
		if err != nil {
			err = fmt.Errorf("LockPathFlock can't flock file %s: %v", fs, err)
			time.Sleep(waitTime)
			continue
		}
		// Avoid the race condition where another prococess flocks our lock file first!
		var st0, st1 unix.Stat_t
		err = unix.Fstat(fd, &st0)
		if err != nil {
			return fmt.Errorf("LockPathFlock can't stat file descriptor %v: %v", fd, err)
		}
		err = unix.Stat(fs, &st1)
		if err != nil {
			return fmt.Errorf("LockPathFlock can't stat lock file %s: %v", fs, err)
		}
		if st0.Ino == st1.Ino {
			break
		}
		time.Sleep(waitTime)
	}
	unix.Close(fd)
	return err
}

// UnlockPathFlock unlocks a directory locked by LockPathFlock.
func UnlockPathFlock(p string) error {
	var err error
	s := path.Join(p, "lock")
	fd, err := unix.Open(s, unix.O_WRONLY|unix.O_CREAT, 0600)
	if err != nil {
		err = fmt.Errorf("UnlockPathFlock can't open lock file descriptor for %s during unlock: %v", s, err)
	}
	unix.Unlink(s)
	if err != nil {
		err = fmt.Errorf("UnlockPathFlock can't unlink %s: %v", s, err)
	}
	unix.Flock(fd, unix.LOCK_UN)
	if err != nil {
		err = fmt.Errorf("UnlockPathFlock can't un-flock file descriptor %v: %v", fd, err)
	}
	return err
}

#asterisk #golang

⬅ Older Post Newer Post ➡