| /* |
| * 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.sling.installer.factory.model.impl; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.io.Reader; |
| import java.io.StringReader; |
| import java.util.ArrayList; |
| import java.util.Dictionary; |
| import java.util.HashMap; |
| import java.util.Hashtable; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import javax.jcr.RepositoryException; |
| import javax.jcr.Session; |
| |
| import org.apache.sling.installer.api.InstallableResource; |
| import org.apache.sling.installer.api.OsgiInstaller; |
| import org.apache.sling.installer.api.tasks.InstallationContext; |
| import org.apache.sling.installer.api.tasks.ResourceState; |
| import org.apache.sling.installer.api.tasks.TaskResource; |
| import org.apache.sling.installer.api.tasks.TaskResourceGroup; |
| import org.apache.sling.jcr.api.SlingRepository; |
| import org.apache.sling.jcr.repoinit.JcrRepoInitOpsProcessor; |
| import org.apache.sling.provisioning.model.Artifact; |
| import org.apache.sling.provisioning.model.ArtifactGroup; |
| import org.apache.sling.provisioning.model.Configuration; |
| import org.apache.sling.provisioning.model.Feature; |
| import org.apache.sling.provisioning.model.Model; |
| import org.apache.sling.provisioning.model.ModelUtility; |
| import org.apache.sling.provisioning.model.RunMode; |
| import org.apache.sling.provisioning.model.Section; |
| import org.apache.sling.provisioning.model.Traceable; |
| import org.apache.sling.provisioning.model.io.ModelArchiveReader; |
| import org.apache.sling.provisioning.model.io.ModelReader; |
| import org.apache.sling.repoinit.parser.RepoInitParser; |
| import org.apache.sling.repoinit.parser.RepoInitParsingException; |
| import org.apache.sling.repoinit.parser.operations.Operation; |
| import org.osgi.framework.BundleContext; |
| |
| /** |
| * This task installs model resources. |
| */ |
| public class InstallModelTask extends AbstractModelTask { |
| |
| private final Set<String> activeRunModes; |
| |
| private final SlingRepository repository; |
| |
| private final JcrRepoInitOpsProcessor repoInitProcessor; |
| |
| private final RepoInitParser repoInitParser; |
| |
| public InstallModelTask(final TaskResourceGroup group, |
| final Set<String> runModes, |
| final SlingRepository repository, |
| final JcrRepoInitOpsProcessor repoInitProcessor, |
| final RepoInitParser repoInitParser, |
| final BundleContext bundleContext) { |
| super(group, bundleContext); |
| this.activeRunModes = runModes; |
| this.repository = repository; |
| this.repoInitProcessor = repoInitProcessor; |
| this.repoInitParser = repoInitParser; |
| } |
| |
| @SuppressWarnings("deprecation") |
| @Override |
| public void execute(final InstallationContext ctx) { |
| try { |
| final TaskResource resource = this.getResource(); |
| ctx.log("Installing {}", resource.getEntityId()); |
| final String modelTxt = (String) resource.getAttribute(ModelTransformer.ATTR_MODEL); |
| final Integer featureIndex = (Integer) resource.getAttribute(ModelTransformer.ATTR_FEATURE_INDEX); |
| final String name = (String) resource.getAttribute(ModelTransformer.ATTR_FEATURE_NAME); |
| if ( modelTxt == null || featureIndex == null || name == null ) { |
| ctx.log("Unable to install model resource {} : no model found", resource); |
| this.getResourceGroup().setFinishState(ResourceState.IGNORED); |
| } else { |
| final String path = (String) resource.getAttribute(ModelTransformer.ATTR_BASE_PATH); |
| final File baseDir = (path == null ? null : new File(path)); |
| |
| boolean success = false; |
| try { |
| final Result result = this.transform(name, modelTxt, featureIndex, resource, baseDir); |
| if ( result == null ) { |
| ctx.log("Unable to install model resource {} : unable to create resources", resource); |
| this.getResourceGroup().setFinishState(ResourceState.IGNORED); |
| } else { |
| // repo init first |
| if ( result.repoinit != null ) { |
| List<Operation> ops = null; |
| try ( final Reader r = new StringReader(result.repoinit) ) { |
| ops = this.repoInitParser.parse(r); |
| } catch (final IOException | RepoInitParsingException e) { |
| logger.error("Unable to parse repoinit block.", e); |
| ctx.log("Unable to install model resource {} : unable parse repoinit block.", resource); |
| this.getResourceGroup().setFinishState(ResourceState.IGNORED); |
| return; |
| } |
| |
| // login admin is required for repo init |
| Session session = null; |
| try { |
| session = this.repository.loginAdministrative(null); |
| this.repoInitProcessor.apply(session, ops); |
| session.save(); |
| } catch ( final RepositoryException re) { |
| logger.error("Unable to process repoinit block.", re); |
| ctx.log("Unable to install model resource {} : unable to process repoinit block.", resource); |
| this.getResourceGroup().setFinishState(ResourceState.IGNORED); |
| return; |
| |
| } finally { |
| if ( session != null ) { |
| session.logout(); |
| } |
| } |
| } |
| if ( !result.resources.isEmpty() ) { |
| final OsgiInstaller installer = this.getService(OsgiInstaller.class); |
| if ( installer != null ) { |
| installer.registerResources("model-" + name, result.resources.toArray(new InstallableResource[result.resources.size()])); |
| } else { |
| ctx.log("Unable to install model resource {} : unable to get OSGi installer", resource); |
| this.getResourceGroup().setFinishState(ResourceState.IGNORED); |
| return; |
| } |
| } |
| this.getResourceGroup().setFinishState(ResourceState.INSTALLED); |
| success = true; |
| } |
| } finally { |
| if ( !success && baseDir != null ) { |
| this.deleteDirectory(baseDir); |
| } |
| } |
| if ( success ) { |
| ctx.log("Installed {}", resource.getEntityId()); |
| } |
| } |
| } finally { |
| this.cleanup(); |
| } |
| } |
| |
| public static final class Result { |
| public final List<InstallableResource> resources = new ArrayList<>(); |
| public String repoinit; |
| } |
| |
| private Result transform(final String name, |
| final String modelText, |
| final int featureIndex, |
| final TaskResource rsrc, |
| final File baseDir) { |
| Model model = null; |
| try ( final Reader reader = new StringReader(modelText)) { |
| model = ModelUtility.getEffectiveModel(ModelReader.read(reader, name)); |
| } catch ( final IOException ioe) { |
| logger.warn("Unable to read model file for feature " + name, ioe); |
| } |
| if ( model == null ) { |
| return null; |
| } |
| int index = 0; |
| final Iterator<Feature> iter = model.getFeatures().iterator(); |
| while ( iter.hasNext() ) { |
| iter.next(); |
| if ( index != featureIndex ) { |
| iter.remove(); |
| } |
| index++; |
| } |
| |
| if ( baseDir != null ) { |
| final List<Artifact> artifacts = new ArrayList<>(); |
| final Feature feature = model.getFeatures().get(0); |
| for(final RunMode rm : feature.getRunModes()) { |
| for(final ArtifactGroup group : rm.getArtifactGroups()) { |
| for(final Artifact a : group) { |
| artifacts.add(a); |
| } |
| } |
| } |
| |
| // extract artifacts |
| final byte[] buffer = new byte[1024*1024*256]; |
| |
| try ( final InputStream is = rsrc.getInputStream() ) { |
| ModelArchiveReader.read(is, new ModelArchiveReader.ArtifactConsumer() { |
| |
| @Override |
| public void consume(final Artifact artifact, final InputStream is) throws IOException { |
| if ( artifacts.contains(artifact) ) { |
| final File artifactFile = new File(baseDir, artifact.getRepositoryPath().replace('/', File.separatorChar)); |
| if ( !artifactFile.exists() ) { |
| artifactFile.getParentFile().mkdirs(); |
| try (final OutputStream os = new FileOutputStream(artifactFile)) { |
| int l = 0; |
| while ( (l = is.read(buffer)) > 0 ) { |
| os.write(buffer, 0, l); |
| } |
| } |
| } |
| } |
| } |
| }); |
| } catch ( final IOException ioe) { |
| logger.warn("Unable to extract artifacts from model " + name, ioe); |
| return null; |
| } |
| } |
| |
| final List<ArtifactDescription> files = new ArrayList<>(); |
| |
| Map<Traceable, String> errors = collectArtifacts(model, files, baseDir); |
| if ( errors == null ) { |
| final Result result = new Result(); |
| for(final ArtifactDescription desc : files) { |
| if ( desc.artifactFile != null ) { |
| try { |
| final InputStream is = new FileInputStream(desc.artifactFile); |
| final String digest = String.valueOf(desc.artifactFile.lastModified()); |
| // handle start level |
| final Dictionary<String, Object> dict = new Hashtable<String, Object>(); |
| if ( desc.startLevel > 0 ) { |
| dict.put(InstallableResource.BUNDLE_START_LEVEL, desc.startLevel); |
| } |
| dict.put(InstallableResource.RESOURCE_URI_HINT, desc.artifactFile.toURI().toString()); |
| |
| result.resources.add(new InstallableResource("/" + desc.artifactFile.getName(), is, dict, digest, |
| InstallableResource.TYPE_FILE, null)); |
| } catch ( final IOException ioe ) { |
| logger.warn("Unable to read artifact " + desc.artifactFile, ioe); |
| return null; |
| } |
| } else if ( desc.cfg != null ) { |
| final String id = (desc.cfg.getFactoryPid() != null ? desc.cfg.getFactoryPid() + "-" + desc.cfg.getPid() : desc.cfg.getPid()); |
| result.resources.add(new InstallableResource("/" + id + ".config", |
| null, |
| desc.cfg.getProperties(), |
| null, |
| InstallableResource.TYPE_CONFIG, null)); |
| |
| } else if ( desc.section != null ) { |
| result.repoinit = desc.section.getContents(); |
| } |
| } |
| return result; |
| } |
| logger.warn("Errors during parsing model file {} : {}", name, errors.values()); |
| |
| return null; |
| } |
| |
| private static class ArtifactDescription { |
| public int startLevel; |
| public File artifactFile; |
| public Configuration cfg; |
| public Section section; |
| } |
| |
| private Map<Traceable, String> collectArtifacts(final Model effectiveModel, |
| final List<ArtifactDescription> files, |
| final File baseDir) { |
| final RepositoryAccess repo = new RepositoryAccess(); |
| final Map<Traceable, String> errors = new HashMap<>(); |
| for(final Feature f : effectiveModel.getFeatures()) { |
| if ( f.isSpecial() ) { |
| continue; |
| } |
| for(final Section section : f.getAdditionalSections()) { |
| final ArtifactDescription desc = new ArtifactDescription(); |
| desc.section = section; |
| files.add(desc); |
| } |
| for(final RunMode mode : f.getRunModes()) { |
| if ( mode.isSpecial() ) { |
| continue; |
| } |
| if ( mode.isActive(this.activeRunModes) ) { |
| for(final ArtifactGroup group : mode.getArtifactGroups()) { |
| for(final Artifact artifact : group) { |
| File file = (baseDir == null ? null : new File(baseDir, artifact.getRepositoryPath().replace('/', File.separatorChar))); |
| if ( file == null || !file.exists() ) { |
| file = repo.get(artifact); |
| } |
| if ( file == null ) { |
| errors.put(artifact, "Artifact " + artifact.toMvnUrl() + " not found."); |
| } else { |
| final ArtifactDescription desc = new ArtifactDescription(); |
| desc.artifactFile = file; |
| desc.startLevel = group.getStartLevel(); |
| files.add(desc); |
| } |
| } |
| } |
| for(final Configuration cfg : mode.getConfigurations() ) { |
| if ( cfg.isSpecial() ) { |
| continue; |
| } |
| final ArtifactDescription desc = new ArtifactDescription(); |
| desc.cfg = cfg; |
| files.add(desc); |
| } |
| } |
| } |
| } |
| return errors.isEmpty() ? null : errors; |
| } |
| |
| @Override |
| public String getSortKey() { |
| return "30-" + getResource().getAttribute(ModelTransformer.ATTR_FEATURE_NAME); |
| } |
| } |
