After install scripts (#1904)

lib/src/after_install.dart

@@ -0,0 +1,81 @@
+// Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+import 'package:path/path.dart' as p;
+
+/// Stores timestamps of the absolute paths to Dart scripts
+/// specified in packages' "after_install" fields, and the
+/// last times they were run.
+class AfterInstallCache {
+  final Map<String, int> _cache;
+
+  const AfterInstallCache._(this._cache);
+
+  /// Returns the name of the file that would hold an "after_install" cache in the [rootDir].
+  static String resolveCacheFilePath(String rootDir) {
+    return p.join(rootDir, "after_install_cache.json");
+  }
+
+  /// Loads from a given [rootDir].
+  static Future<AfterInstallCache> load(String rootDir) async {
+    var filename = resolveCacheFilePath(rootDir);
+    var cacheFile = new File(filename);
+
+    // If the file does not exist, return the default.
+    if (!await cacheFile.exists()) return new AfterInstallCache._({});
+
+    var map = json.decode(await cacheFile.readAsString());
+    var isValidMap = map is Map &&
+        map.keys.every((k) => k is String) &&
+        map.values.every((k) => k is int);
+
+    // If the file is formatted improperly, return the default.
+    //
+    // Whatever corrupted data was stored in the cache file, will
+    // ultimately be overwritten.
+    if (!isValidMap) return new AfterInstallCache._({});
+
+    // If everything went well, return the parsed cache.
+    return new AfterInstallCache._(map.cast<String, int>());
+  }
+
+  /// Determines if the script at [path] should be re-run.
+  ///
+  /// This is `true` if any of the following is true:
+  ///   * The cache contains no entry for the [path].
+  ///   * The file at [path] was modified after the timestamp in the cache.
+  Future<bool> isOutdated(String path) async {
+    if (!_cache.containsKey(path)) return true;
+    var stat = await FileStat.stat(path);
+    return _cache[path] < stat.modified.millisecondsSinceEpoch;
+  }
+
+  /// Saves the contents of the cache to a file in the given [rootDir].
+  Future save(String rootDir) async {
+    if (_cache.isNotEmpty) {
+      var file = new File(resolveCacheFilePath(rootDir));
+      await file.create(recursive: true);
+      await file.writeAsString(json.encode(_cache));
+    }
+  }
+
+  /// Updates the cached timestamp for [path].
+  void update(String path) =>
+      _cache[path] = new DateTime.now().millisecondsSinceEpoch;
+
+  /// Returns a combined cache containing the contents of both `this` and [other].
+  ///
+  /// Where there are conflicts, values in [other] are prioritized.
+  ///
+  /// Does not modify the caches of either `this` or [other].
+  AfterInstallCache merge(AfterInstallCache other) {
+    return new AfterInstallCache._(
+        <String, int>{}..addAll(_cache)..addAll(other._cache));
+  }
+
+  Map<String, int> toMap() => new Map<String, int>.from(_cache);
+}

lib/src/entrypoint.dart

@@ -4,12 +4,14 @@
 
 import 'dart:async';
 import 'dart:io';
+import 'dart:isolate';
 
 import 'package:collection/collection.dart';
 import 'package:package_config/packages_file.dart' as packages_file;
 import 'package:path/path.dart' as p;
 import 'package:pub_semver/pub_semver.dart';
 
+import 'after_install.dart';
 import 'dart.dart' as dart;
 import 'exceptions.dart';
 import 'http.dart' as http;
@@ -246,6 +248,8 @@ class Entrypoint {
       } else {
         _deleteExecutableSnapshots(changed: result.changedPackages);
       }
+
+      await runAfterInstallScripts(result);
     } catch (error, stackTrace) {
       // Just log exceptions here. Since the method is just about acquiring
       // dependencies, it shouldn't fail unless that fails.
@@ -642,4 +646,127 @@ class Entrypoint {
     ensureDir(p.dirname(newPath));
     renameDir(oldPath, newPath);
   }
+
+  /// Execute any outstanding Dart scripts in `after_install`.
+  Future runAfterInstallScripts(SolveResult result) async {
+    // Count how many scripts we could potentially run.
+    var allScripts = <String, List<String>>{};
+
+    for (var package in result.changedPackages) {
+      var scripts = result.pubspecs[package].afterInstall;
+      if (scripts.isNotEmpty) allScripts[package] = scripts;
+    }
+
+    // If no scripts need to be run, don't bother updating the cache.
+    if (allScripts.isEmpty) return;
+
+    // Figure out what the last time every script was run.
+    // If a script has not changed since the last time it was run,
+    // Don't run it.
+    var systemScriptCache = await AfterInstallCache.load(cache.rootDir);
+    var localScriptCache = p.equals(cache.rootDir, cachePath)
+        ? systemScriptCache
+        : await AfterInstallCache.load(cachePath);
+    var mergedCache = systemScriptCache.merge(localScriptCache);
+
+    // Sort so that the root's scripts run last.
+    var changedPackages = result.changedPackages.toList();
+    changedPackages.sort((a, b) => a == root.name ? 1 : a.compareTo(b));
+
+    // Run scripts in dependencies.
+    for (var package in changedPackages) {
+      var pkg = package == root.name
+          ? root
+          : cache.load(result.packages
+              .firstWhere((a) => a.name == package, orElse: () => null));
+
+      for (var script in pkg.pubspec.afterInstall) {
+        var absolutePath = p.normalize(p.absolute(p.join(pkg.dir, script)));
+        var scriptFile = new File(absolutePath);
+
+        // Don't run the script against there are new changes.
+        if (!await mergedCache.isOutdated(absolutePath)) continue;
+
+        if (!await scriptFile.exists()) {
+          if (pkg == root)
+            log.warning(log.yellow(
+                '"after_install" script "$absolutePath" does not exist.'));
+        } else {
+          // Never trust any third-party scripts. Show a prompt before running scripts.
+          //
+          // The user can opt to print the contents of the script.
+          YesNoPrintResponse response = YesNoPrintResponse.yes;
+
+          if (pkg != root) {
+            var message =
+                '\npackage:$package wants to run the script "$absolutePath".';
+
+            do {
+              response = await confirmOrPrint(message);
+
+              if (response == YesNoPrintResponse.no) {
+                log.message('User declined to run script.');
+                continue;
+              }
+
+              if (response == YesNoPrintResponse.print) {
+                log.message(log.gray('Contents of "$absolutePath":'));
+                log.message(log.gray(await scriptFile.readAsString()));
+              }
+            } while (response == YesNoPrintResponse.print);
+          }
+
+          if (response != YesNoPrintResponse.yes) continue;
+
+          // We need to change into the package's directory to run its scripts.
+          var currentDir = Directory.current;
+          Directory.current = pkg.dir;
+
+          // Spawn an isolate for the script.
+          var onError = new ReceivePort();
+          var onExit = new ReceivePort();
+          var onComplete = new Completer();
+
+          onExit.listen(
+              (x) => onComplete.isCompleted ? null : onComplete.complete());
+          onError.listen((x) => onComplete.isCompleted
+              ? null
+              : onComplete.completeError(x[0], x[1]));
+
+          try {
+            Isolate.spawnUri(p.toUri(absolutePath), [], null,
+                onExit: onExit.sendPort,
+                onError: onError.sendPort,
+                automaticPackageResolution: true);
+            await onComplete.future;
+
+            // Update the cache so this script does not run again redundantly.
+            if (pkg == root)
+              localScriptCache.update(absolutePath);
+            else
+              systemScriptCache.update(absolutePath);
+          } catch (e, st) {
+            log.error(
+                log.red('An unhandled exception occurred in "$absolutePath".'),
+                log.red(e),
+                st);
+            log.error(log
+                .red('Below is the stack trace where the exception occurred:'));
+            log.error(log.red(st.toString()));
+            log.error(log.red(
+                '\nThis is not an error in Pub; Report this error to the author(s) of package:$package instead.'));
+          } finally {
+            // Switch back!
+            Directory.current = currentDir;
+            onError.close();
+            onExit.close();
+          }
+        }
+      }
+    }
+
+    // Now that we've run all scripts, update the cache files.
+    await systemScriptCache.save(cache.rootDir);
+    await localScriptCache.save(cachePath);
+  }
 }

