Rename fletch -> dartino

pkg/dartino_compiler/lib/src/worker/developer.dart

 // Copyright (c) 2015, the Dartino 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.md file.
 
-library fletchc.worker.developer;
+library dartino_compiler.worker.developer;
 
 import 'dart:async' show
     Future,
     Stream,
     StreamController,
     Timer;
 
 import 'dart:convert' show
     JSON,
     JsonEncoder,
     UTF8;
 
 import 'dart:io' show
     Directory,
     File,
     FileSystemEntity,
     InternetAddress,
     Platform,
     Process,
     Socket,
     SocketException;
 
 import 'package:sdk_library_metadata/libraries.dart' show
     Category;
 
 import 'package:sdk_services/sdk_services.dart' show
     OutputService,
     SDKServices;
 
-import 'package:fletch_agent/agent_connection.dart' show
+import 'package:dartino_agent/agent_connection.dart' show
     AgentConnection,
     AgentException,
     VmData;
 
-import 'package:fletch_agent/messages.dart' show
+import 'package:dartino_agent/messages.dart' show
     AGENT_DEFAULT_PORT,
     MessageDecodeException;
 
 import 'package:mdns/mdns.dart' show
     MDnsClient,
     ResourceRecord,
     RRType;
 
 import 'package:path/path.dart' show
     join;
@@ skipping 11 matching lines @@
     WriteSnapshotResult;
 
 import '../../program_info.dart' show
     Configuration,
     ProgramInfo,
     ProgramInfoBinary,
     ProgramInfoJson,
     buildProgramInfo;
 
 import '../hub/session_manager.dart' show
-    FletchVm,
+    DartinoVm,
     SessionState,
     Sessions;
 
 import '../hub/client_commands.dart' show
     ClientCommandCode,
     handleSocketErrors;
 
 import '../verbs/infrastructure.dart' show
     ClientCommand,
     CommandSender,
     DiagnosticKind,
-    FletchCompiler,
-    FletchDelta,
+    DartinoCompiler,
+    DartinoDelta,
     IncrementalCompiler,
     WorkerConnection,
     IsolatePool,
     Session,
     SharedTask,
     StreamIterator,
     throwFatalError;
 
-import '../../incremental/fletchc_incremental.dart' show
+import '../../incremental/dartino_compiler_incremental.dart' show
     IncrementalCompilationFailed,
     IncrementalMode,
     parseIncrementalMode,
     unparseIncrementalMode;
 
-export '../../incremental/fletchc_incremental.dart' show
+export '../../incremental/dartino_compiler_incremental.dart' show
     IncrementalMode;
 
-import '../../fletch_compiler.dart' show fletchDeviceType;
+import '../../dartino_compiler.dart' show dartinoDeviceType;
 
 import '../hub/exit_codes.dart' as exit_codes;
 
-import '../../fletch_system.dart' show
-    FletchFunction,
-    FletchSystem;
+import '../../dartino_system.dart' show
+    DartinoFunction,
+    DartinoSystem;
 
 import '../../bytecodes.dart' show
     Bytecode,
     MethodEnd;
 
 import '../diagnostic.dart' show
     throwInternalError;
 
 import '../guess_configuration.dart' show
     executable,
-    fletchVersion,
-    guessFletchVm;
+    dartinoVersion,
+    guessDartinoVm;
 
 import '../device_type.dart' show
     DeviceType,
     parseDeviceType,
     unParseDeviceType;
 
 export '../device_type.dart' show
     DeviceType;
 
 import '../please_report_crash.dart' show
