| /* |
| * 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.karaf.tooling.exam.container.internal; |
| |
| import com.google.common.collect.Lists; |
| import com.google.common.collect.Maps; |
| import org.apache.commons.compress.archivers.ArchiveEntry; |
| import org.apache.commons.compress.archivers.ArchiveInputStream; |
| import org.apache.commons.compress.archivers.tar.TarArchiveInputStream; |
| import org.apache.commons.compress.archivers.zip.ZipArchiveInputStream; |
| import org.apache.commons.compress.compressors.gzip.GzipCompressorInputStream; |
| import org.apache.commons.io.FileUtils; |
| import org.apache.commons.io.IOUtils; |
| import org.apache.commons.io.filefilter.WildcardFileFilter; |
| import org.apache.karaf.tooling.exam.container.internal.adaptions.KarafManipulator; |
| import org.apache.karaf.tooling.exam.container.internal.adaptions.KarafManipulatorFactory; |
| import org.apache.karaf.tooling.exam.container.internal.runner.Runner; |
| import org.apache.karaf.tooling.exam.options.*; |
| import org.apache.karaf.tooling.exam.options.configs.CustomProperties; |
| import org.apache.karaf.tooling.exam.options.configs.FeaturesCfg; |
| import org.ops4j.pax.exam.*; |
| import org.ops4j.pax.exam.container.remote.RBCRemoteTarget; |
| import org.ops4j.pax.exam.options.*; |
| import org.ops4j.pax.exam.options.extra.FeaturesScannerProvisionOption; |
| import org.ops4j.pax.exam.options.extra.VMOption; |
| import org.ops4j.pax.exam.rbc.client.RemoteBundleContextClient; |
| import org.osgi.framework.Bundle; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| import java.io.*; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.util.*; |
| |
| import static org.apache.karaf.tooling.exam.options.KarafDistributionOption.editConfigurationFileExtend; |
| import static org.ops4j.pax.exam.CoreOptions.options; |
| import static org.ops4j.pax.exam.CoreOptions.systemProperty; |
| import static org.ops4j.pax.exam.rbc.Constants.*; |
| |
| public class KarafTestContainer implements TestContainer { |
| |
| private static final Logger LOGGER = LoggerFactory.getLogger(KarafTestContainer.class); |
| |
| private static final String KARAF_TEST_CONTAINER = "KarafTestContainer.start"; |
| private static final String EXAM_INVOKER_PROPERTY = "pax.exam.invoker"; |
| private static final String EXAM_INJECT_PROPERTY = "pax.exam.inject"; |
| |
| private final Runner runner; |
| private final RMIRegistry registry; |
| private final ExamSystem system; |
| private KarafDistributionBaseConfigurationOption framework; |
| @SuppressWarnings("unused") |
| private KarafManipulator versionAdaptions; |
| |
| private boolean deleteRuntime = true; |
| private boolean started = false; |
| private RBCRemoteTarget target; |
| |
| private File targetFolder; |
| |
| public KarafTestContainer(ExamSystem system, RMIRegistry registry, |
| KarafDistributionBaseConfigurationOption framework, Runner runner) { |
| this.framework = framework; |
| this.registry = registry; |
| this.system = system; |
| this.runner = runner; |
| } |
| |
| @Override |
| public synchronized TestContainer start() { |
| try { |
| String name = system.createID(KARAF_TEST_CONTAINER); |
| |
| KarafExamSystemConfigurationOption[] internalConfigurationOptions = |
| system.getOptions(KarafExamSystemConfigurationOption.class); |
| Option invokerConfiguration = systemProperty("pax.exam.invoker").value("junit"); |
| if (internalConfigurationOptions != null && internalConfigurationOptions.length != 0) { |
| invokerConfiguration = |
| systemProperty("pax.exam.invoker").value(internalConfigurationOptions[0].getInvoker()); |
| } |
| |
| ExamSystem subsystem = system.fork( |
| options( |
| systemProperty(RMI_HOST_PROPERTY).value(registry.getHost()), |
| systemProperty(RMI_PORT_PROPERTY).value("" + registry.getPort()), |
| systemProperty(RMI_NAME_PROPERTY).value(name), |
| invokerConfiguration, |
| systemProperty(EXAM_INJECT_PROPERTY).value("true"), |
| editConfigurationFileExtend("etc/system.properties", "jline.shutdownhook", "true") |
| )); |
| target = new RBCRemoteTarget(name, registry.getPort(), subsystem.getTimeout()); |
| |
| System.setProperty("java.protocol.handler.pkgs", "org.ops4j.pax.url"); |
| |
| URL sourceDistribution = new URL(framework.getFrameworkURL()); |
| |
| KeepRuntimeFolderOption[] keepRuntimeFolder = subsystem.getOptions(KeepRuntimeFolderOption.class); |
| if (keepRuntimeFolder != null && keepRuntimeFolder.length != 0) { |
| deleteRuntime = false; |
| } |
| |
| targetFolder = retrieveFinalTargetFolder(subsystem); |
| extractKarafDistribution(sourceDistribution, targetFolder); |
| |
| File javaHome = new File(System.getProperty("java.home")); |
| File karafBase = searchKarafBase(targetFolder); |
| File distributionInfo = new File(karafBase + "/etc/distribution.info"); |
| File karafBin = new File(karafBase + "/bin"); |
| File featuresXmlFile = new File(targetFolder + "/examfeatures.xml"); |
| File karafHome = karafBase; |
| File deploy = new File(karafBase + "/deploy"); |
| String karafData = karafHome + "/data"; |
| |
| framework = new InternalKarafDistributionConfigurationOption(framework, distributionInfo); |
| versionAdaptions = KarafManipulatorFactory.createManipulator(framework.getKarafVersion()); |
| |
| ArrayList<String> javaOpts = Lists.newArrayList(); |
| appendVmSettingsFromSystem(javaOpts, subsystem); |
| String[] javaEndorsedDirs = |
| new String[]{javaHome + "/jre/lib/endorsed", javaHome + "/lib/endorsed", karafHome + "/lib/endorsed"}; |
| String[] javaExtDirs = |
| new String[]{javaHome + "/jre/lib/ext", javaHome + "/lib/ext", javaHome + "/lib/ext"}; |
| String[] karafOpts = new String[]{}; |
| ArrayList<String> opts = |
| Lists.newArrayList("-Dkaraf.startLocalConsole=" + shouldLocalConsoleBeStarted(subsystem), |
| "-Dkaraf.startRemoteShell=" + shouldRemoteShellBeStarted(subsystem)); |
| |
| String[] classPath = buildKarafClasspath(karafHome); |
| String main = "org.apache.karaf.main.Main"; |
| String options = ""; |
| String[] environment = new String[]{}; |
| String[] fileEndings = new String[]{"jar", "war", "zip", "kar", "xml"}; |
| |
| updateLogProperties(karafHome, subsystem); |
| updateUserSetProperties(karafHome, subsystem); |
| copyBootClasspathLibraries(karafHome, subsystem); |
| setupExamProperties(karafHome, subsystem); |
| makeScriptsInBinExec(karafBin); |
| |
| int startLevel = Constants.DEFAULT_START_LEVEL; |
| ExamBundlesStartLevel examBundlesStartLevel = system.getSingleOption(ExamBundlesStartLevel.class); |
| if (examBundlesStartLevel != null) { |
| startLevel = examBundlesStartLevel.getStartLevel(); |
| } |
| |
| ExamFeaturesFile examFeaturesFile; |
| if (framework.isUseDeployFolder()) { |
| copyReferencedArtifactsToDeployFolder(deploy, subsystem, fileEndings); |
| examFeaturesFile = new ExamFeaturesFile("", startLevel); |
| } else { |
| StringBuilder extension = extractExtensionString(subsystem); |
| examFeaturesFile = new ExamFeaturesFile(extension.toString(), startLevel); |
| } |
| examFeaturesFile.writeToFile(featuresXmlFile); |
| |
| examFeaturesFile.adaptDistributionToStartExam(karafHome, featuresXmlFile); |
| |
| long startedAt = System.currentTimeMillis(); |
| |
| runner.exec(environment, karafBase, javaHome.toString(), javaOpts.toArray(new String[]{}), |
| javaEndorsedDirs, javaExtDirs, karafHome.toString(), karafData, karafOpts, |
| opts.toArray(new String[]{}), classPath, main, options); |
| |
| LOGGER.debug("Test Container started in " + (System.currentTimeMillis() - startedAt) + " millis"); |
| LOGGER.info("Wait for test container to finish its initialization " + subsystem.getTimeout()); |
| |
| if (subsystem.getOptions(ServerModeOption.class).length == 0) { |
| waitForState(org.apache.karaf.tooling.exam.container.internal.Constants.SYSTEM_BUNDLE, |
| Bundle.ACTIVE, subsystem.getTimeout()); |
| } else { |
| LOGGER |
| .info("System runs in Server Mode. Which means, no Test facility bundles available on target system."); |
| } |
| |
| started = true; |
| } catch (IOException e) { |
| throw new RuntimeException("Problem starting container", e); |
| } |
| return this; |
| } |
| |
| private void copyBootClasspathLibraries(File karafHome, ExamSystem subsystem) throws MalformedURLException, |
| IOException { |
| BootClasspathLibraryOption[] bootClasspathLibraryOptions = |
| subsystem.getOptions(BootClasspathLibraryOption.class); |
| for (BootClasspathLibraryOption bootClasspathLibraryOption : bootClasspathLibraryOptions) { |
| UrlReference libraryUrl = bootClasspathLibraryOption.getLibraryUrl(); |
| FileUtils.copyURLToFile( |
| new URL(libraryUrl.getURL()), |
| createFileNameWithRandomPrefixFromUrlAtTarget(libraryUrl.getURL(), new File(karafHome + "/lib"), |
| new String[]{"jar"})); |
| } |
| } |
| |
| @SuppressWarnings("rawtypes") |
| private StringBuilder extractExtensionString(ExamSystem subsystem) { |
| ProvisionOption[] provisionOptions = subsystem.getOptions(ProvisionOption.class); |
| StringBuilder extension = new StringBuilder(); |
| for (ProvisionOption provisionOption : provisionOptions) { |
| if (provisionOption.getURL().startsWith("link") || provisionOption.getURL().startsWith("scan-features")) { |
| // well those we've already handled at another location... |
| continue; |
| } |
| extension.append("<bundle>").append(provisionOption.getURL()).append("</bundle>\n"); |
| } |
| return extension; |
| } |
| |
| private String shouldRemoteShellBeStarted(ExamSystem subsystem) { |
| KarafDistributionConfigurationConsoleOption[] consoleOptions = |
| subsystem.getOptions(KarafDistributionConfigurationConsoleOption.class); |
| if (consoleOptions == null) { |
| return "true"; |
| } |
| for (KarafDistributionConfigurationConsoleOption consoleOption : consoleOptions) { |
| if (consoleOption.getStartRemoteShell() != null) { |
| return consoleOption.getStartRemoteShell() ? "true" : "false"; |
| } |
| } |
| return "true"; |
| } |
| |
| private String shouldLocalConsoleBeStarted(ExamSystem subsystem) { |
| KarafDistributionConfigurationConsoleOption[] consoleOptions = |
| subsystem.getOptions(KarafDistributionConfigurationConsoleOption.class); |
| if (consoleOptions == null) { |
| return "true"; |
| } |
| for (KarafDistributionConfigurationConsoleOption consoleOption : consoleOptions) { |
| if (consoleOption.getStartLocalConsole() != null) { |
| return consoleOption.getStartLocalConsole() ? "true" : "false"; |
| } |
| } |
| return "true"; |
| } |
| |
| private void makeScriptsInBinExec(File karafBin) { |
| if (!karafBin.exists()) { |
| return; |
| } |
| File[] files = karafBin.listFiles(); |
| for (File file : files) { |
| file.setExecutable(true); |
| } |
| } |
| |
| private File retrieveFinalTargetFolder(ExamSystem subsystem) { |
| if (framework.getUnpackDirectory() == null) { |
| return subsystem.getConfigFolder(); |
| } else { |
| File target = new File(framework.getUnpackDirectory() + "/" + UUID.randomUUID().toString()); |
| target = transformToAbsolutePath(target); |
| target.mkdirs(); |
| return target; |
| } |
| } |
| |
| private File transformToAbsolutePath(File file) { |
| return new File(file.getAbsolutePath()); |
| } |
| |
| private void appendVmSettingsFromSystem(ArrayList<String> opts, ExamSystem subsystem) { |
| VMOption[] options = subsystem.getOptions(VMOption.class); |
| for (VMOption option : options) { |
| opts.add(option.getOption()); |
| } |
| } |
| |
| @SuppressWarnings("rawtypes") |
| private void copyReferencedArtifactsToDeployFolder(File deploy, ExamSystem subsystem, String[] fileEndings) { |
| ProvisionOption[] options = subsystem.getOptions(ProvisionOption.class); |
| for (ProvisionOption option : options) { |
| try { |
| FileUtils.copyURLToFile(new URL(option.getURL()), |
| createFileNameWithRandomPrefixFromUrlAtTarget(option.getURL(), deploy, fileEndings)); |
| } catch (Exception e) { |
| // well, this can happen... |
| } |
| } |
| } |
| |
| private File createFileNameWithRandomPrefixFromUrlAtTarget(String url, File deploy, String[] fileEndings) { |
| String prefix = UUID.randomUUID().toString(); |
| String realEnding = extractPossibleFileEndingIfMavenArtifact(url, fileEndings); |
| String fileName = new File(url).getName(); |
| return new File(deploy + "/" + prefix + "_" + fileName + "." + realEnding); |
| } |
| |
| private String extractPossibleFileEndingIfMavenArtifact(String url, String[] fileEndings) { |
| String realEnding = "jar"; |
| for (String ending : fileEndings) { |
| if (url.indexOf("/" + ending + "/") > 0) { |
| realEnding = ending; |
| break; |
| } |
| } |
| return realEnding; |
| } |
| |
| private void updateUserSetProperties(File karafHome, ExamSystem subsystem) throws IOException { |
| List<KarafDistributionConfigurationFileOption> options = Lists.newArrayList( |
| subsystem.getOptions(KarafDistributionConfigurationFileOption.class)); |
| options.addAll(extractFileOptionsBasedOnFeaturesScannerOptions(subsystem)); |
| options.addAll(configureBootDelegation(subsystem)); |
| options.addAll(configureSystemBundles(subsystem)); |
| HashMap<String, HashMap<String, List<KarafDistributionConfigurationFileOption>>> optionMap = Maps.newHashMap(); |
| for (KarafDistributionConfigurationFileOption option : options) { |
| if (!optionMap.containsKey(option.getConfigurationFilePath())) { |
| optionMap.put(option.getConfigurationFilePath(), |
| new HashMap<String, List<KarafDistributionConfigurationFileOption>>()); |
| } |
| HashMap<String, List<KarafDistributionConfigurationFileOption>> optionEntries = |
| optionMap.get(option.getConfigurationFilePath()); |
| if (!optionEntries.containsKey(option.getKey())) { |
| optionEntries.put(option.getKey(), new ArrayList<KarafDistributionConfigurationFileOption>()); |
| } else { |
| // if special file warn, replace and continue |
| if (!option.getConfigurationFilePath().equals(FeaturesCfg.FILE_PATH)) { |
| LOGGER.warn("you're trying to add an additional value to a config file; you're current " + |
| "value will be replaced."); |
| optionEntries.put(option.getKey(), new ArrayList<KarafDistributionConfigurationFileOption>()); |
| } |
| } |
| optionEntries.get(option.getKey()).add(option); |
| } |
| Set<String> configFiles = optionMap.keySet(); |
| for (String configFile : configFiles) { |
| |
| KarafPropertiesFile karafPropertiesFile = new KarafPropertiesFile(karafHome, configFile); |
| karafPropertiesFile.load(); |
| Collection<List<KarafDistributionConfigurationFileOption>> optionsToApply = |
| optionMap.get(configFile).values(); |
| boolean store = true; |
| for (List<KarafDistributionConfigurationFileOption> optionListToApply : optionsToApply) { |
| for (KarafDistributionConfigurationFileOption optionToApply : optionListToApply) { |
| if (optionToApply instanceof KarafDistributionConfigurationFilePutOption) { |
| karafPropertiesFile.put(optionToApply.getKey(), optionToApply.getValue()); |
| } else if (optionToApply instanceof KarafDistributionConfigurationFileReplacementOption) { |
| karafPropertiesFile |
| .replace(((KarafDistributionConfigurationFileReplacementOption) optionToApply) |
| .getSource()); |
| store = false; |
| break; |
| } else { |
| karafPropertiesFile.extend(optionToApply.getKey(), optionToApply.getValue()); |
| } |
| } |
| if (!store) { |
| break; |
| } |
| } |
| if (store) { |
| karafPropertiesFile.store(); |
| } |
| } |
| } |
| |
| private Collection<? extends KarafDistributionConfigurationFileOption> configureSystemBundles(ExamSystem subsystem) { |
| SystemPackageOption[] systemPackageOptions = subsystem.getOptions(SystemPackageOption.class); |
| String systemPackageString = ""; |
| for (SystemPackageOption systemPackageOption : systemPackageOptions) { |
| if (!systemPackageString.equals("")) { |
| systemPackageString += ","; |
| } |
| systemPackageString += systemPackageOption.getValue(); |
| } |
| if (systemPackageString.equals("")) { |
| return Lists.newArrayList(); |
| } |
| return Lists.newArrayList(new KarafDistributionConfigurationFileExtendOption( |
| CustomProperties.SYSTEM_PACKAGES_EXTRA, systemPackageString)); |
| } |
| |
| private Collection<? extends KarafDistributionConfigurationFileOption> |
| configureBootDelegation(ExamSystem subsystem) { |
| BootDelegationOption[] bootDelegationOptions = subsystem.getOptions(BootDelegationOption.class); |
| String bootDelegationString = ""; |
| for (BootDelegationOption bootDelegationOption : bootDelegationOptions) { |
| bootDelegationString += ","; |
| bootDelegationString += bootDelegationOption.getValue(); |
| } |
| return Lists.newArrayList(new KarafDistributionConfigurationFileExtendOption(CustomProperties.BOOTDELEGATION, |
| bootDelegationString)); |
| } |
| |
| private Collection<? extends KarafDistributionConfigurationFileOption> |
| extractFileOptionsBasedOnFeaturesScannerOptions(ExamSystem subsystem) { |
| ArrayList<KarafDistributionConfigurationFileOption> retVal = Lists.newArrayList(); |
| FeaturesScannerProvisionOption[] features = subsystem.getOptions(FeaturesScannerProvisionOption.class); |
| for (FeaturesScannerProvisionOption feature : features) { |
| String fullFeatureUrl = feature.getURL(); |
| String[] split = fullFeatureUrl.split("\\!/"); |
| String url = split[0].replaceAll("scan-features:", ""); |
| retVal.add(new KarafDistributionConfigurationFileExtendOption(FeaturesCfg.REPOSITORIES, "," + url)); |
| retVal.add(new KarafDistributionConfigurationFileExtendOption(FeaturesCfg.BOOT, "," + split[1])); |
| } |
| return retVal; |
| } |
| |
| private void setupExamProperties(File karafHome, ExamSystem system) throws IOException { |
| File customPropertiesFile = new File(karafHome + "/etc/system.properties"); |
| SystemPropertyOption[] customProps = system.getOptions(SystemPropertyOption.class); |
| Properties karafPropertyFile = new Properties(); |
| karafPropertyFile.load(new FileInputStream(customPropertiesFile)); |
| for (SystemPropertyOption systemPropertyOption : customProps) { |
| karafPropertyFile.put(systemPropertyOption.getKey(), systemPropertyOption.getValue()); |
| } |
| karafPropertyFile.store(new FileOutputStream(customPropertiesFile), "updated by pax-exam"); |
| } |
| |
| private void updateLogProperties(File karafHome, ExamSystem system) throws IOException { |
| DoNotModifyLogOption[] modifyLog = system.getOptions(DoNotModifyLogOption.class); |
| if (modifyLog != null && modifyLog.length != 0) { |
| LOGGER.info("Log file should not be modified by the test framework"); |
| return; |
| } |
| String realLogLevel = retrieveRealLogLevel(system); |
| File customPropertiesFile = new File(karafHome + "/etc/org.ops4j.pax.logging.cfg"); |
| Properties karafPropertyFile = new Properties(); |
| karafPropertyFile.load(new FileInputStream(customPropertiesFile)); |
| karafPropertyFile.put("log4j.rootLogger", realLogLevel + ", out, stdout, osgi:*"); |
| karafPropertyFile.store(new FileOutputStream(customPropertiesFile), "updated by pax-exam"); |
| } |
| |
| private String retrieveRealLogLevel(ExamSystem system) { |
| LogLevelOption[] logLevelOptions = system.getOptions(LogLevelOption.class); |
| return logLevelOptions != null && logLevelOptions.length != 0 ? logLevelOptions[0].getLogLevel().toString() |
| : "WARN"; |
| } |
| |
| private String[] buildKarafClasspath(File karafHome) { |
| List<String> cp = new ArrayList<String>(); |
| File[] jars = new File(karafHome + "/lib").listFiles((FileFilter) new WildcardFileFilter("*.jar")); |
| for (File jar : jars) { |
| cp.add(jar.toString()); |
| } |
| return cp.toArray(new String[]{}); |
| } |
| |
| /** |
| * Since we might get quite deep use a simple breath first search algorithm |
| */ |
| private File searchKarafBase(File targetFolder) { |
| Queue<File> searchNext = new LinkedList<File>(); |
| searchNext.add(targetFolder); |
| while (!searchNext.isEmpty()) { |
| File head = searchNext.poll(); |
| if (!head.isDirectory()) { |
| continue; |
| } |
| boolean system = false; |
| boolean etc = false; |
| for (File file : head.listFiles()) { |
| if (file.isDirectory() && file.getName().equals("system")) { |
| system = true; |
| } |
| if (file.isDirectory() && file.getName().equals("etc")) { |
| etc = true; |
| } |
| } |
| if (system && etc) { |
| return head; |
| } |
| searchNext.addAll(Arrays.asList(head.listFiles())); |
| } |
| throw new IllegalStateException("No karaf base dir found in extracted distribution."); |
| } |
| |
| private void extractKarafDistribution(URL sourceDistribution, File targetFolder) throws IOException { |
| if (sourceDistribution.getProtocol().equals("file")) { |
| if (sourceDistribution.getFile().indexOf(".zip") > 0) { |
| extractZipDistribution(sourceDistribution, targetFolder); |
| } else if (sourceDistribution.getFile().indexOf(".tar.gz") > 0) { |
| extractTarGzDistribution(sourceDistribution, targetFolder); |
| } else { |
| throw new IllegalStateException( |
| "Unknow packaging of distribution; only zip or tar.gz could be handled."); |
| } |
| return; |
| } |
| if (sourceDistribution.toExternalForm().indexOf("/zip") > 0) { |
| extractZipDistribution(sourceDistribution, targetFolder); |
| } else if (sourceDistribution.toExternalForm().indexOf("/tar.gz") > 0) { |
| extractTarGzDistribution(sourceDistribution, targetFolder); |
| } else { |
| throw new IllegalStateException( |
| "Unknow packaging of distribution; only zip or tar.gz could be handled."); |
| } |
| } |
| |
| private void extractTarGzDistribution(URL sourceDistribution, File targetFolder) throws IOException, |
| FileNotFoundException { |
| File uncompressedFile = File.createTempFile("uncompressedTarGz-", ".tar"); |
| extractGzArchive(sourceDistribution.openStream(), uncompressedFile); |
| extract(new TarArchiveInputStream(new FileInputStream(uncompressedFile)), targetFolder); |
| FileUtils.forceDelete(uncompressedFile); |
| } |
| |
| private void extractZipDistribution(URL sourceDistribution, File targetFolder) throws IOException { |
| extract(new ZipArchiveInputStream(sourceDistribution.openStream()), targetFolder); |
| } |
| |
| private void extractGzArchive(InputStream tarGz, File tar) throws IOException { |
| BufferedInputStream in = new BufferedInputStream(tarGz); |
| FileOutputStream out = new FileOutputStream(tar); |
| GzipCompressorInputStream gzIn = new GzipCompressorInputStream(in); |
| final byte[] buffer = new byte[1000]; |
| int n = 0; |
| while (-1 != (n = gzIn.read(buffer))) { |
| out.write(buffer, 0, n); |
| } |
| out.close(); |
| gzIn.close(); |
| } |
| |
| private void extract(ArchiveInputStream is, File targetDir) throws IOException { |
| try { |
| if (targetDir.exists()) { |
| FileUtils.forceDelete(targetDir); |
| } |
| targetDir.mkdirs(); |
| ArchiveEntry entry = is.getNextEntry(); |
| while (entry != null) { |
| String name = entry.getName(); |
| name = name.substring(name.indexOf("/") + 1); |
| File file = new File(targetDir, name); |
| if (entry.isDirectory()) { |
| file.mkdirs(); |
| } else { |
| file.getParentFile().mkdirs(); |
| OutputStream os = new FileOutputStream(file); |
| try { |
| IOUtils.copy(is, os); |
| } finally { |
| IOUtils.closeQuietly(os); |
| } |
| } |
| entry = is.getNextEntry(); |
| } |
| } finally { |
| is.close(); |
| } |
| } |
| |
| @Override |
| public synchronized TestContainer stop() { |
| LOGGER.debug("Shutting down the test container (Pax Runner)"); |
| try { |
| if (started) { |
| target.stop(); |
| RemoteBundleContextClient remoteBundleContextClient = target.getClientRBC(); |
| if (remoteBundleContextClient != null) { |
| remoteBundleContextClient.stop(); |
| |
| } |
| if (runner != null) { |
| runner.shutdown(); |
| } |
| } else { |
| throw new RuntimeException("Container never came up"); |
| } |
| } finally { |
| started = false; |
| target = null; |
| if (deleteRuntime) { |
| system.clear(); |
| try { |
| FileUtils.forceDelete(targetFolder); |
| } catch (IOException e) { |
| LOGGER.info("Can't remove runtime system; shedule it for exit of the jvm."); |
| try { |
| FileUtils.forceDeleteOnExit(targetFolder); |
| } catch (IOException e1) { |
| LOGGER.error("Well, this should simply not happen..."); |
| } |
| } |
| } |
| } |
| return this; |
| } |
| |
| private void waitForState(final long bundleId, final int state, final RelativeTimeout timeout) |
| throws TimeoutException { |
| target.getClientRBC().waitForState(bundleId, state, timeout); |
| } |
| |
| @Override |
| public synchronized void call(TestAddress address) { |
| target.call(address); |
| } |
| |
| @Override |
| public synchronized long install(InputStream stream) { |
| return install("local", stream); |
| } |
| |
| @Override |
| public synchronized long install(String location, InputStream stream) { |
| return target.install(location, stream); |
| } |
| |
| @Override |
| public String toString() { |
| return "KarafTestContainer{" + framework.getFrameworkURL() + "}"; |
| } |
| |
| } |