lib/src/io.dart

@@ -590,6 +590,43 @@ Future<bool> confirm(String message) {
       .then((line) => new RegExp(r"^[yY]").hasMatch(line));
 }
 
+enum YesNoPrintResponse { yes, no, print }
+
+/// Displays a message and reads a yes/no/print confirmation from the user.
+///
+/// Returns a [Future] that completes to:
+///   * `ViewContents.yes`: The user confirmed.
+///   * `ViewContents.no`: The user declined.
+///   * `ViewContents.print`: The user confirmed to show file contents.
+Future<YesNoPrintResponse> confirmOrPrint(String message) async {
+  log.fine('Showing confirm or print message: $message');
+  if (runningFromTest) {
+    log.message("$message (y/n/print)?");
+  } else {
+    while (true) {
+      stdout
+        ..writeln(log.format(message))
+        ..writeln()
+        ..writeln(log.format('  1) yes'))
+        ..writeln(log.format('  2) no'))
+        ..writeln(log.format('  3) print'));
+
+      var line = stdin.readLineSync().trim();
+      if (new RegExp(r"^[yY1]").hasMatch(line)) return YesNoPrintResponse.yes;
+      if (new RegExp(r"^[nN2]").hasMatch(line)) return YesNoPrintResponse.no;
+      if (new RegExp(r"^[pP3]").hasMatch(line)) return YesNoPrintResponse.print;
+      stdout.writeln(
+          log.format("Your choice of '$line' is not a valid selection."));
+    }
+  }
+
+  return await streamFirst(_stdinLines).then((line) {
+    if (new RegExp(r"^[yY]").hasMatch(line)) return YesNoPrintResponse.yes;
+    if (new RegExp(r"^[nN]").hasMatch(line)) return YesNoPrintResponse.no;
+    if (new RegExp(r"^[pP]").hasMatch(line)) return YesNoPrintResponse.print;
+  });
+}
+
 /// Flushes the stdout and stderr streams, then exits the program with the given
 /// status code.
 ///

