| /* |
| * Copyright 2014-present Facebook, Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may |
| * not use this file except in compliance with the License. You may obtain |
| * a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package com.facebook.buck.cli; |
| |
| import com.android.ddmlib.AdbCommandRejectedException; |
| import com.android.ddmlib.CollectingOutputReceiver; |
| import com.android.ddmlib.IDevice; |
| import com.android.ddmlib.InstallException; |
| import com.facebook.buck.android.agent.util.AgentUtil; |
| import com.facebook.buck.event.BuckEventBus; |
| import com.facebook.buck.event.ConsoleEvent; |
| import com.facebook.buck.event.TraceEventLogger; |
| import com.facebook.buck.io.ProjectFilesystem; |
| import com.facebook.buck.log.Logger; |
| import com.facebook.buck.rules.ExopackageInfo; |
| import com.facebook.buck.rules.InstallableApk; |
| import com.facebook.buck.step.ExecutionContext; |
| import com.facebook.buck.util.NamedTemporaryFile; |
| import com.google.common.annotations.VisibleForTesting; |
| import com.google.common.base.Charsets; |
| import com.google.common.base.Function; |
| import com.google.common.base.Joiner; |
| import com.google.common.base.Optional; |
| import com.google.common.base.Preconditions; |
| import com.google.common.base.Predicates; |
| import com.google.common.base.Splitter; |
| import com.google.common.collect.FluentIterable; |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.ImmutableMap; |
| import com.google.common.collect.ImmutableMultimap; |
| import com.google.common.collect.ImmutableSet; |
| import com.google.common.collect.Maps; |
| import com.google.common.collect.Sets; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.OutputStream; |
| import java.net.Socket; |
| import java.nio.file.Files; |
| import java.nio.file.Path; |
| import java.nio.file.Paths; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.concurrent.atomic.AtomicInteger; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| import javax.annotation.Nullable; |
| |
| /** |
| * ExopackageInstaller manages the installation of apps with the "exopackage" flag set to true. |
| */ |
| public class ExopackageInstaller { |
| |
| private static final Logger LOG = Logger.get(ExopackageInstaller.class); |
| |
| /** |
| * Prefix of the path to the agent apk on the device. |
| */ |
| private static final String AGENT_DEVICE_PATH = "/data/app/" + AgentUtil.AGENT_PACKAGE_NAME; |
| |
| /** |
| * Command line to invoke the agent on the device. |
| */ |
| private static final String JAVA_AGENT_COMMAND = |
| "dalvikvm -classpath " + |
| AGENT_DEVICE_PATH + "-1.apk:" + AGENT_DEVICE_PATH + "-2.apk:" + |
| AGENT_DEVICE_PATH + "-1/base.apk:" + AGENT_DEVICE_PATH + "-2/base.apk " + |
| "com.facebook.buck.android.agent.AgentMain "; |
| |
| /** |
| * Maximum length of commands that can be passed to "adb shell". |
| */ |
| private static final int MAX_ADB_COMMAND_SIZE = 1019; |
| |
| private static final Path SECONDARY_DEX_DIR = Paths.get("secondary-dex"); |
| |
| private static final Path NATIVE_LIBS_DIR = Paths.get("native-libs"); |
| |
| @VisibleForTesting |
| static final Pattern DEX_FILE_PATTERN = Pattern.compile("secondary-([0-9a-f]+)\\.[\\w.-]*"); |
| |
| @VisibleForTesting |
| static final Pattern NATIVE_LIB_PATTERN = Pattern.compile("native-([0-9a-f]+)\\.so"); |
| |
| private final ProjectFilesystem projectFilesystem; |
| private final BuckEventBus eventBus; |
| private final AdbHelper adbHelper; |
| private final InstallableApk apkRule; |
| private final String packageName; |
| private final Path dataRoot; |
| |
| private final ExopackageInfo exopackageInfo; |
| |
| /** |
| * The next port number to use for communicating with the agent on a device. |
| * This resets for every instance of ExopackageInstaller, |
| * but is incremented for every device we are installing on when using "-x". |
| */ |
| private final AtomicInteger nextAgentPort = new AtomicInteger(2828); |
| |
| @VisibleForTesting |
| static class PackageInfo { |
| final String apkPath; |
| final String nativeLibPath; |
| final String versionCode; |
| private PackageInfo(String apkPath, String nativeLibPath, String versionCode) { |
| this.nativeLibPath = nativeLibPath; |
| this.apkPath = apkPath; |
| this.versionCode = versionCode; |
| } |
| } |
| |
| public ExopackageInstaller( |
| ExecutionContext context, |
| AdbHelper adbHelper, |
| InstallableApk apkRule) { |
| this.adbHelper = adbHelper; |
| this.projectFilesystem = context.getProjectFilesystem(); |
| this.eventBus = context.getBuckEventBus(); |
| this.apkRule = apkRule; |
| this.packageName = AdbHelper.tryToExtractPackageNameFromManifest(apkRule, context); |
| this.dataRoot = Paths.get("/data/local/tmp/exopackage/").resolve(packageName); |
| |
| Preconditions.checkArgument(AdbHelper.PACKAGE_NAME_PATTERN.matcher(packageName).matches()); |
| |
| Optional<ExopackageInfo> exopackageInfo = apkRule.getExopackageInfo(); |
| Preconditions.checkArgument(exopackageInfo.isPresent()); |
| this.exopackageInfo = exopackageInfo.get(); |
| } |
| |
| /** |
| * Installs the app specified in the constructor. This object should be discarded afterward. |
| */ |
| public synchronized boolean install() throws InterruptedException { |
| eventBus.post(InstallEvent.started(apkRule.getBuildTarget())); |
| |
| boolean success = adbHelper.adbCall( |
| new AdbHelper.AdbCallable() { |
| @Override |
| public boolean call(IDevice device) throws Exception { |
| try { |
| return new SingleDeviceInstaller(device, nextAgentPort.getAndIncrement()).doInstall(); |
| } catch (Exception e) { |
| throw new RuntimeException("Failed to install exopackage on " + device, e); |
| } |
| } |
| |
| @Override |
| public String toString() { |
| return "install exopackage"; |
| } |
| }); |
| |
| eventBus.post(InstallEvent.finished(apkRule.getBuildTarget(), success)); |
| return success; |
| } |
| |
| /** |
| * Helper class to manage the state required to install on a single device. |
| */ |
| private class SingleDeviceInstaller { |
| |
| /** |
| * Device that we are installing onto. |
| */ |
| private final IDevice device; |
| |
| /** |
| * Port to use for sending files to the agent. |
| */ |
| private final int agentPort; |
| |
| /** |
| * True iff we should use the native agent. |
| */ |
| private boolean useNativeAgent = true; |
| |
| /** |
| * Set after the agent is installed. |
| */ |
| @Nullable |
| private String nativeAgentPath; |
| |
| private SingleDeviceInstaller(IDevice device, int agentPort) { |
| this.device = device; |
| this.agentPort = agentPort; |
| } |
| |
| boolean doInstall() throws Exception { |
| Optional<PackageInfo> agentInfo = installAgentIfNecessary(); |
| if (!agentInfo.isPresent()) { |
| return false; |
| } |
| |
| nativeAgentPath = agentInfo.get().nativeLibPath; |
| determineBestAgent(); |
| |
| final File apk = apkRule.getApkPath().toFile(); |
| // TODO(user): Support SD installation. |
| final boolean installViaSd = false; |
| |
| if (shouldAppBeInstalled()) { |
| try (TraceEventLogger ignored = TraceEventLogger.start(eventBus, "install_exo_apk")) { |
| boolean success = adbHelper.installApkOnDevice(device, apk, installViaSd); |
| if (!success) { |
| return false; |
| } |
| } |
| } |
| |
| if (exopackageInfo.getDexInfo().isPresent()) { |
| installSecondaryDexFiles(); |
| } |
| |
| if (exopackageInfo.getNativeLibsInfo().isPresent()) { |
| installNativeLibraryFiles(); |
| } |
| |
| // TODO(user): Make this work on Gingerbread. |
| try (TraceEventLogger ignored = TraceEventLogger.start(eventBus, "kill_app")) { |
| AdbHelper.executeCommandWithErrorChecking(device, "am force-stop " + packageName); |
| } |
| |
| return true; |
| } |
| |
| private void installSecondaryDexFiles() throws Exception { |
| final ImmutableMap<String, Path> hashToSources = getRequiredDexFiles(); |
| final ImmutableSet<String> requiredHashes = hashToSources.keySet(); |
| final ImmutableSet<String> presentHashes = prepareSecondaryDexDir(requiredHashes); |
| final Set<String> hashesToInstall = Sets.difference(requiredHashes, presentHashes); |
| |
| Map<String, Path> filesToInstallByHash = |
| Maps.filterKeys(hashToSources, Predicates.in(hashesToInstall)); |
| |
| // This is a bit gross. It was a late addition. Ideally, we could eliminate this, but |
| // it wouldn't be terrible if we don't. We store the dexed jars on the device |
| // with the full SHA-1 hashes in their names. This is the format that the loader uses |
| // internally, so ideally we would just load them in place. However, the code currently |
| // expects to be able to copy the jars from a directory that matches the name in the |
| // metadata file, like "secondary-1.dex.jar". We don't want to give up putting the |
| // hashes in the file names (because we use that to skip re-uploads), so just hack |
| // the metadata file to have hash-like names. |
| String metadataContents = com.google.common.io.Files.toString( |
| exopackageInfo.getDexInfo().get().getMetadata().toFile(), |
| Charsets.UTF_8) |
| .replaceAll( |
| "secondary-(\\d+)\\.dex\\.jar (\\p{XDigit}{40}) ", |
| "secondary-$2.dex.jar $2 "); |
| |
| installFiles( |
| "secondary_dex", |
| ImmutableMap.copyOf(filesToInstallByHash), |
| metadataContents, |
| "secondary-%s.dex.jar", |
| SECONDARY_DEX_DIR); |
| } |
| |
| private void installNativeLibraryFiles() throws Exception { |
| String abi1 = getProperty("ro.product.cpu.abi"); |
| if (abi1.isEmpty()) { |
| throw new RuntimeException("adb returned empty result for ro.product.cpu.abi property."); |
| } |
| |
| ImmutableMultimap<String, Path> allLibraries = getAllLibraries(); |
| |
| ImmutableMap<String, Path> abi1Libraries = |
| getRequiredLibrariesForAbi(allLibraries, abi1, ImmutableSet.<String>of()); |
| installNativeLibrariesForAbi(abi1, abi1Libraries); |
| |
| String abi2 = getProperty("ro.product.cpu.abi2"); |
| if (abi2.isEmpty()) { |
| return; |
| } |
| |
| ImmutableSet<String> abi1LibraryNames = FluentIterable.from(abi1Libraries.values()) |
| .transform( |
| new Function<Path, String>() { |
| @Override |
| public String apply(Path input) { |
| return input.getFileName().toString(); |
| } |
| }) |
| .toSet(); |
| ImmutableMap<String, Path> abi2Libraries = |
| getRequiredLibrariesForAbi(allLibraries, abi2, abi1LibraryNames); |
| installNativeLibrariesForAbi(abi2, abi2Libraries); |
| } |
| |
| private void installNativeLibrariesForAbi(String abi, ImmutableMap<String, Path> libraries) |
| throws Exception { |
| if (libraries.isEmpty()) { |
| return; |
| } |
| |
| ImmutableSet<String> requiredHashes = libraries.keySet(); |
| ImmutableSet<String> presentHashes = prepareNativeLibsDir(abi, requiredHashes); |
| |
| Map<String, Path> filesToInstallByHash = |
| Maps.filterKeys(libraries, Predicates.not(Predicates.in(presentHashes))); |
| |
| if (useNativeAgent) { |
| // "ln -s" only works on pre-L Android devices. |
| createSymlinks(abi, libraries); |
| } |
| |
| String metadataContents = Joiner.on('\n').join( |
| FluentIterable.from(libraries.entrySet()).transform( |
| new Function<Map.Entry<String, Path>, String>() { |
| @Override |
| public String apply(Map.Entry<String, Path> input) { |
| String hash = input.getKey(); |
| String filename = input.getValue().getFileName().toString(); |
| int index = filename.indexOf('.'); |
| String libname = index == -1 ? filename : filename.substring(0, index); |
| return String.format("%s native-%s.so", libname, hash); |
| } |
| })); |
| |
| installFiles( |
| "native_library", |
| ImmutableMap.copyOf(filesToInstallByHash), |
| metadataContents, |
| "native-%s.so", |
| NATIVE_LIBS_DIR.resolve(abi)); |
| } |
| |
| /** |
| * Create symlinks of the form "lib<name>.so" to the native libraries. We want to do this while |
| * minimizing the number of adb shell commands, hence creating chunks of source/target pairs. |
| */ |
| private void createSymlinks(String abi, ImmutableMap<String, Path> libraries) throws Exception { |
| try (TraceEventLogger ignored = TraceEventLogger.start(eventBus, "create_symlinks_native")) { |
| int maxSize = MAX_ADB_COMMAND_SIZE - AdbHelper.ECHO_COMMAND_SUFFIX.length(); |
| Path abiDir = dataRoot.resolve(NATIVE_LIBS_DIR).resolve(abi); |
| String commandPrefix = String.format("cd %s", abiDir.toString()); |
| |
| String command = commandPrefix; |
| for (Map.Entry<String, Path> entry : libraries.entrySet()) { |
| String target = entry.getValue().getFileName().toString(); |
| String source = String.format("native-%s.so", entry.getKey()); |
| String nextToken = String.format(" && ln -s %s %s", source, target); |
| |
| if (command.length() + nextToken.length() > maxSize) { |
| LOG.debug("Executing symlink command: " + command); |
| AdbHelper.executeCommandWithErrorChecking(device, command); |
| command = commandPrefix + nextToken; |
| } else { |
| command += nextToken; |
| } |
| } |
| |
| if (!command.equals(commandPrefix)) { |
| AdbHelper.executeCommandWithErrorChecking(device, command); |
| } |
| } |
| } |
| |
| /** |
| * Sets {@link #useNativeAgent} to true on pre-L devices, because our native agent is built |
| * without -fPIC. The java agent works fine on L as long as we don't use it for mkdir. |
| */ |
| private void determineBestAgent() throws Exception { |
| String value = getProperty("ro.build.version.sdk"); |
| try { |
| if (Integer.valueOf(value.trim()) > 19) { |
| useNativeAgent = false; |
| } |
| } catch (NumberFormatException exn) { |
| useNativeAgent = false; |
| } |
| } |
| |
| private String getAgentCommand() { |
| if (useNativeAgent) { |
| return nativeAgentPath + "/libagent.so "; |
| } else { |
| return JAVA_AGENT_COMMAND; |
| } |
| } |
| |
| private Optional<PackageInfo> getPackageInfo(final String packageName) throws Exception { |
| try (TraceEventLogger ignored = TraceEventLogger.start( |
| eventBus, |
| "get_package_info", |
| ImmutableMap.of("package", packageName))) { |
| |
| /* This produces output that looks like |
| |
| Package [com.facebook.katana] (4229ce68): |
| userId=10145 gids=[1028, 1015, 3003] |
| pkg=Package{42690b80 com.facebook.katana} |
| codePath=/data/app/com.facebook.katana-1.apk |
| resourcePath=/data/app/com.facebook.katana-1.apk |
| nativeLibraryPath=/data/app-lib/com.facebook.katana-1 |
| versionCode=1640376 targetSdk=14 |
| versionName=8.0.0.0.23 |
| |
| ... |
| |
| */ |
| String lines = AdbHelper.executeCommandWithErrorChecking( |
| device, "dumpsys package " + packageName); |
| |
| return parsePackageInfo(packageName, lines); |
| } |
| } |
| |
| /** |
| * @return PackageInfo for the agent, or absent if installation failed. |
| */ |
| private Optional<PackageInfo> installAgentIfNecessary() throws Exception { |
| Optional<PackageInfo> agentInfo = getPackageInfo(AgentUtil.AGENT_PACKAGE_NAME); |
| if (!agentInfo.isPresent()) { |
| LOG.debug("Agent not installed. Installing."); |
| return installAgentApk(); |
| } |
| LOG.debug("Agent version: %s", agentInfo.get().versionCode); |
| if (!agentInfo.get().versionCode.equals(AgentUtil.AGENT_VERSION_CODE)) { |
| // Always uninstall before installing. We might be downgrading, which requires |
| // an uninstall, or we might just want a clean installation. |
| uninstallAgent(); |
| return installAgentApk(); |
| } |
| return agentInfo; |
| } |
| |
| private void uninstallAgent() throws InstallException { |
| try (TraceEventLogger ignored = TraceEventLogger.start(eventBus, "uninstall_old_agent")) { |
| device.uninstallPackage(AgentUtil.AGENT_PACKAGE_NAME); |
| } |
| } |
| |
| private Optional<PackageInfo> installAgentApk() throws Exception { |
| try (TraceEventLogger ignored = TraceEventLogger.start(eventBus, "install_agent_apk")) { |
| String apkFileName = System.getProperty("buck.android_agent_path"); |
| if (apkFileName == null) { |
| throw new RuntimeException("Android agent apk path not specified in properties"); |
| } |
| File apkPath = new File(apkFileName); |
| boolean success = adbHelper.installApkOnDevice(device, apkPath, /* installViaSd */ false); |
| if (!success) { |
| return Optional.absent(); |
| } |
| return getPackageInfo(AgentUtil.AGENT_PACKAGE_NAME); |
| } |
| } |
| |
| private boolean shouldAppBeInstalled() throws Exception { |
| Optional<PackageInfo> appPackageInfo = getPackageInfo(packageName); |
| if (!appPackageInfo.isPresent()) { |
| eventBus.post(ConsoleEvent.info("App not installed. Installing now.")); |
| return true; |
| } |
| |
| LOG.debug("App path: %s", appPackageInfo.get().apkPath); |
| String installedAppSignature = getInstalledAppSignature(appPackageInfo.get().apkPath); |
| String localAppSignature = AgentUtil.getJarSignature(apkRule.getApkPath().toString()); |
| LOG.debug("Local app signature: %s", localAppSignature); |
| LOG.debug("Remote app signature: %s", installedAppSignature); |
| |
| if (!installedAppSignature.equals(localAppSignature)) { |
| LOG.debug("App signatures do not match. Must re-install."); |
| return true; |
| } |
| |
| LOG.debug("App signatures match. No need to install."); |
| return false; |
| } |
| |
| private String getInstalledAppSignature(final String packagePath) throws Exception { |
| try (TraceEventLogger ignored = TraceEventLogger.start(eventBus, "get_app_signature")) { |
| String command = getAgentCommand() + "get-signature " + packagePath; |
| LOG.debug("Executing %s", command); |
| String output = AdbHelper.executeCommandWithErrorChecking(device, command); |
| |
| String result = output.trim(); |
| if (result.contains("\n") || result.contains("\r")) { |
| throw new IllegalStateException("Unexpected return from get-signature:\n" + output); |
| } |
| |
| return result; |
| } |
| } |
| |
| private ImmutableMap<String, Path> getRequiredDexFiles() throws IOException { |
| ExopackageInfo.DexInfo dexInfo = exopackageInfo.getDexInfo().get(); |
| ImmutableMultimap<String, Path> multimap = parseExopackageInfoMetadata( |
| dexInfo.getMetadata(), |
| dexInfo.getDirectory(), |
| projectFilesystem); |
| // Convert multimap to a map, because every key should have only one value. |
| ImmutableMap.Builder<String, Path> builder = ImmutableMap.builder(); |
| for (Map.Entry<String, Path> entry : multimap.entries()) { |
| builder.put(entry); |
| } |
| return builder.build(); |
| } |
| |
| private ImmutableSet<String> prepareSecondaryDexDir(ImmutableSet<String> requiredHashes) |
| throws Exception { |
| return prepareDirectory("secondary-dex", DEX_FILE_PATTERN, requiredHashes); |
| } |
| |
| private ImmutableSet<String> prepareNativeLibsDir( |
| String abi, |
| ImmutableSet<String> requiredHashes) throws Exception { |
| return prepareDirectory("native-libs/" + abi, NATIVE_LIB_PATTERN, requiredHashes); |
| } |
| |
| private ImmutableSet<String> prepareDirectory( |
| String dirname, |
| Pattern filePattern, |
| ImmutableSet<String> requiredHashes) throws Exception { |
| try (TraceEventLogger ignored = TraceEventLogger.start(eventBus, "prepare_" + dirname)) { |
| String dirPath = dataRoot.resolve(dirname).toString(); |
| mkDirP(dirPath); |
| |
| String output = AdbHelper.executeCommandWithErrorChecking(device, "ls " + dirPath); |
| |
| ImmutableSet.Builder<String> foundHashes = ImmutableSet.builder(); |
| ImmutableSet.Builder<String> filesToDelete = ImmutableSet.builder(); |
| |
| processLsOutput(output, filePattern, requiredHashes, foundHashes, filesToDelete); |
| |
| String commandPrefix = "cd " + dirPath + " && rm "; |
| // Add a fudge factor for separators and error checking. |
| final int overhead = commandPrefix.length() + 100; |
| for (List<String> rmArgs : |
| chunkArgs(filesToDelete.build(), MAX_ADB_COMMAND_SIZE - overhead)) { |
| String command = commandPrefix + Joiner.on(' ').join(rmArgs); |
| LOG.debug("Executing %s", command); |
| AdbHelper.executeCommandWithErrorChecking(device, command); |
| } |
| |
| return foundHashes.build(); |
| } |
| } |
| |
| private void installFiles( |
| String filesType, |
| ImmutableMap<String, Path> filesToInstallByHash, |
| String metadataFileContents, |
| String filenameFormat, |
| Path destinationDirRelativeToDataRoot) throws Exception { |
| try (TraceEventLogger ignored1 = |
| TraceEventLogger.start(eventBus, "multi_install_" + filesType)) { |
| device.createForward(agentPort, agentPort); |
| try { |
| for (Map.Entry<String, Path> entry : filesToInstallByHash.entrySet()) { |
| Path destination = destinationDirRelativeToDataRoot.resolve( |
| String.format(filenameFormat, entry.getKey())); |
| Path source = entry.getValue(); |
| |
| try (TraceEventLogger ignored2 = |
| TraceEventLogger.start(eventBus, "install_" + filesType)) { |
| installFile(device, agentPort, destination, source); |
| } |
| } |
| try (TraceEventLogger ignored3 = |
| TraceEventLogger.start(eventBus, "install_" + filesType + "_metadata")) { |
| try (NamedTemporaryFile temp = new NamedTemporaryFile("metadata", "tmp")) { |
| com.google.common.io.Files.write( |
| metadataFileContents.getBytes(Charsets.UTF_8), |
| temp.get().toFile()); |
| installFile( |
| device, |
| agentPort, |
| destinationDirRelativeToDataRoot.resolve("metadata.txt"), |
| temp.get()); |
| } |
| } |
| } finally { |
| try { |
| device.removeForward(agentPort, agentPort); |
| } catch (AdbCommandRejectedException e) { |
| LOG.warn(e, "Failed to remove adb forward on port %d for device %s", agentPort, device); |
| eventBus.post( |
| ConsoleEvent.warning( |
| "Failed to remove adb forward %d. This is not necessarily a problem\n" + |
| "because it will be recreated during the next exopackage installation.\n" + |
| "See the log for the full exception.", |
| agentPort)); |
| } |
| } |
| } |
| } |
| |
| private void installFile( |
| IDevice device, |
| final int port, |
| Path pathRelativeToDataRoot, |
| final Path source) throws Exception { |
| CollectingOutputReceiver receiver = new CollectingOutputReceiver() { |
| |
| private boolean sentPayload = false; |
| |
| @Override |
| public void addOutput(byte[] data, int offset, int length) { |
| super.addOutput(data, offset, length); |
| if (!sentPayload && getOutput().length() >= AgentUtil.TEXT_SECRET_KEY_SIZE) { |
| LOG.verbose("Got key: %s", getOutput().trim()); |
| |
| sentPayload = true; |
| try (Socket clientSocket = new Socket("localhost", port)) { |
| LOG.verbose("Connected"); |
| OutputStream outToDevice = clientSocket.getOutputStream(); |
| outToDevice.write( |
| getOutput().substring( |
| 0, |
| AgentUtil.TEXT_SECRET_KEY_SIZE).getBytes()); |
| LOG.verbose("Wrote key"); |
| com.google.common.io.Files.asByteSource(source.toFile()).copyTo(outToDevice); |
| LOG.verbose("Wrote file"); |
| } catch (IOException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| } |
| }; |
| |
| String targetFileName = dataRoot.resolve(pathRelativeToDataRoot).toString(); |
| String command = |
| "umask 022 && " + |
| getAgentCommand() + |
| "receive-file " + port + " " + Files.size(source) + " " + |
| targetFileName + |
| " ; echo -n :$?"; |
| LOG.debug("Executing %s", command); |
| |
| // If we fail to execute the command, stash the exception. My experience during development |
| // has been that the exception from checkReceiverOutput is more actionable. |
| Exception shellException = null; |
| try { |
| device.executeShellCommand(command, receiver); |
| } catch (Exception e) { |
| shellException = e; |
| } |
| |
| try { |
| AdbHelper.checkReceiverOutput(command, receiver); |
| } catch (Exception e) { |
| if (shellException != null) { |
| e.addSuppressed(shellException); |
| } |
| throw e; |
| } |
| |
| if (shellException != null) { |
| throw shellException; |
| } |
| |
| // The standard Java libraries on Android always create new files un-readable by other users. |
| // We use the shell user or root to create these files, so we need to explicitly set the mode |
| // to allow the app to read them. Ideally, the agent would do this automatically, but |
| // there's no easy way to do this in Java. We can drop this if we drop support for the |
| // Java agent. |
| AdbHelper.executeCommandWithErrorChecking(device, "chmod 644 " + targetFileName); |
| } |
| |
| private String getProperty(String property) throws Exception { |
| return AdbHelper.executeCommandWithErrorChecking(device, "getprop " + property).trim(); |
| } |
| |
| private void mkDirP(String dirpath) throws Exception { |
| // Kind of a hack here. The java agent can't force the proper permissions on the |
| // directories it creates, so we use the command-line "mkdir -p" instead of the java agent. |
| // Fortunately, "mkdir -p" seems to work on all devices where we use use the java agent. |
| String mkdirP = useNativeAgent ? getAgentCommand() + "mkdir-p" : "mkdir -p"; |
| |
| AdbHelper.executeCommandWithErrorChecking(device, "umask 022 && " + mkdirP + " " + dirpath); |
| } |
| } |
| |
| private ImmutableMultimap<String, Path> getAllLibraries() throws IOException { |
| ExopackageInfo.NativeLibsInfo nativeLibsInfo = exopackageInfo.getNativeLibsInfo().get(); |
| return parseExopackageInfoMetadata( |
| nativeLibsInfo.getMetadata(), |
| nativeLibsInfo.getDirectory(), |
| projectFilesystem); |
| } |
| |
| private ImmutableMap<String, Path> getRequiredLibrariesForAbi( |
| ImmutableMultimap<String, Path> allLibraries, |
| String abi, |
| ImmutableSet<String> ignoreLibraries) throws IOException { |
| return filterLibrariesForAbi( |
| exopackageInfo.getNativeLibsInfo().get().getDirectory(), |
| allLibraries, |
| abi, |
| ignoreLibraries); |
| } |
| |
| @VisibleForTesting |
| static ImmutableMap<String, Path> filterLibrariesForAbi( |
| Path nativeLibsDir, |
| ImmutableMultimap<String, Path> allLibraries, |
| String abi, |
| ImmutableSet<String> ignoreLibraries) { |
| ImmutableMap.Builder<String, Path> filteredLibraries = ImmutableMap.builder(); |
| for (Map.Entry<String, Path> entry : allLibraries.entries()) { |
| Path relativePath = nativeLibsDir.relativize(entry.getValue()); |
| Preconditions.checkState(relativePath.getNameCount() == 2); |
| String libAbi = relativePath.getParent().toString(); |
| String libName = relativePath.getFileName().toString(); |
| if (libAbi.equals(abi) && !ignoreLibraries.contains(libName)) { |
| filteredLibraries.put(entry); |
| } |
| } |
| return filteredLibraries.build(); |
| } |
| |
| /** |
| * Parses a text file which is supposed to be in the following format: |
| * "file_path_without_spaces file_hash ...." i.e. it parses the first two columns of each line |
| * and ignores the rest of it. |
| * |
| * @return A multi map from the file hash to its path, which equals the raw path resolved against |
| * {@code resolvePathAgainst}. |
| */ |
| @VisibleForTesting |
| static ImmutableMultimap<String, Path> parseExopackageInfoMetadata( |
| Path metadataTxt, |
| Path resolvePathAgainst, |
| ProjectFilesystem filesystem) throws IOException { |
| ImmutableMultimap.Builder<String, Path> builder = ImmutableMultimap.builder(); |
| for (String line : filesystem.readLines(metadataTxt)) { |
| List<String> parts = Splitter.on(' ').splitToList(line); |
| if (parts.size() < 2) { |
| throw new RuntimeException("Illegal line in metadata file: " + line); |
| } |
| builder.put(parts.get(1), resolvePathAgainst.resolve(parts.get(0))); |
| } |
| return builder.build(); |
| } |
| |
| @VisibleForTesting |
| static Optional<PackageInfo> parsePackageInfo(String packageName, String lines) { |
| final String packagePrefix = " Package [" + packageName + "] ("; |
| final String otherPrefix = " Package ["; |
| boolean sawPackageLine = false; |
| final Splitter splitter = Splitter.on('=').limit(2); |
| |
| String codePath = null; |
| String resourcePath = null; |
| String nativeLibPath = null; |
| String versionCode = null; |
| |
| for (String line : Splitter.on("\r\n").split(lines)) { |
| // Just ignore everything until we see the line that says we are in the right package. |
| if (line.startsWith(packagePrefix)) { |
| sawPackageLine = true; |
| continue; |
| } |
| // This should never happen, but if we do see a different package, stop parsing. |
| if (line.startsWith(otherPrefix)) { |
| break; |
| } |
| // Ignore lines before our package. |
| if (!sawPackageLine) { |
| continue; |
| } |
| // Parse key-value pairs. |
| List<String> parts = splitter.splitToList(line.trim()); |
| if (parts.size() != 2) { |
| continue; |
| } |
| switch (parts.get(0)) { |
| case "codePath": |
| codePath = parts.get(1); |
| break; |
| case "resourcePath": |
| resourcePath = parts.get(1); |
| break; |
| case "nativeLibraryPath": |
| nativeLibPath = parts.get(1); |
| break; |
| // Lollipop uses this name. Not sure what's "legacy" about it yet. |
| // Maybe something to do with 64-bit? |
| // Might need to update if people report failures. |
| case "legacyNativeLibraryDir": |
| nativeLibPath = parts.get(1); |
| break; |
| case "versionCode": |
| // Extra split to get rid of the SDK thing. |
| versionCode = parts.get(1).split(" ", 2)[0]; |
| break; |
| default: |
| break; |
| } |
| } |
| |
| if (!sawPackageLine) { |
| return Optional.absent(); |
| } |
| |
| Preconditions.checkNotNull(codePath, "Could not find codePath"); |
| Preconditions.checkNotNull(resourcePath, "Could not find resourcePath"); |
| Preconditions.checkNotNull(nativeLibPath, "Could not find nativeLibraryPath"); |
| Preconditions.checkNotNull(versionCode, "Could not find versionCode"); |
| if (!codePath.equals(resourcePath)) { |
| throw new IllegalStateException("Code and resource path do not match"); |
| } |
| |
| // Lollipop doesn't give the full path to the apk anymore. Not sure why it's "base.apk". |
| if (!codePath.endsWith(".apk")) { |
| codePath += "/base.apk"; |
| } |
| |
| return Optional.of(new PackageInfo(codePath, nativeLibPath, versionCode)); |
| } |
| |
| /** |
| * @param output Output of "ls" command. |
| * @param filePattern A {@link Pattern} that is used to check if a file is valid, and if it |
| * matches, {@code filePattern.group(1)} should return the hash in the file name. |
| * @param requiredHashes Hashes of dex files required for this apk. |
| * @param foundHashes Builder to receive hashes that we need and were found. |
| * @param toDelete Builder to receive files that we need to delete. |
| */ |
| @VisibleForTesting |
| static void processLsOutput( |
| String output, |
| Pattern filePattern, |
| ImmutableSet<String> requiredHashes, |
| ImmutableSet.Builder<String> foundHashes, |
| ImmutableSet.Builder<String> toDelete) { |
| for (String line : Splitter.on("\r\n").omitEmptyStrings().split(output)) { |
| if (line.equals("lock")) { |
| continue; |
| } |
| |
| Matcher m = filePattern.matcher(line); |
| if (m.matches()) { |
| if (requiredHashes.contains(m.group(1))) { |
| foundHashes.add(m.group(1)); |
| } else { |
| toDelete.add(line); |
| } |
| } else { |
| toDelete.add(line); |
| } |
| } |
| } |
| |
| /** |
| * Breaks a list of strings into groups whose total size is within some limit. |
| * Kind of like the xargs command that groups arguments to avoid maximum argument length limits. |
| * Except that the limit in adb is about 1k instead of 512k or 2M on Linux. |
| */ |
| @VisibleForTesting |
| static ImmutableList<ImmutableList<String>> chunkArgs(Iterable<String> args, int sizeLimit) { |
| ImmutableList.Builder<ImmutableList<String>> topLevelBuilder = ImmutableList.builder(); |
| ImmutableList.Builder<String> chunkBuilder = ImmutableList.builder(); |
| int chunkSize = 0; |
| for (String arg : args) { |
| if (chunkSize + arg.length() > sizeLimit) { |
| topLevelBuilder.add(chunkBuilder.build()); |
| chunkBuilder = ImmutableList.builder(); |
| chunkSize = 0; |
| } |
| // We don't check for an individual arg greater than the limit. |
| // We just put it in its own chunk and hope for the best. |
| chunkBuilder.add(arg); |
| chunkSize += arg.length(); |
| } |
| ImmutableList<String> tail = chunkBuilder.build(); |
| if (!tail.isEmpty()) { |
| topLevelBuilder.add(tail); |
| } |
| return topLevelBuilder.build(); |
| } |
| } |
