platform_build_soong/ui/build/proc_sync.go

// Copyright 2017 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package build

import (
	"errors"
	"fmt"
	"math"
	"os"
	"path/filepath"
	"syscall"
	"time"

	"android/soong/ui/logger"
)

// This file provides cross-process synchronization methods
// i.e. making sure only one Soong process is running for a given output directory

func BecomeSingletonOrFail(ctx Context, config Config) (lock *fileLock) {
	lockingInfo, err := newLock(config.OutDir())
	if err != nil {
		ctx.Logger.Fatal(err)
	}
	lockfilePollDuration := time.Second
	lockfileTimeout := time.Second * 10
	if envTimeout := os.Getenv("SOONG_LOCK_TIMEOUT"); envTimeout != "" {
		lockfileTimeout, err = time.ParseDuration(envTimeout)
		if err != nil {
			ctx.Logger.Fatalf("failure parsing SOONG_LOCK_TIMEOUT %q: %s", envTimeout, err)
		}
	}
	err = lockSynchronous(*lockingInfo, newSleepWaiter(lockfilePollDuration, lockfileTimeout), ctx.Logger)
	if err != nil {
		ctx.Logger.Fatal(err)
	}
	return lockingInfo
}

type lockable interface {
	tryLock() error
	Unlock() error
	description() string
}

var _ lockable = (*fileLock)(nil)

type fileLock struct {
	File *os.File
}

func (l fileLock) description() (path string) {
	return l.File.Name()
}
func (l fileLock) tryLock() (err error) {
	return syscall.Flock(int(l.File.Fd()), syscall.LOCK_EX|syscall.LOCK_NB)
}
func (l fileLock) Unlock() (err error) {
	return l.File.Close()
}

func lockSynchronous(lock lockable, waiter waiter, logger logger.Logger) (err error) {

	waited := false

	for {
		err = lock.tryLock()
		if err == nil {
			if waited {
				// If we had to wait at all, then when the wait is done, we inform the user
				logger.Printf("Acquired lock on %v; previous Soong process must have completed. Continuing...\n", lock.description())
			}
			return nil
		}

		done, description := waiter.checkDeadline()

		if !waited {
			logger.Printf("Waiting up to %s to lock %v to ensure no other Soong process is running in the same output directory\n", description, lock.description())
		}

		waited = true

		if done {
			return fmt.Errorf("Tried to lock %s, but timed out %s . Make sure no other Soong process is using it",
				lock.description(), waiter.summarize())
		} else {
			waiter.wait()
		}
	}
}

func newLock(basedir string) (lock *fileLock, err error) {
	lockPath := filepath.Join(basedir, ".lock")

	os.MkdirAll(basedir, 0777)
	lockfileDescriptor, err := os.OpenFile(lockPath, os.O_RDWR|os.O_CREATE, 0666)
	if err != nil {
		return nil, errors.New("failed to open " + lockPath)
	}
	lockingInfo := &fileLock{File: lockfileDescriptor}

	return lockingInfo, nil
}

type waiter interface {
	wait()
	checkDeadline() (done bool, remainder string)
	summarize() (summary string)
}

type sleepWaiter struct {
	sleepInterval time.Duration
	deadline      time.Time

	totalWait time.Duration
}

var _ waiter = (*sleepWaiter)(nil)

func newSleepWaiter(interval time.Duration, duration time.Duration) (waiter *sleepWaiter) {
	return &sleepWaiter{interval, time.Now().Add(duration), duration}
}

func (s sleepWaiter) wait() {
	time.Sleep(s.sleepInterval)
}
func (s *sleepWaiter) checkDeadline() (done bool, remainder string) {
	remainingSleep := s.deadline.Sub(time.Now())
	numSecondsRounded := math.Floor(remainingSleep.Seconds()*10+0.5) / 10
	if remainingSleep > 0 {
		return false, fmt.Sprintf("%vs", numSecondsRounded)
	} else {
		return true, ""
	}
}
func (s sleepWaiter) summarize() (summary string) {
	return fmt.Sprintf("polling every %v until %v", s.sleepInterval, s.totalWait)
}