artifacts.dart 8.89 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14
// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import 'base/context.dart';
import 'base/file_system.dart';
import 'base/platform.dart';
import 'build_info.dart';
import 'globals.dart';

enum Artifact {
  dartIoEntriesTxt,
  dartVmEntryPointsTxt,
  genSnapshot,
15
  flutterTester,
16 17
  snapshotDart,
  flutterFramework,
18 19
  vmSnapshotData,
  isolateSnapshotData
20 21 22 23 24 25 26 27 28 29
}

String _artifactToFileName(Artifact artifact) {
  switch (artifact) {
    case Artifact.dartIoEntriesTxt:
      return 'dart_io_entries.txt';
    case Artifact.dartVmEntryPointsTxt:
      return 'dart_vm_entry_points.txt';
    case Artifact.genSnapshot:
      return 'gen_snapshot';
30
    case Artifact.flutterTester:
31
      return 'flutter_tester';
32 33 34 35
    case Artifact.snapshotDart:
      return 'snapshot.dart';
    case Artifact.flutterFramework:
      return 'Flutter.framework';
36 37 38 39
    case Artifact.vmSnapshotData:
      return 'vm_isolate_snapshot.bin';
    case Artifact.isolateSnapshotData:
      return 'isolate_snapshot.bin';
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
  }
  assert(false, 'Invalid artifact $artifact.');
  return null;
}

// Manages the engine artifacts of Flutter.
abstract class Artifacts {
  static Artifacts get instance => context[Artifacts];

  static void useLocalEngine(String engineSrcPath, String engineOutPath) {
    context.setVariable(Artifacts, new LocalEngineArtifacts(engineSrcPath, engineOutPath));
  }

  // Returns the requested [artifact] for the [platform] and [mode] combination.
  String getArtifactPath(Artifact artifact, [TargetPlatform platform, BuildMode mode]);

  // Returns which set of engine artifacts is currently used for the [platform]
  // and [mode] combination.
  String getEngineType(TargetPlatform platform, [BuildMode mode]);
}

/// Manages the engine artifacts downloaded to the local cache.
class CachedArtifacts extends Artifacts {

  @override
  String getArtifactPath(Artifact artifact, [TargetPlatform platform, BuildMode mode]) {
    platform ??= _currentHostPlatform;
    switch (platform) {
      case TargetPlatform.android_arm:
      case TargetPlatform.android_x64:
      case TargetPlatform.android_x86:
        return _getAndroidArtifactPath(artifact, platform, mode);
      case TargetPlatform.ios:
        return _getIosArtifactPath(artifact, platform, mode);
      case TargetPlatform.darwin_x64:
      case TargetPlatform.linux_x64:
76
      case TargetPlatform.windows_x64:
77
      case TargetPlatform.fuchsia:
78 79 80 81 82 83 84 85 86 87 88 89
        return _getHostArtifactPath(artifact, platform);
    }
    assert(false, 'Invalid platform $platform.');
    return null;
  }

  @override
  String getEngineType(TargetPlatform platform, [BuildMode mode]){
    return fs.path.basename(_getEngineArtifactsPath(platform, mode));
  }

  String _getAndroidArtifactPath(Artifact artifact, TargetPlatform platform, BuildMode mode) {
90
    final String engineDir = _getEngineArtifactsPath(platform, mode);
91 92 93 94 95 96 97
    switch (artifact) {
      case Artifact.dartIoEntriesTxt:
      case Artifact.dartVmEntryPointsTxt:
        assert(mode != BuildMode.debug, 'Artifact $artifact only available in non-debug mode.');
        return fs.path.join(engineDir, _artifactToFileName(artifact));
      case Artifact.genSnapshot:
        assert(mode != BuildMode.debug, 'Artifact $artifact only available in non-debug mode.');
98
        final String hostPlatform = getNameForHostPlatform(getCurrentHostPlatform());
99 100 101 102 103 104 105 106
        return fs.path.join(engineDir, hostPlatform, _artifactToFileName(artifact));
      default:
        assert(false, 'Artifact $artifact not available for platform $platform.');
        return null;
    }
  }

  String _getIosArtifactPath(Artifact artifact, TargetPlatform platform, BuildMode mode) {
107
    final String engineDir = _getEngineArtifactsPath(platform, mode);
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
    switch (artifact) {
      case Artifact.dartIoEntriesTxt:
      case Artifact.dartVmEntryPointsTxt:
      case Artifact.genSnapshot:
      case Artifact.snapshotDart:
      case Artifact.flutterFramework:
        return fs.path.join(engineDir, _artifactToFileName(artifact));
      default:
        assert(false, 'Artifact $artifact not available for platform $platform.');
        return null;
    }
  }

