/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 org.apache.felix.deploymentadmin;
import java.io.BufferedReader;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.jar.Attributes;
import java.util.jar.JarFile;
import java.util.jar.Manifest;
import java.util.jar.Attributes.Name;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
public class Utils {
private static final String MANIFEST_NAME = JarFile.MANIFEST_NAME;
public static Manifest readManifest(File manifestFile) throws IOException {
InputStream is = null;
Manifest mf = null;
try {
is = new GZIPInputStream(new FileInputStream(manifestFile));
mf = new Manifest(is);
}
finally {
closeSilently(is);
}
return mf;
}
public static boolean replace(File target, File source) {
return delete(target, true /* deleteRoot */) && rename(source, target);
}
public static boolean copy(File from, File to) {
boolean result = true;
if (from.isDirectory()) {
if (!to.isDirectory()) {
if (!to.mkdirs()) {
return false;
}
File[] files = from.listFiles();
if (files == null) {
return false;
}
for (int i = 0; i < files.length; i++) {
result &= copy(files[i], new File(to, files[i].getName()));
}
}
}
else {
InputStream input = null;
OutputStream output = null;
try {
input = new FileInputStream(from);
output = new FileOutputStream(to);
byte[] buffer = new byte[4096];
for (int i = input.read(buffer); i > -1; i = input.read(buffer)) {
output.write(buffer, 0, i);
}
}
catch (IOException e) {
return false;
}
finally {
if (!closeSilently(output)) {
result = false;
}
if (!closeSilently(input)) {
result = false;
}
}
}
return result;
}
public static boolean rename(File from, File to) {
if (!from.renameTo(to)) {
if (copy(from, to)) {
if (!delete(from, true /* deleteRoot */)) {
return false;
}
}
else {
return false;
}
}
return true;
}
public static boolean delete(File root, boolean deleteRoot) {
boolean result = true;
if (root.isDirectory()) {
File[] files = root.listFiles();
for (int i = 0; i < files.length; i++) {
if (files[i].isDirectory()) {
result &= delete(files[i], true);
}
else {
result &= files[i].delete();
}
}
}
if (deleteRoot) {
if (root.exists()) {
result &= root.delete();
}
}
return result;
}
public static void merge(File targetIndex, File target, File sourceIndex, File source) throws IOException {
List targetFiles = readIndex(targetIndex);
List sourceFiles = readIndex(sourceIndex);
List result = new ArrayList(targetFiles);
File manifestFile = new File(source, (String) sourceFiles.remove(0));
Manifest resultManifest = Utils.readManifest(manifestFile);
resultManifest.getMainAttributes().remove(new Name(Constants.DEPLOYMENTPACKAGE_FIXPACK));
for (Iterator i = result.iterator(); i.hasNext();) {
String targetFile = (String) i.next();
if (!MANIFEST_NAME.equals(targetFile) && !resultManifest.getEntries().containsKey(targetFile)) {
i.remove();
}
}
for (Iterator iter = sourceFiles.iterator(); iter.hasNext();) {
String path = (String) iter.next();
File from = new File(source, path);
File to = new File(target, path);
if (targetFiles.contains(path)) {
if (!to.delete()) {
throw new IOException("Could not delete " + to);
}
}
else {
result.add(path);
}
if (!rename(from, to)) {
throw new IOException("Could not rename " + from + " to " + to);
}
}
targetFiles.removeAll(sourceFiles);
for (Iterator iter = resultManifest.getEntries().keySet().iterator(); iter.hasNext();) {
String path = (String) iter.next();
Attributes sourceAttribute = (Attributes) resultManifest.getEntries().get(path);
if ("true".equals(sourceAttribute.remove(new Name(Constants.DEPLOYMENTPACKAGE_MISSING)))) {
targetFiles.remove(path);
}
}
for (Iterator iter = targetFiles.iterator(); iter.hasNext();) {
String path = (String) iter.next();
File targetFile = new File(target, path);
if (!targetFile.delete()) {
throw new IOException("Could not delete " + targetFile);
}
}
GZIPOutputStream outputStream = new GZIPOutputStream(new FileOutputStream(new File(target, MANIFEST_NAME)));
try {
resultManifest.write(outputStream);
}
finally {
outputStream.close();
}
writeIndex(targetIndex, result);
}
public static List readIndex(File index) throws IOException {
BufferedReader reader = null;
try {
reader = new BufferedReader(new FileReader(index));
List result = new ArrayList();
for (String line = reader.readLine(); line != null; line = reader.readLine()) {
result.add(line);
}
return result;
}
finally {
closeSilently(reader);
}
}
static boolean closeSilently(Closeable closeable) {
if (closeable != null) {
try {
closeable.close();
}
catch (IOException exception) {
// Ignore; nothing we can do about this...
return false;
}
}
return true;
}
private static void writeIndex(File index, List input) throws IOException {
PrintWriter writer = null;
try {
writer = new PrintWriter(new FileWriter(index));
for (Iterator iterator = input.iterator(); iterator.hasNext();) {
writer.println(iterator.next());
}
}
finally {
closeSilently(writer);
}
}
}