Finish integrating logging.

utils/pub/entrypoint.dart

 // Copyright (c) 2012, 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.
 
 library entrypoint;
 
 import 'io.dart';
 import 'lock_file.dart';
+import 'log.dart' as log;
 import 'package.dart';
 import 'root_source.dart';
 import 'system_cache.dart';
 import 'version.dart';
 import 'version_solver.dart';
 import 'utils.dart';
 
 /**
  * Pub operates over a directed graph of dependencies that starts at a root
  * "entrypoint" package. This is typically the package where the current
@@ skipping 61 matching lines @@
     var pendingOrCompleted = _installs[id];
     if (pendingOrCompleted != null) return pendingOrCompleted;
 
     var packageDir = join(path, id.name);
     var future = ensureDir(dirname(packageDir)).chain((_) {
       return exists(packageDir);
     }).chain((exists) {
       if (!exists) return new Future.immediate(null);
       // TODO(nweiz): figure out when to actually delete the directory, and when
       // we can just re-use the existing symlink.
+      log.fine("Deleting package directory for ${id.name} before install.");
       return deleteDir(packageDir);
     }).chain((_) {
       if (id.source.shouldCache) {
         return cache.install(id).chain(
             (pkg) => createPackageSymlink(id.name, pkg.dir, packageDir));
       } else {
         return id.source.install(id, packageDir).transform((found) {
           if (found) return null;
           // TODO(nweiz): More robust error-handling.
           throw 'Package ${id.name} not found in source "${id.source.name}".';
@@ skipping 60 matching lines @@
   /**
    * Loads the list of concrete package versions from the `pubspec.lock`, if it
    * exists. If it doesn't, this completes to an empty [LockFile].
    *
    * If there's an error reading the `pubspec.lock` file, this will print a
    * warning message and act as though the file doesn't exist.
    */
   Future<LockFile> _loadLockFile() {
     var completer = new Completer<LockFile>();
     var lockFilePath = join(root.dir, 'pubspec.lock');
+
+    log.fine("Loading lockfile.");
     var future = readTextFile(lockFilePath);
 
     future.handleException((_) {
       // If we failed to load the lockfile but it does exist, something's
       // probably wrong and we should notify the user.
       fileExists(lockFilePath).transform((exists) {
         if (!exists) return;
-        printError("Error reading pubspec.lock: ${future.exception}");
+        log.error("Error reading pubspec.lock: ${future.exception}");
       }).then((_) {
+        log.fine("No lock file at $lockFilePath, creating empty one.");
         completer.complete(new LockFile.empty());
       });
 
       return true;
     });
 
     future.then((text) =>
         completer.complete(new LockFile.parse(text, cache.sources)));
     return completer.future;
   }
 
   /**
    * Saves a list of concrete package versions to the `pubspec.lock` file.
    */
   Future _saveLockFile(List<PackageId> packageIds) {
     var lockFile = new LockFile.empty();
     for (var id in packageIds) {
       if (id.source is! RootSource) lockFile.packages[id.name] = id;
     }
 
-    return writeTextFile(join(root.dir, 'pubspec.lock'), lockFile.serialize());
+    var lockFilePath = join(root.dir, 'pubspec.lock');
+    log.fine("Saving lockfile.");
+    return writeTextFile(lockFilePath, lockFile.serialize());
   }
 
   /**
    * Installs a self-referential symlink in the `packages` directory that will
    * allow a package to import its own files using `package:`.
    */
   Future _installSelfReference(_) {
     var linkPath = join(path, root.name);
     return exists(linkPath).chain((exists) {
       // Create the symlink if it doesn't exist.
@@ skipping 69 matching lines @@
    * Creates a symlink to the `packages` directory in [dir] if none exists.
    */
   Future _linkSecondaryPackageDir(String dir) {
     var to = join(dir, 'packages');
     return exists(to).chain((exists) {
       if (exists) return new Future.immediate(null);
       return createSymlink(path, to);
     });
   }
 }