  String _getHostArtifactPath(Artifact artifact, TargetPlatform platform) {
    switch (artifact) {
123 124 125 126
      case Artifact.genSnapshot:
        // For script snapshots any gen_snapshot binary will do. Returning gen_snapshot for
        // android_arm in profile mode because it is available on all supported host platforms.
        return _getAndroidArtifactPath(artifact, TargetPlatform.android_arm, BuildMode.profile);
127
      case Artifact.flutterTester:
128 129
        if (platform == TargetPlatform.windows_x64)
          throw new UnimplementedError('Artifact $artifact not available on platfrom $platform.');
130 131
        continue fallThrough;
      fallThrough:
132 133
      case Artifact.vmSnapshotData:
      case Artifact.isolateSnapshotData:
134 135
        final String engineArtifactsPath = cache.getArtifactDirectory('engine').path;
        final String platformDirName = getNameForTargetPlatform(platform);
136 137 138 139 140
        return fs.path.join(engineArtifactsPath, platformDirName, _artifactToFileName(artifact));
      default:
        assert(false, 'Artifact $artifact not available for platform $platform.');
        return null;
    }
141 142
    assert(false, 'Artifact $artifact not available for platform $platform.');
    return null;
143 144 145
  }

  String _getEngineArtifactsPath(TargetPlatform platform, [BuildMode mode]) {
146 147
    final String engineDir = cache.getArtifactDirectory('engine').path;
    final String platformName = getNameForTargetPlatform(platform);
148 149 150
    switch (platform) {
      case TargetPlatform.linux_x64:
      case TargetPlatform.darwin_x64:
151
      case TargetPlatform.windows_x64:
152
      case TargetPlatform.fuchsia:
153 154 155 156 157 158 159
        assert(mode == null, 'Platform $platform does not support different build modes.');
        return fs.path.join(engineDir, platformName);
      case TargetPlatform.ios:
      case TargetPlatform.android_arm:
      case TargetPlatform.android_x64:
      case TargetPlatform.android_x86:
        assert(mode != null, 'Need to specify a build mode for platform $platform.');
160
        final String suffix = mode != BuildMode.debug ? '-${getModeName(mode)}' : '';
161 162 163 164 165 166 167 168 169 170 171
        return fs.path.join(engineDir, platformName + suffix);
    }
    assert(false, 'Invalid platform $platform.');
    return null;
  }

  TargetPlatform get _currentHostPlatform {
    if (platform.isMacOS)
      return TargetPlatform.darwin_x64;
    if (platform.isLinux)
      return TargetPlatform.linux_x64;
172 173
    if (platform.isWindows)
      return TargetPlatform.windows_x64;
174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
    throw new UnimplementedError('Host OS not supported.');
  }
}

/// Manages the artifacts of a locally built engine.
class LocalEngineArtifacts extends Artifacts {
  final String _engineSrcPath;
  final String engineOutPath; // TODO(goderbauer): This should be private.

  LocalEngineArtifacts(this._engineSrcPath, this.engineOutPath);

  @override
  String getArtifactPath(Artifact artifact, [TargetPlatform platform, BuildMode mode]) {
    switch (artifact) {
      case Artifact.dartIoEntriesTxt:
        return fs.path.join(_engineSrcPath, 'dart', 'runtime', 'bin', _artifactToFileName(artifact));
      case Artifact.dartVmEntryPointsTxt:
        return fs.path.join(_engineSrcPath, 'flutter', 'runtime', _artifactToFileName(artifact));
      case Artifact.snapshotDart:
        return fs.path.join(_engineSrcPath, 'flutter', 'lib', 'snapshot', _artifactToFileName(artifact));
      case Artifact.genSnapshot:
195
        return _genSnapshotPath(platform, mode);
196 197
      case Artifact.flutterTester:
        return _flutterTesterPath(platform);
198 199 200
      case Artifact.isolateSnapshotData:
      case Artifact.vmSnapshotData:
        return fs.path.join(engineOutPath, 'gen', 'flutter', 'lib', 'snapshot', _artifactToFileName(artifact));
201 202 203 204 205 206 207 208 209 210 211 212
      case Artifact.flutterFramework:
        return fs.path.join(engineOutPath, _artifactToFileName(artifact));
    }
    assert(false, 'Invalid artifact $artifact.');
    return null;
  }

  @override
  String getEngineType(TargetPlatform platform, [BuildMode mode]) {
    return fs.path.basename(engineOutPath);
  }

213
  String _genSnapshotPath(TargetPlatform platform, BuildMode mode) {
214
    String clang;
215
    if (platform == TargetPlatform.ios || mode == BuildMode.debug) {
216 217 218 219 220 221 222
      clang = 'clang_x64';
    } else {
      clang = getCurrentHostPlatform() == HostPlatform.darwin_x64 ? 'clang_i386' : 'clang_x86';
    }
    return fs.path.join(engineOutPath, clang, _artifactToFileName(Artifact.genSnapshot));
  }

223
  String _flutterTesterPath(TargetPlatform platform) {
224
    if (getCurrentHostPlatform() == HostPlatform.linux_x64) {
225
      return fs.path.join(engineOutPath, _artifactToFileName(Artifact.flutterTester));
226
    } else if (getCurrentHostPlatform() == HostPlatform.darwin_x64) {
227
      return fs.path.join(engineOutPath, 'FlutterTester.app', 'Contents', 'MacOS', 'FlutterTester');
228 229 230 231
    }
    throw new Exception('Unsupported platform $platform.');
  }
}