@@ skipping 66 matching lines @@
     disconnectFromAgent(connection);
   }
 }
 
 void disconnectFromAgent(AgentConnection connection) {
   assert(connection.socket != null);
   connection.socket.close();
 }
 
 Future<Null> checkAgentVersion(Uri base, SessionState state) async {
-  String deviceFletchVersion = await withAgentConnection(state,
-      (connection) => connection.fletchVersion());
-  Uri packageFile = await lookForAgentPackage(base, version: fletchVersion);
+  String deviceDartinoVersion = await withAgentConnection(state,
+      (connection) => connection.dartinoVersion());
+  Uri packageFile = await lookForAgentPackage(base, version: dartinoVersion);
   String fixit;
   if (packageFile != null) {
     fixit = "Try running\n"
-      "  'fletch x-upgrade agent in session ${state.name}'.";
+      "  'dartino x-upgrade agent in session ${state.name}'.";
   } else {
     fixit = "Try downloading a matching SDK and running\n"
-      "  'fletch x-upgrade agent in session ${state.name}'\n"
+      "  'dartino x-upgrade agent in session ${state.name}'\n"
       "from the SDK's root directory.";
   }
 
-  if (fletchVersion != deviceFletchVersion) {
+  if (dartinoVersion != deviceDartinoVersion) {
     throwFatalError(DiagnosticKind.agentVersionMismatch,
-        userInput: fletchVersion,
-        additionalUserInput: deviceFletchVersion,
+        userInput: dartinoVersion,
+        additionalUserInput: deviceDartinoVersion,
         fixit: fixit);
   }
 }
 
 Future<Null> startAndAttachViaAgent(Uri base, SessionState state) async {
-  // TODO(wibling): integrate with the FletchVm class, e.g. have a
-  // AgentFletchVm and LocalFletchVm that both share the same interface
+  // TODO(wibling): integrate with the DartinoVm class, e.g. have a
+  // AgentDartinoVm and LocalDartinoVm that both share the same interface
   // where the former is interacting with the agent.
   await checkAgentVersion(base, state);
   VmData vmData = await withAgentConnection(state,
       (connection) => connection.startVm());
-  state.fletchAgentVmId = vmData.id;
+  state.dartinoAgentVmId = vmData.id;
   String host = state.settings.deviceAddress.host;
   await attachToVm(host, vmData.port, state);
   await state.session.disableVMStandardOutput();
 }
 
 Future<Null> startAndAttachDirectly(SessionState state, Uri base) async {
-  String fletchVmPath = state.compilerHelper.fletchVm.toFilePath();
-  state.fletchVm = await FletchVm.start(fletchVmPath, workingDirectory: base);
-  await attachToVm(state.fletchVm.host, state.fletchVm.port, state);
+  String dartinoVmPath = state.compilerHelper.dartinoVm.toFilePath();
+  state.dartinoVm = await DartinoVm.start(dartinoVmPath, workingDirectory: base);
+  await attachToVm(state.dartinoVm.host, state.dartinoVm.port, state);
   await state.session.disableVMStandardOutput();
 }
 
 Future<Null> attachToVm(String host, int port, SessionState state) async {
   Socket socket = await connect(
       host, port, DiagnosticKind.socketVmConnectError, "vmSocket", state);
 
   Session session = new Session(socket, state.compiler, state.stdoutSink,
       state.stderrSink, null);
 
   // Perform handshake with VM which validates that VM and compiler
   // have the same versions.
-  HandShakeResult handShakeResult = await session.handShake(fletchVersion);
+  HandShakeResult handShakeResult = await session.handShake(dartinoVersion);
   if (handShakeResult == null) {
     throwFatalError(DiagnosticKind.handShakeFailed, address: '$host:$port');
   }
   if (!handShakeResult.success) {
     throwFatalError(DiagnosticKind.versionMismatch,
                     address: '$host:$port',
-                    userInput: fletchVersion,
+                    userInput: dartinoVersion,
                     additionalUserInput: handShakeResult.version);
   }
 
   // Enable debugging to be able to communicate with VM when there
   // are errors.
   await session.runCommand(const Debugging());
 
   state.session = session;
 }
 
 Future<int> compile(
     Uri script,
     SessionState state,
     Uri base,
     {bool analyzeOnly: false,
      bool fatalIncrementalFailures: false}) async {
   IncrementalCompiler compiler = state.compiler;
   if (!compiler.isProductionModeEnabled) {
     state.resetCompiler();
   }
   Uri firstScript = state.script;
-  List<FletchDelta> previousResults = state.compilationResults;
+  List<DartinoDelta> previousResults = state.compilationResults;
 
-  FletchDelta newResult;
+  DartinoDelta newResult;
   try {
     if (analyzeOnly) {
       state.resetCompiler();
       state.log("Analyzing '$script'");
       return await compiler.analyze(script, base);
     } else if (previousResults.isEmpty) {
       state.script = script;
       await compiler.compile(script, base);
       newResult = compiler.computeInitialDelta();
     } else {
@@ skipping 52 matching lines @@
 
 Future<Settings> createSettings(
     String sessionName,
     Uri uri,
     Uri cwd,
     Uri configFileUri,
     CommandSender commandSender,
     StreamIterator<ClientCommand> commandIterator) async {
   bool userProvidedSettings = uri != null;
   if (!userProvidedSettings) {
-    // Try to find a $sessionName.fletch-settings file starting from the current
+    // Try to find a $sessionName.dartino-settings file starting from the current
     // working directory and walking up its parent directories.
-    uri = await findFile(cwd, '$sessionName.fletch-settings');
+    uri = await findFile(cwd, '$sessionName.dartino-settings');
 
-    // If no $sessionName.fletch-settings file is found, try to find the
+    // If no $sessionName.dartino-settings file is found, try to find the
     // settings template file (in the SDK or git repo) by looking for a
-    // .fletch-settings file starting from the fletch executable's directory
+    // .dartino-settings file starting from the dartino executable's directory
     // and walking up its parent directory chain.
     if (uri == null) {
-      uri = await findFile(executable, '.fletch-settings');
+      uri = await findFile(executable, '.dartino-settings');
       if (uri != null) print('Using template settings file $uri');
     }
   }
 
   Settings settings = new Settings.empty();
   if (uri != null) {
     String jsonLikeData = await new File.fromUri(uri).readAsString();
     settings = parseSettings(jsonLikeData, uri);
   }
   if (userProvidedSettings) return settings;
 
   // TODO(wibling): get rid of below special handling of the sessions 'remote'
-  // and 'local' and come up with a fletch project concept that can contain
+  // and 'local' and come up with a dartino project concept that can contain
   // these settings.
   Uri packagesUri;
   Address address;
   switch (sessionName) {
     case "remote":
-      uri = configFileUri.resolve("remote.fletch-settings");
+      uri = configFileUri.resolve("remote.dartino-settings");
       Settings remoteSettings = await readSettings(uri);
       if (remoteSettings != null) return remoteSettings;
-      packagesUri = executable.resolve("fletch-sdk.packages");
+      packagesUri = executable.resolve("dartino-sdk.packages");
       address = await readAddressFromUser(commandSender, commandIterator);
       if (address == null) {
         // Assume user aborted data entry.
         return settings;
       }
       break;
 
     case "local":
-      uri = configFileUri.resolve("local.fletch-settings");
+      uri = configFileUri.resolve("local.dartino-settings");
       Settings localSettings = await readSettings(uri);
       if (localSettings != null) return localSettings;
       // TODO(ahe): Use mock packages here.
-      packagesUri = executable.resolve("fletch-sdk.packages");
+      packagesUri = executable.resolve("dartino-sdk.packages");
       break;
 
     default:
       return settings;
   }
 
   if (!await new File.fromUri(packagesUri).exists()) {
     packagesUri = null;
   }
   settings = settings.copyWith(packages: packagesUri, deviceAddress: address);
@@ skipping 25 matching lines @@
         // session because we use canonical input processing (Unix line
         // buffering), but it doesn't work in general. So we should fix that.
         String line = UTF8.decode(command.data).trim();
         if (line.isEmpty && devices.isEmpty) {
           commandSender.sendStdout("\n");
           // [discoverDevices] will print out the list of device with their
           // IP address, hostname, and agent version.
           devices = await discoverDevices(prefixWithNumber: true);
           if (devices.isEmpty) {
             commandSender.sendStdout(
-                "Couldn't find Fletch capable devices\n");
+                "Couldn't find Dartino capable devices\n");
             commandSender.sendStdout(message);
           } else {
             if (devices.length == 1) {
               commandSender.sendStdout("\n");
               commandSender.sendStdout("Press Enter to use this device");
             } else {
               commandSender.sendStdout("\n");
               commandSender.sendStdout(
-                  "Found ${devices.length} Fletch capable devices\n");
+                  "Found ${devices.length} Dartino capable devices\n");
               commandSender.sendStdout(
                   "Please enter the number or the IP address of "
                   "the remote device you would like to use "
                   "(press Enter to use the first device): ");
             }
           }
         } else {
           bool checkedIndex = false;
           if (devices.length > 0) {
             if (line.isEmpty) {
@@ skipping 24 matching lines @@
         return null;
     }
   }
   return null;
 }
 
 SessionState createSessionState(
     String name,
     Settings settings,
     {Uri libraryRoot,
-     Uri fletchVm,
+     Uri dartinoVm,
      Uri nativesJson}) {
   if (settings == null) {
     settings = const Settings.empty();
   }
-  List<String> compilerOptions = const bool.fromEnvironment("fletchc-verbose")
+  List<String> compilerOptions = const bool.fromEnvironment("dartino_compiler-verbose")
       ? <String>['--verbose'] : <String>[];
   compilerOptions.addAll(settings.options);
   Uri packageConfig = settings.packages;
   if (packageConfig == null) {
-    packageConfig = executable.resolve("fletch-sdk.packages");
+    packageConfig = executable.resolve("dartino-sdk.packages");
   }
 
   DeviceType deviceType = settings.deviceType ??
-      parseDeviceType(fletchDeviceType);
+      parseDeviceType(dartinoDeviceType);
 
   String platform = (deviceType == DeviceType.embedded)
-      ? "fletch_embedded.platform"
-      : "fletch_mobile.platform";
+      ? "dartino_embedded.platform"
+      : "dartino_mobile.platform";
 
-  FletchCompiler compilerHelper = new FletchCompiler(
+  DartinoCompiler compilerHelper = new DartinoCompiler(
       options: compilerOptions,
       packageConfig: packageConfig,
       environment: settings.constants,
       platform: platform,
       libraryRoot: libraryRoot,
-      fletchVm: fletchVm,
+      dartinoVm: dartinoVm,
       nativesJson: nativesJson);
 
   return new SessionState(
       name, compilerHelper,
       compilerHelper.newIncrementalCompiler(settings.incrementalMode),
       settings);
 }
 
 Future runWithDebugger(
     List<String> commands,
@@ skipping 14 matching lines @@
       session.debug(inputGenerator(), Uri.base, state, echo: true) :
       session.debug(
           new Stream<String>.fromIterable(commands), Uri.base, state,
           echo: true);
 }
 
 Future<int> run(
     SessionState state,
     {List<String> testDebuggerCommands,
      bool terminateDebugger: true}) async {
-  List<FletchDelta> compilationResults = state.compilationResults;
+  List<DartinoDelta> compilationResults = state.compilationResults;
   Session session = state.session;
 
-  for (FletchDelta delta in compilationResults) {
+  for (DartinoDelta delta in compilationResults) {
     await session.applyDelta(delta);
   }
 
   if (testDebuggerCommands != null) {
     await runWithDebugger(testDebuggerCommands, session, state);
     return 0;
   }
 
   session.silent = true;
 
   await session.enableDebugger();
   await session.spawnProcess();
   var command = await session.debugRun();
 
   int exitCode = exit_codes.COMPILER_EXITCODE_CRASH;
   if (command == null) {
     await session.kill();
     await session.shutdown();
-    throwInternalError("No command received from Fletch VM");
+    throwInternalError("No command received from Dartino VM");
   }
 
   Future printException() async {
     if (!session.loaded) {
       print('### process not loaded, cannot print uncaught exception');
       return;
     }
     debug.RemoteObject exception = await session.uncaughtException();
     if (exception != null) {
       print(session.exceptionToString(exception));
@@ skipping 26 matching lines @@
         exitCode = exit_codes.DART_VM_EXITCODE_COMPILE_TIME_ERROR;
         await printTrace();
         // TODO(ahe): Continue to unwind stack?
         break;
 
       case VmCommandCode.ProcessTerminated:
         exitCode = 0;
         break;
 
       case VmCommandCode.ConnectionError:
-        state.log("Error on connection to Fletch VM: ${command.error}");
+        state.log("Error on connection to Dartino VM: ${command.error}");
         exitCode = exit_codes.COMPILER_EXITCODE_CONNECTION_ERROR;
         break;
 
       default:
-        throwInternalError("Unexpected result from Fletch VM: '$command'");
+        throwInternalError("Unexpected result from Dartino VM: '$command'");
         break;
     }
   } finally {
     if (terminateDebugger) {
       await state.terminateSession();
     } else {
       // If the session terminated due to a ConnectionError or the program
       // finished don't reuse the state's session.
       if (session.terminated) {
         state.session = null;
       }
       session.silent = false;
     }
   };
 
   return exitCode;
 }
 
 Future<int> export(SessionState state,
                    Uri snapshot,
                    {bool binaryProgramInfo: false}) async {
-  List<FletchDelta> compilationResults = state.compilationResults;
+  List<DartinoDelta> compilationResults = state.compilationResults;
   Session session = state.session;
   state.session = null;
 
-  for (FletchDelta delta in compilationResults) {
+  for (DartinoDelta delta in compilationResults) {
     await session.applyDelta(delta);
   }
 
   var result = await session.writeSnapshot(snapshot.toFilePath());
   if (result is WriteSnapshotResult) {
     WriteSnapshotResult snapshotResult = result;
 
     await session.shutdown();
 
     ProgramInfo info =
@@ skipping 18 matching lines @@
 Future<int> compileAndAttachToVmThen(
     CommandSender commandSender,
     StreamIterator<ClientCommand> commandIterator,
     SessionState state,
     Uri script,
     Uri base,
     bool waitForVmExit,
     Future<int> action(),
     {ClientEventHandler eventHandler}) async {
   bool startedVmDirectly = false;
-  List<FletchDelta> compilationResults = state.compilationResults;
+  List<DartinoDelta> compilationResults = state.compilationResults;
   if (compilationResults.isEmpty || script != null) {
     if (script == null) {
       throwFatalError(DiagnosticKind.noFileTarget);
     }
     int exitCode = await compile(script, state, base);
     if (exitCode != 0) return exitCode;
     compilationResults = state.compilationResults;
     assert(compilationResults != null);
   }
 
   Session session = state.session;
   if (session != null && session.loaded) {
     // We cannot reuse a session that has already been loaded. Loading
     // currently implies that some of the code has been run.
     if (state.explicitAttach) {
-      // If the user explicitly called 'fletch attach' we cannot
+      // If the user explicitly called 'dartino attach' we cannot
       // create a new VM session since we don't know if the vm is
       // running locally or remotely and if running remotely there
       // is no guarantee there is an agent to start a new vm.
       //
       // The UserSession is invalid in its current state as the
       // vm session (aka. session in the code here) has already
       // been loaded and run some code.
       throwFatalError(DiagnosticKind.sessionInvalidState,
           sessionName: state.name);
     }
     state.log('Cannot reuse existing VM session, creating new.');
     await state.terminateSession();
     session = null;
   }
   if (session == null) {
     if (state.settings.deviceAddress != null) {
       await startAndAttachViaAgent(base, state);
       // TODO(wibling): read stdout from agent.
     } else {
       startedVmDirectly = true;
       await startAndAttachDirectly(state, base);
-      state.fletchVm.stdoutLines.listen((String line) {
+      state.dartinoVm.stdoutLines.listen((String line) {
           commandSender.sendStdout("$line\n");
         });
-      state.fletchVm.stderrLines.listen((String line) {
+      state.dartinoVm.stderrLines.listen((String line) {
           commandSender.sendStderr("$line\n");
         });
     }
     session = state.session;
     assert(session != null);
   }
 
   eventHandler ??= defaultClientEventHandler(state, commandIterator);
   setupClientInOut(state, commandSender, eventHandler);
 
   int exitCode = exit_codes.COMPILER_EXITCODE_CRASH;
   try {
     exitCode = await action();
   } catch (error, trace) {
     print(error);
     if (trace != null) {
       print(trace);
     }
   } finally {
     if (waitForVmExit && startedVmDirectly) {
-      exitCode = await state.fletchVm.exitCode;
+      exitCode = await state.dartinoVm.exitCode;
     }
     state.detachCommandSender();
   }
   return exitCode;
 }
 
 void setupClientInOut(
     SessionState state,
     CommandSender commandSender,
     ClientEventHandler eventHandler) {
   // Forward output going into the state's outputSink using the passed in
   // commandSender. This typically forwards output to the hub (main isolate)
-  // which forwards it on to stdout of the Fletch C++ client.
+  // which forwards it on to stdout of the Dartino C++ client.
   state.attachCommandSender(commandSender);
 
-  // Start event handling for input passed from the Fletch C++ client.
+  // Start event handling for input passed from the Dartino C++ client.
   eventHandler(state.session);
 
   // Let the hub (main isolate) know that event handling has been started.
   commandSender.sendEventLoopStarted();
 }
 
 /// Return a default client event handler bound to the current session's
 /// commandIterator and state.
 /// This handler only takes care of signals coming from the client.
 ClientEventHandler defaultClientEventHandler(
     SessionState state,
     StreamIterator<ClientCommand> commandIterator) {
   return (Session session) async {
     while (await commandIterator.moveNext()) {
       ClientCommand command = commandIterator.current;
       switch (command.code) {
         case ClientCommandCode.Signal:
           int signalNumber = command.data;
           handleSignal(state, signalNumber);
           break;
         default:
           state.log("Unhandled command from client: $command");
       }
     }
   };
 }
 
 void handleSignal(SessionState state, int signalNumber) {
   state.log("Received signal $signalNumber");
-  if (!state.hasRemoteVm && state.fletchVm == null) {
+  if (!state.hasRemoteVm && state.dartinoVm == null) {
     // This can happen if a user has attached to a vm using the "attach" verb
     // in which case we don't forward the signal to the vm.
     // TODO(wibling): Determine how to interpret the signal for the persistent
     // process.
     state.log('Signal $signalNumber ignored. VM was manually attached.');
     print('Signal $signalNumber ignored. VM was manually attached.');
     return;
   }
   if (state.hasRemoteVm) {
     signalAgentVm(state, signalNumber);
   } else {
-    assert(state.fletchVm.process != null);
-    int vmPid = state.fletchVm.process.pid;
+    assert(state.dartinoVm.process != null);
+    int vmPid = state.dartinoVm.process.pid;
     Process.runSync("kill", ["-$signalNumber", "$vmPid"]);
   }
 }
 
 Future signalAgentVm(SessionState state, int signalNumber) async {
   await withAgentConnection(state, (connection) {
-    return connection.signalVm(state.fletchAgentVmId, signalNumber);
+    return connection.signalVm(state.dartinoAgentVmId, signalNumber);
   });
 }
 
 String extractVersion(Uri uri) {
   List<String> nameParts = uri.pathSegments.last.split('_');
-  if (nameParts.length != 3 || nameParts[0] != 'fletch-agent') {
+  if (nameParts.length != 3 || nameParts[0] != 'dartino-agent') {
     throwFatalError(DiagnosticKind.upgradeInvalidPackageName);
   }
   String version = nameParts[1];
   // create_debian_packages.py adds a '-1' after the hash in the package name.
   if (version.endsWith('-1')) {
     version = version.substring(0, version.length - 2);
   }
   return version;
 }
 
-/// Try to locate an Fletch agent package file assuming the normal SDK layout
+/// Try to locate an Dartino agent package file assuming the normal SDK layout
 /// with SDK base directory [base].
 ///
 /// If the parameter [version] is passed, the Uri is only returned, if
 /// the version matches.
 Future<Uri> lookForAgentPackage(Uri base, {String version}) async {
   String platform = "raspberry-pi2";
   Uri platformUri = base.resolve("platforms/$platform");
   Directory platformDir = new Directory.fromUri(platformUri);
 
   // Try to locate the agent package in the SDK for the selected platform.
   Uri sdkAgentPackage;
   if (await platformDir.exists()) {
     for (FileSystemEntity entry in platformDir.listSync()) {
       Uri uri = entry.uri;
       String name = uri.pathSegments.last;
-      if (name.startsWith('fletch-agent') &&
+      if (name.startsWith('dartino-agent') &&
           name.endsWith('.deb') &&
           (version == null || extractVersion(uri) == version)) {
         return uri;
       }
     }
   }
   return null;
 }
 
 Future<Uri> readPackagePathFromUser(
@@ skipping 122 matching lines @@
 
   if (!await new File.fromUri(packageUri).exists()) {
     print('File not found: $packageUri');
     return 1;
   }
 
   Version version = parseVersion(extractVersion(packageUri));
 
   Version existingVersion = parseVersion(
       await withAgentConnection(state,
-          (connection) => connection.fletchVersion()));
+          (connection) => connection.dartinoVersion()));
 
   if (existingVersion == version) {
     print('Target device is already at $version');
     return 0;
   }
 
   print("Attempting to upgrade device from "
       "$existingVersion to $version");
 
   if (existingVersion.isGreaterThan(version)) {
@@ skipping 18 matching lines @@
         break;
 
       default:
         throwInternalError("Unexpected ${command.code}");
         return null;
       }
     }
   }
 
   List<int> data = await new File.fromUri(packageUri).readAsBytes();
-  print("Sending package to fletch agent");
+  print("Sending package to dartino agent");
   await withAgentConnection(state,
       (connection) => connection.upgradeAgent(version.toString(), data));
-  print("Transfer complete, waiting for the Fletch agent to restart. "
+  print("Transfer complete, waiting for the Dartino agent to restart. "
       "This can take a few seconds.");
 
   Version newVersion;
   int remainingTries = 20;
   // Wait for the agent to come back online to verify the version.
   while (--remainingTries > 0) {
     await new Future.delayed(const Duration(seconds: 1));
     try {
       // TODO(karlklose): this functionality should be shared with connect.
       Socket socket = await Socket.connect(
           state.settings.deviceAddress.host,
           state.settings.deviceAddress.port);
       handleSocketErrors(socket, "pollAgentVersion", log: (String info) {
         state.log("Connected to TCP waitForAgentUpgrade $info");
       });
       AgentConnection connection = new AgentConnection(socket);
-      newVersion = parseVersion(await connection.fletchVersion());
+      newVersion = parseVersion(await connection.dartinoVersion());
       disconnectFromAgent(connection);
       if (newVersion != existingVersion) {
         break;
       }
     } on SocketException catch (e) {
       // Ignore this error and keep waiting.
     }
   }
 
   if (newVersion == existingVersion) {
     print("Failed to upgrade: the device is still at the old version.");
     print("Try running x-upgrade again. "
         "If the upgrade fails again, try rebooting the device.");
     return 1;
   } else if (newVersion == null) {
-    print("Could not connect to Fletch agent after upgrade.");
-    print("Try running 'fletch show devices' later to see if it has been"
+    print("Could not connect to Dartino agent after upgrade.");
+    print("Try running 'dartino show devices' later to see if it has been"
         " restarted. If the device does not show up, try rebooting it.");
     return 1;
   } else {
     print("Upgrade successful.");
   }
 
   return 0;
 }
 
 Future<int> downloadTools(
@@ skipping 19 matching lines @@
       throwUnsupportedPlatform();
     }
     if (result.exitCode != 0) {
         throwInternalError(
             "Failed to decompress ${zipFile.path} to ${destination.path}, "
             "error = ${result.exitCode}");
     }
   }
 
   const String gcsRoot = "https://storage.googleapis.com";
-  String gcsBucket = "fletch-archive";
+  String gcsBucket = "dartino-archive";
 
   Future downloadTool(String gcsPath, String zipFile, String toolName) async {
     Uri url = Uri.parse("$gcsRoot/$gcsBucket/$gcsPath/$zipFile");
     Directory tmpDir = Directory.systemTemp.createTempSync("fletch_download");
     File tmpZip = new File(join(tmpDir.path, zipFile));
 
     OutputService outputService =
         new OutputService(commandSender.sendStdout, state.log);
     SDKServices service = new SDKServices(outputService);
     print("Downloading: $toolName");
     state.log("Downloading $toolName from $url to $tmpZip");
     await service.downloadWithProgress(url, tmpZip);
     print(""); // service.downloadWithProgress does not write newline when done.
 
     // In the SDK, the tools directory is at the same level as the
     // internal (and bin) directory.
     Directory toolsDirectory =
         new Directory.fromUri(executable.resolve('../tools'));
     state.log("Decompressing ${tmpZip.path} to ${toolsDirectory.path}");
     await decompressFile(tmpZip, toolsDirectory);
     state.log("Deleting temporary directory ${tmpDir.path}");
     await tmpDir.delete(recursive: true);
   }
 
   String gcsPath;
 
-  Version version = parseVersion(fletchVersion);
+  Version version = parseVersion(dartinoVersion);
   if (version.isEdgeVersion) {
     print("WARNING: For bleeding edge a fixed image is used.");
     // For edge versions download use a well known version for now.
     var knownVersion = "0.3.0-edge.3c85dbafe006eb2ce16545aaf3df1352fa7a4500";
-    gcsBucket = "fletch-temporary";
+    gcsBucket = "dartino-temporary";
     gcsPath = "channels/be/raw/$knownVersion/sdk";
   } else if (version.isDevVersion) {
     // TODO(sgjesse): Change this to channels/dev/release at some point.
     gcsPath = "channels/dev/raw/$version/sdk";
   } else {
     print("Stable version not supported. Got version $version.");
   }
 
   String osName;
   if (Platform.isLinux) {
@@ skipping 56 matching lines @@
 Future<String> getAgentVersion(InternetAddress host, int port) async {
   Socket socket;
   try {
     socket = await Socket.connect(host, port);
     handleSocketErrors(socket, "getAgentVersionSocket");
   } on SocketException catch (e) {
     return 'Error: no agent: $e';
   }
   try {
     AgentConnection connection = new AgentConnection(socket);
-    return await connection.fletchVersion();
+    return await connection.dartinoVersion();
   } finally {
     socket.close();
   }
 }
 
 Future<List<InternetAddress>> discoverDevices(
     {bool prefixWithNumber: false}) async {
   const ipV4AddressLength = 'xxx.xxx.xxx.xxx'.length;
   print("Looking for Dartino capable devices (will search for 5 seconds)...");
   MDnsClient client = new MDnsClient();
@@ skipping 314 matching lines @@
         "device_type",
         deviceType == null ? null : unParseDeviceType(deviceType));
     addIfNotNull(
         "incremental_mode",
         incrementalMode == null
             ? null : unparseIncrementalMode(incrementalMode));
 
     return result;
   }
 }