| // Copyright 2016 Google Inc. All rights reserved. |
| // |
| // 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.google.archivepatcher.tools; |
| |
| import com.google.archivepatcher.applier.FileByFileV1DeltaApplier; |
| import com.google.archivepatcher.generator.DeltaFriendlyOldBlobSizeLimiter; |
| import com.google.archivepatcher.generator.FileByFileV1DeltaGenerator; |
| import com.google.archivepatcher.generator.RecommendationModifier; |
| import com.google.archivepatcher.generator.TotalRecompressionLimiter; |
| import java.io.BufferedInputStream; |
| import java.io.BufferedOutputStream; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| |
| /** |
| * Simple command-line tool for generating and applying patches. |
| */ |
| public class FileByFileTool extends AbstractTool { |
| |
| /** Usage instructions for the command line. */ |
| private static final String USAGE = |
| "java -cp <classpath> com.google.archivepatcher.tools.FileByFileTool <options>\n" |
| + "\nOptions:\n" |
| + " --generate generate a patch\n" |
| + " --apply apply a patch\n" |
| + " --old the old file\n" |
| + " --new the new file\n" |
| + " --patch the patch file\n" |
| + " --trl optionally, the total bytes of recompression to allow (see below)\n" |
| + " --dfobsl optionally, a limit on the total size of the delta-friendly old blob (see below)\n" |
| + "\nTotal Recompression Limit (trl):\n" |
| + " When generating a patch, a limit can be specified on the total number of bytes to\n" |
| + " allow to be recompressed during the patch apply process. This can be for a variety\n" |
| + " of reasons, with the most obvious being to limit the amount of effort that has to\n" |
| + " be expended applying the patch on the target platform. To properly explain a\n" |
| + " patch that had such a limitation, it is necessary to specify the same limitation\n" |
| + " here. This argument is illegal for --apply, since it only applies to --generate.\n" |
| + "\nDelta Friendly Old Blob Size Limit (dfobsl):\n" |
| + " When generating a patch, a limit can be specified on the total size of the delta-\n" |
| + " friendly old blob. This implicitly limits the size of the temporary file that\n" |
| + " needs to be created when applying the patch. The size limit is \"soft\" in that \n" |
| + " the delta-friendly old blob needs to at least contain the original data that was\n" |
| + " within it; but the limit specified here will constrain any attempt to uncompress\n" |
| + " the content. If the limit is less than or equal to the size of the old file, no\n" |
| + " uncompression will be performed at all. Otherwise, the old file can expand into\n" |
| + " delta-friendly old blob until the size reaches this limit.\n" |
| + "\nExamples:\n" |
| + " To generate a patch from OLD to NEW, saving the patch in PATCH:\n" |
| + " java -cp <classpath> com.google.archivepatcher.tools.FileByFileTool --generate \\\n" |
| + " --old OLD --new NEW --patch PATCH\n" |
| + " To generate a patch from OLD to NEW, limiting to 1,000,000 recompress bytes:\n" |
| + " java -cp <classpath> com.google.archivepatcher.tools.FileByFileTool --generate \\\n" |
| + " --old OLD --new NEW --trl 1000000 --patch PATCH\n" |
| + " To apply a patch PATCH to OLD, saving the result in NEW:\n" |
| + " java -cp <classpath> com.google.archivepatcher.tools.FileByFileTool --apply \\\n" |
| + " --old OLD --patch PATCH --new NEW"; |
| |
| /** |
| * Modes of operation. |
| */ |
| private static enum Mode { |
| /** |
| * Generate a patch. |
| */ |
| GENERATE, |
| |
| /** |
| * Apply a patch. |
| */ |
| APPLY; |
| } |
| |
| /** |
| * Runs the tool. See usage instructions for more information. |
| * |
| * @param args command line arguments |
| * @throws IOException if anything goes wrong |
| * @throws InterruptedException if any thread has interrupted the current thread |
| */ |
| public static void main(String... args) throws IOException, InterruptedException { |
| new FileByFileTool().run(args); |
| } |
| |
| /** |
| * Run the tool. |
| * |
| * @param args command line arguments |
| * @throws IOException if anything goes wrong |
| * @throws InterruptedException if any thread has interrupted the current thread |
| */ |
| public void run(String... args) throws IOException, InterruptedException { |
| String oldPath = null; |
| String newPath = null; |
| String patchPath = null; |
| Long totalRecompressionLimit = null; |
| Long deltaFriendlyOldBlobSizeLimit = null; |
| Mode mode = null; |
| Iterator<String> argIterator = new LinkedList<String>(Arrays.asList(args)).iterator(); |
| while (argIterator.hasNext()) { |
| String arg = argIterator.next(); |
| if ("--old".equals(arg)) { |
| oldPath = popOrDie(argIterator, "--old"); |
| } else if ("--new".equals(arg)) { |
| newPath = popOrDie(argIterator, "--new"); |
| } else if ("--patch".equals(arg)) { |
| patchPath = popOrDie(argIterator, "--patch"); |
| } else if ("--generate".equals(arg)) { |
| mode = Mode.GENERATE; |
| } else if ("--apply".equals(arg)) { |
| mode = Mode.APPLY; |
| } else if ("--trl".equals(arg)) { |
| totalRecompressionLimit = Long.parseLong(popOrDie(argIterator, "--trl")); |
| if (totalRecompressionLimit < 0) { |
| exitWithUsage("--trl cannot be negative: " + totalRecompressionLimit); |
| } |
| } else if ("--dfobsl".equals(arg)) { |
| deltaFriendlyOldBlobSizeLimit = Long.parseLong(popOrDie(argIterator, "--dfobsl")); |
| if (deltaFriendlyOldBlobSizeLimit < 0) { |
| exitWithUsage("--dfobsl cannot be negative: " + deltaFriendlyOldBlobSizeLimit); |
| } |
| } else { |
| exitWithUsage("unknown argument: " + arg); |
| } |
| } |
| if (oldPath == null || newPath == null || patchPath == null || mode == null) { |
| exitWithUsage("missing required argument(s)"); |
| } |
| if (mode == Mode.APPLY && totalRecompressionLimit != null) { |
| exitWithUsage("--trl can only be used with --generate"); |
| } |
| if (mode == Mode.APPLY && deltaFriendlyOldBlobSizeLimit != null) { |
| exitWithUsage("--dfobsl can only be used with --generate"); |
| } |
| File oldFile = getRequiredFileOrDie(oldPath, "old file"); |
| if (mode == Mode.GENERATE) { |
| File newFile = getRequiredFileOrDie(newPath, "new file"); |
| generatePatch( |
| oldFile, |
| newFile, |
| new File(patchPath), |
| totalRecompressionLimit, |
| deltaFriendlyOldBlobSizeLimit); |
| } else { // mode == Mode.APPLY |
| File patchFile = getRequiredFileOrDie(patchPath, "patch file"); |
| applyPatch(oldFile, patchFile, new File(newPath)); |
| } |
| } |
| |
| /** |
| * Generate a specified patch to transform the specified old file to the specified new file. |
| * |
| * @param oldFile the old file (will be read) |
| * @param newFile the new file (will be read) |
| * @param patchFile the patch file (will be written) |
| * @param totalRecompressionLimit optional limit for total number of bytes of recompression to |
| * allow in the resulting patch |
| * @param deltaFriendlyOldBlobSizeLimit optional limit for the size of the delta-friendly old |
| * blob, which implies a limit on the temporary space needed to apply the generated patch |
| * @throws IOException if anything goes wrong |
| * @throws InterruptedException if any thread has interrupted the current thread |
| */ |
| public static void generatePatch( |
| File oldFile, |
| File newFile, |
| File patchFile, |
| Long totalRecompressionLimit, |
| Long deltaFriendlyOldBlobSizeLimit) |
| throws IOException, InterruptedException { |
| List<RecommendationModifier> recommendationModifiers = new ArrayList<RecommendationModifier>(); |
| if (totalRecompressionLimit != null) { |
| recommendationModifiers.add(new TotalRecompressionLimiter(totalRecompressionLimit)); |
| } |
| if (deltaFriendlyOldBlobSizeLimit != null) { |
| recommendationModifiers.add( |
| new DeltaFriendlyOldBlobSizeLimiter(deltaFriendlyOldBlobSizeLimit)); |
| } |
| FileByFileV1DeltaGenerator generator = |
| new FileByFileV1DeltaGenerator( |
| recommendationModifiers.toArray(new RecommendationModifier[] {})); |
| try (FileOutputStream patchOut = new FileOutputStream(patchFile); |
| BufferedOutputStream bufferedPatchOut = new BufferedOutputStream(patchOut)) { |
| generator.generateDelta(oldFile, newFile, bufferedPatchOut); |
| bufferedPatchOut.flush(); |
| } |
| } |
| |
| /** |
| * Apply a specified patch to the specified old file, creating the specified new file. |
| * @param oldFile the old file (will be read) |
| * @param patchFile the patch file (will be read) |
| * @param newFile the new file (will be written) |
| * @throws IOException if anything goes wrong |
| */ |
| public static void applyPatch(File oldFile, File patchFile, File newFile) throws IOException { |
| // Figure out temp directory |
| File tempFile = File.createTempFile("fbftool", "tmp"); |
| File tempDir = tempFile.getParentFile(); |
| tempFile.delete(); |
| FileByFileV1DeltaApplier applier = new FileByFileV1DeltaApplier(tempDir); |
| try (FileInputStream patchIn = new FileInputStream(patchFile); |
| BufferedInputStream bufferedPatchIn = new BufferedInputStream(patchIn); |
| FileOutputStream newOut = new FileOutputStream(newFile); |
| BufferedOutputStream bufferedNewOut = new BufferedOutputStream(newOut)) { |
| applier.applyDelta(oldFile, bufferedPatchIn, bufferedNewOut); |
| bufferedNewOut.flush(); |
| } |
| } |
| |
| @Override |
| protected String getUsage() { |
| return USAGE; |
| } |
| } |
