// bake` and let it do its work.
func RunDocker(args Args) error {
	requiresSplitBuild := len(args.Architectures) > 1 && (args.Save || !args.Push)
	if !requiresSplitBuild {
		log.Infof("building for architectures: %v", args.Architectures)
		return runDocker(args)
	}
	// https://github.com/docker/buildx/issues/59 - load and save are not supported for multi-arch

		// The crane builder is much faster but less tested.
		// Neither builder is doing standard logic; see each builder for details.
		if args.Builder == CraneBuilder {
			return RunCrane(ctx, args)
		}

		return RunDocker(args)
	},
}

func ValidateArgs(a Args) error {
	if len(a.Targets) == 0 {
		return fmt.Errorf("no targets specified")
	}
	if a.Push && a.Save {

    private final FileLockManager lockManager;
    private final Lock stateLock;
    private final Consumer<FileLock> onOpen;
    private final Consumer<FileLock> onClose;
    private final Runnable unlocker;
    private final Consumer<FileLockReleasedSignal> whenContended;
    private int lockCount;
    private FileLock fileLock;
    private final CacheInitializationAction initAction;

			// are provided, we will not return bucket metrics.
			if bmg, ok := h.metricsData.bucketMGMap[collectorPath]; ok {
				if len(buckets) == 0 {
					continue
				}
				unLocker := bmg.LockAndSetBuckets(buckets)
				defer unLocker()
			}
			gatherers = append(gatherers, gatherer)
		}
	}

	if len(gatherers) == 0 {
		return notFoundHandler
	}

	unlocksFailed := 0
	for lockID := range locks {
		if isLocked(locks[lockID]) {
			unlocksFailed++
		}
	}

	// Unlock failures are higher than tolerance limit
	// for this instance of unlocker, we should let the
	// caller know that lock is not successfully released
	// yet.
	if len(locks)-tolerance == tolerance {
		// In case of split brain scenarios where
		// tolerance is exactly half of the len(*locks)