PinsStore.swift

/*
 This source file is part of the Swift.org open source project

 Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
 Licensed under Apache License v2.0 with Runtime Library Exception

 See http://swift.org/LICENSE.txt for license information
 See http://swift.org/CONTRIBUTORS.txt for Swift project authors
*/

import Basic
import SPMUtility
import SourceControl
import PackageModel
import PackageGraph

public final class PinsStore {
    public struct Pin {
        /// The package reference of the pinned dependency.
        public let packageRef: PackageReference

        /// The pinned state.
        public let state: CheckoutState

        init(
            packageRef: PackageReference,
            state: CheckoutState
        ) {
            self.packageRef = packageRef
            self.state = state
        }
    }

    /// The schema version of the resolved file.
    ///
    /// * 1: Initial version.
    static let schemaVersion: Int = 1

    /// The path to the pins file.
    fileprivate let pinsFile: AbsolutePath

    /// The filesystem to manage the pin file on.
    fileprivate var fileSystem: FileSystem

    /// The pins map.
    ///
    /// Key -> Package Identity.
    fileprivate(set) var pinsMap: [String: Pin]

    /// The current pins.
    public var pins: AnySequence<Pin> {
        return AnySequence<Pin>(pinsMap.values)
    }

    fileprivate let persistence: SimplePersistence

    /// Create a new pins store.
    ///
    /// - Parameters:
    ///   - pinsFile: Path to the pins file.
    ///   - fileSystem: The filesystem to manage the pin file on.
    public init(pinsFile: AbsolutePath, fileSystem: FileSystem) throws {
        self.pinsFile = pinsFile
        self.fileSystem = fileSystem
        self.persistence = SimplePersistence(
            fileSystem: fileSystem,
            schemaVersion: PinsStore.schemaVersion,
            statePath: pinsFile,
            prettyPrint: true)
        pinsMap = [:]
        do {
            _ = try self.persistence.restoreState(self)
        } catch SimplePersistence.Error.restoreFailure {
            throw WorkspaceDiagnostics.MalformedPackageResolved()
        }
    }

    /// Pin a repository at a version.
    ///
    /// This method does not automatically write to state file.
    ///
    /// - Parameters:
    ///   - packageRef: The package reference to pin.
    ///   - state: The state to pin at.
    public func pin(
        packageRef: PackageReference,
        state: CheckoutState
    ) {
        pinsMap[packageRef.identity] = Pin(
            packageRef: packageRef,
            state: state
        )
    }

    /// Add a pin.
    ///
    /// This will replace any previous pin with same package name.
    public func add(_ pin: Pin) {
        pinsMap[pin.packageRef.identity] = pin
    }

    /// Pin a managed dependency at its checkout state.
    ///
    /// This method does nothing if the dependency is in edited state.
    func pin(_ dependency: ManagedDependency) {

        // Get the checkout state.
        let checkoutState: CheckoutState
        switch dependency.state {
        case .checkout(let state):
            checkoutState = state
        case .edited, .local:
            return
        }

        self.pin(
            packageRef: dependency.packageRef,
            state: checkoutState)
    }

    /// Unpin all of the currently pinnned dependencies.
    ///
    /// This method does not automatically write to state file.
    public func unpinAll() {
        // Reset the pins map.
        pinsMap = [:]
    }

    /// Creates constraints based on the pins in the store.
    public func createConstraints() -> [RepositoryPackageConstraint] {
        return pins.map({ pin in
            return RepositoryPackageConstraint(
                container: pin.packageRef, requirement: pin.state.requirement())
        })
    }
}

/// Persistence.
extension PinsStore: SimplePersistanceProtocol {

    public func saveState() throws {
        if pinsMap.isEmpty {
            // Remove the pins file if there are zero pins to save.
            //
            // This can happen if all dependencies are path-based or edited
            // dependencies.
            return try fileSystem.removeFileTree(pinsFile)
        }

        try self.persistence.saveState(self)
    }

    public func restore(from json: JSON) throws {
        self.pinsMap = try Dictionary(items: json.get("pins").map({ ($0.packageRef.identity, $0) }))
    }

    /// Saves the current state of pins.
    public func toJSON() -> JSON {
        return JSON([
            "pins": pins.sorted(by: { $0.packageRef.identity < $1.packageRef.identity }).toJSON(),
        ])
    }
}

// JSON.
extension PinsStore.Pin: JSONMappable, JSONSerializable, Equatable {
    /// Create an instance from JSON data.
    public init(json: JSON) throws {
        let name: String? = json.get("package")
        let url: String = try json.get("repositoryURL")
        let ref = PackageReference(identity: PackageReference.computeIdentity(packageURL: url), path: url)
        self.packageRef = name.flatMap(ref.with(newName:)) ?? ref
        self.state = try json.get("state")
    }

    /// Convert the pin to JSON.
    public func toJSON() -> JSON {
        return .init([
            "package": packageRef.name.toJSON(),
            "repositoryURL": packageRef.path,
            "state": state,
        ])
    }
}

/// A file watcher utility for the Package.resolved file.
///
/// This is not intended to be used directly by clients.
final class ResolvedFileWatcher {
    private var fswatch: FSWatch!
    private var existingValue: ByteString?
    private let valueLock: Lock = Lock()
    private let resolvedFile: AbsolutePath

    public func updateValue() {
        valueLock.withLock {
            self.existingValue = try? localFileSystem.readFileContents(resolvedFile)
        }
    }

    init(resolvedFile: AbsolutePath, onChange: @escaping () -> ()) throws {
        self.resolvedFile = resolvedFile

        let block = { [weak self] (paths: [AbsolutePath]) in
            guard let self = self else { return }

            // Check if resolved file is part of the received paths.
            let hasResolvedFile = paths.contains{ $0.appending(component: resolvedFile.basename) == resolvedFile }
            guard hasResolvedFile else { return }

            self.valueLock.withLock {
                // Compute the contents of the resolved file and fire the onChange block
                // if its value is different than existing value.
                let newValue = try? localFileSystem.readFileContents(resolvedFile)
                if self.existingValue != newValue {
                    self.existingValue = newValue
                    onChange()
                }
            }
        }

        fswatch = FSWatch(paths: [resolvedFile.parentDirectory], latency: 1, block: block)
        try fswatch.start()
    }

    deinit {
        fswatch.stop()
    }
}