lib/src/pubspec.dart

@@ -241,6 +241,33 @@ class Pubspec {
     return _features;
   }
 
+  /// An optional list of paths to *.dart scripts that will be executed
+  /// upon package installation.
+  ///
+  /// This can be expressed in YAML as either a list, or a single string.
+  List<String> get afterInstall {
+    var value = fields['after_install'];
+
+    if (value == null)
+      return [];
+    else if (value is String)
+      return [value];
+    else if (value is YamlList) {
+      for (int i = 0; i < value.nodes.length; i++) {
+        var child = value.nodes[i];
+        if (child.value is! String) {
+          _error('Value at index $i of "after_install" field must be a string.',
+              child.span);
+        }
+      }
+
+      return value.cast<String>();
+    } else {
+      _error('"after_install" field must be a string, or a list thereof."',
+          fields.nodes['after_install'].span);
+    }
+  }
+
   Map<String, Feature> _features;
 
   /// A map from SDK identifiers to constraints on those SDK versions.

test/pubspec_test.dart

@@ -633,6 +633,35 @@ features:
               (pubspec) => pubspec.features);
         });
       });
+
+      group("after_install", () {
+        test("can be null", () {
+          var pubspec = new Pubspec.parse('after_install:', sources);
+          expect(pubspec.afterInstall, isEmpty);
+        });
+
+        test("can be a single string", () {
+          var pubspec =
+              new Pubspec.parse("after_install: tool/foo.dart", sources);
+          expect(pubspec.afterInstall, ["tool/foo.dart"]);
+        });
+
+        test("can be a string list", () {
+          var pubspec = new Pubspec.parse(
+              "after_install: [tool/foo.dart, tool/bar.dart]", sources);
+          expect(pubspec.afterInstall, ["tool/foo.dart", "tool/bar.dart"]);
+        });
+
+        test("must be a list", () {
+          expectPubspecException(
+              "after_install: {foo: bar}", (pubspec) => pubspec.afterInstall);
+        });
+
+        test("must be a string list", () {
+          expectPubspecException(
+              "after_install: [1, 2, 3, 4]", (pubspec) => pubspec.afterInstall);
+        });
+      });
     });
   });
 }