| /* |
| * 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.jackrabbit.vault.fs.impl; |
| |
| import java.io.IOException; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.TreeMap; |
| |
| import javax.jcr.RepositoryException; |
| |
| import org.apache.jackrabbit.vault.fs.DirectoryArtifact; |
| import org.apache.jackrabbit.vault.fs.api.Aggregate; |
| import org.apache.jackrabbit.vault.fs.api.Artifact; |
| import org.apache.jackrabbit.vault.fs.api.ArtifactType; |
| import org.apache.jackrabbit.vault.fs.api.ImportArtifact; |
| import org.apache.jackrabbit.vault.fs.api.ImportInfo; |
| import org.apache.jackrabbit.vault.fs.api.SerializationType; |
| import org.apache.jackrabbit.vault.fs.api.VaultFile; |
| import org.apache.jackrabbit.vault.fs.api.VaultFileOutput; |
| import org.apache.jackrabbit.vault.fs.api.VaultFileSystem; |
| import org.apache.jackrabbit.vault.fs.api.VaultFsTransaction; |
| import org.apache.jackrabbit.vault.fs.api.VaultInputSource; |
| import org.apache.jackrabbit.vault.fs.impl.io.DocViewAnalyzer; |
| import org.apache.jackrabbit.vault.fs.impl.io.ImportInfoImpl; |
| import org.apache.jackrabbit.vault.fs.impl.io.InputSourceArtifact; |
| import org.apache.jackrabbit.vault.fs.impl.io.XmlAnalyzer; |
| import org.apache.jackrabbit.vault.fs.io.AutoSave; |
| import org.apache.jackrabbit.vault.fs.io.DocViewAnalyzerListener; |
| import org.apache.jackrabbit.vault.util.Constants; |
| import org.apache.jackrabbit.vault.util.PathComparator; |
| import org.apache.jackrabbit.vault.util.PathUtil; |
| import org.apache.jackrabbit.vault.util.PlatformNameFormat; |
| import org.apache.jackrabbit.vault.util.Text; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| /** |
| * Provides transactional brackets around a write back transaction to |
| * the Vault filesystem. a transaction is always needed due to the fact that |
| * several jcr files could belong to the same artifact. |
| * |
| * TODO: check all vault operations! |
| * |
| */ |
| public class TransactionImpl implements VaultFsTransaction { |
| |
| /** |
| * default logger |
| */ |
| private static final Logger log = LoggerFactory.getLogger(TransactionImpl.class); |
| |
| private final VaultFileSystem fs; |
| |
| private final List<Change> changes = new LinkedList<Change>(); |
| |
| private final Map<String, DotXmlInfo> dotXmlNodes = new HashMap<String, DotXmlInfo>(); |
| |
| private boolean verbose; |
| |
| private final AutoSave autoSave = new AutoSave(); |
| |
| public TransactionImpl(VaultFileSystem fs) { |
| this.fs = fs; |
| } |
| |
| public AutoSave getAutoSave() { |
| return autoSave; |
| } |
| |
| public boolean isVerbose() { |
| return verbose; |
| } |
| |
| public void setVerbose(boolean verbose) { |
| this.verbose = verbose; |
| } |
| |
| public void delete(VaultFile file) throws IOException { |
| if (file != null) { |
| changes.add(new Change(Type.DELETED, file, null)); |
| } |
| } |
| |
| public void modify(VaultFile file, VaultInputSource input) throws IOException { |
| final Change change = new Change(Type.MODIFIED, file, input); |
| changes.add(change); |
| |
| // special handling for .content.xml |
| if (file.getName().equals(Constants.DOT_CONTENT_XML)) { |
| String repoParentPath = file.getAggregate().getPath(); |
| // analyze the xml to scan for added nodes |
| DocViewAnalyzer.analyze( |
| new DocViewAnalyzerListener(){ |
| public void onNode(String path, boolean intermediate, String nodeType) { |
| if (!intermediate) { |
| dotXmlNodes.put(path, new DotXmlInfo(change, nodeType == null)); |
| } |
| } |
| }, fs.getAggregateManager().getSession(), repoParentPath, input); |
| } |
| } |
| |
| public VaultFileOutput add(String path, VaultInputSource input) |
| throws IOException, RepositoryException { |
| |
| String repoPath = PlatformNameFormat.getRepositoryPath(path, true); |
| String repoName = Text.getName(repoPath); |
| String parentPath = Text.getRelativeParent(path, 1); |
| String repoParentPath = Text.getRelativeParent(repoPath, 1); |
| |
| if (repoName.equals(Constants.DOT_CONTENT_XML)) { |
| // special handling for .content.xml |
| final Change change = new Change(Type.ADDED_X, repoParentPath, path, input); |
| changes.add(change); |
| |
| // analyze the xml to scan for added nodes |
| DocViewAnalyzer.analyze( |
| new DocViewAnalyzerListener(){ |
| public void onNode(String path, boolean intermediate, String nodeType) { |
| if (!intermediate) { |
| dotXmlNodes.put(path, new DotXmlInfo(change, nodeType == null)); |
| } |
| } |
| }, fs.getAggregateManager().getSession(), repoParentPath, input); |
| // create artifact |
| String parentExt = parentPath.endsWith(".dir") ? ".dir" : ""; |
| Artifact parent = new DirectoryArtifact(Text.getName(repoParentPath), parentExt); |
| InputSourceArtifact isa = new InputSourceArtifact( |
| parent, |
| Constants.DOT_CONTENT_XML, |
| "", |
| ArtifactType.PRIMARY, input, |
| SerializationType.XML_DOCVIEW); |
| isa.setContentType("text/xml"); |
| // attach to change |
| change.isa = isa; |
| return new VaultFileOutputImpl(change); |
| |
| } else { |
| // normal file, detect type |
| SerializationType serType = SerializationType.GENERIC; |
| ArtifactType aType = ArtifactType.FILE; |
| String extension = ""; |
| int idx = repoName.lastIndexOf('.'); |
| if (idx > 0) { |
| String base = repoName.substring(0, idx); |
| String ext = repoName.substring(idx); |
| if (ext.equals(".xml")) { |
| // this can either be an generic exported docview or |
| // a 'user-xml' that is imported as file |
| // btw: this only works for input sources that can |
| // refetch their input stream |
| serType = XmlAnalyzer.analyze(input); |
| if (serType == SerializationType.XML_DOCVIEW) { |
| // in this case, the extension was added by the exporter. |
| aType = ArtifactType.PRIMARY; |
| repoName = base; |
| extension = ext; |
| } else { |
| // force generic |
| serType = SerializationType.GENERIC; |
| } |
| } else if (ext.equals(".xcnd")) { |
| aType = ArtifactType.PRIMARY; |
| serType = SerializationType.CND; |
| repoName = base; |
| extension = ext; |
| } else if (ext.equals(".binary")) { |
| aType = ArtifactType.BINARY; |
| repoName = base; |
| extension = ext; |
| } |
| } |
| InputSourceArtifact isa = new InputSourceArtifact(null, repoName, |
| extension, aType, input, serType); |
| |
| Change change = new Change(Type.ADDED, repoParentPath + "/" + repoName, path, input); |
| change.isa = isa; |
| changes.add(change); |
| return new VaultFileOutputImpl(change); |
| } |
| } |
| |
| public void mkdir(String path) throws IOException, RepositoryException { |
| changes.add(new Change(Type.MKDIR, PlatformNameFormat.getRepositoryPath(path), path, null)); |
| } |
| |
| public Collection<Info> commit() throws RepositoryException, IOException { |
| Map<String, Info> infos = new HashMap<String, Info>(); |
| |
| // remember all nodes to checkin again |
| ImportInfoImpl allInfos = new ImportInfoImpl(); |
| |
| // first scan all changes for additions that need to be attached to a |
| // .content.xml change |
| if (!dotXmlNodes.isEmpty()) { |
| Iterator<Change> iter = changes.iterator(); |
| while (iter.hasNext()) { |
| Change c = iter.next(); |
| if (c.type == Type.ADDED) { |
| if (c.isa.getType() == ArtifactType.BINARY) { |
| DotXmlInfo dxi = dotXmlNodes.get(c.repoPath); |
| if (dxi != null) { |
| dxi.change.add(c); |
| iter.remove(); |
| } |
| } |
| } else if (c.type == Type.MKDIR) { |
| DotXmlInfo dxi = dotXmlNodes.get(c.repoPath); |
| if (dxi != null) { |
| iter.remove(); |
| } |
| } |
| } |
| } |
| |
| // process the changes and group them by artifact path |
| Map<String, TxInfo> modified = new TreeMap<String, TxInfo>(new PathComparator()); |
| boolean ignoreMP = true; |
| while (!changes.isEmpty()) { |
| int size = changes.size(); |
| // process as many changes that have a parent file |
| Iterator<Change> iter = changes.iterator(); |
| while (iter.hasNext()) { |
| Change change = iter.next(); |
| if (processChange(change, modified, ignoreMP)) { |
| changes.remove(change); |
| iter = changes.iterator(); |
| } |
| } |
| if (changes.size() == size) { |
| if (ignoreMP) { |
| ignoreMP = false; |
| } else { |
| for (Change c: changes) { |
| infos.put(c.filePath, new Info(Type.ERROR, c.filePath)); |
| } |
| // abort iteration |
| changes.clear(); |
| } |
| } else { |
| // write back the current collected modifications and generate a |
| // new modified info list |
| for (TxInfo info : modified.values()) { |
| |
| // check if primary artifact is still present |
| if (info.out == null && info.aggregate == null) { |
| // this was an intermediate directory delete |
| for (String path: info.original.keySet()) { |
| infos.put(path, new Info(Type.DELETED, path)); |
| if (verbose) { |
| log.info("...comitting DEL {}", path); |
| } |
| } |
| } else if (info.out.getArtifacts().isEmpty() && info.aggregate != null) { |
| // delete entire node if aggregate is still attached |
| if (info.aggregate.isAttached()) { |
| info.aggregate.remove(false); |
| } |
| // generate infos for the deleted ones |
| for (String path: info.original.keySet()) { |
| infos.put(path, new Info(Type.DELETED, path)); |
| if (verbose) { |
| log.info("...comitting DEL {}", path); |
| } |
| } |
| // mark the primary artifact of the parent as modified |
| // TODO fix |
| String cXmlPath = info.parentFile.getPath(); |
| if (cXmlPath.endsWith("/")) { |
| cXmlPath+= Constants.DOT_CONTENT_XML; |
| } else { |
| cXmlPath+= "/" + Constants.DOT_CONTENT_XML; |
| } |
| Info i = infos.get(cXmlPath); |
| if (i == null) { |
| infos.put(cXmlPath, new Info(Type.MODIFIED, cXmlPath)); |
| } |
| } else if (info.aggregate == null) { |
| // this was and addition |
| // for now, just guess from the artifacts the new files |
| String parentPath = info.parentFile.getPath(); |
| if (!parentPath.endsWith("/")) { |
| parentPath += "/"; |
| } |
| for (Artifact a: info.out.getArtifacts().values()) { |
| if (a instanceof ImportArtifact) { |
| String path = parentPath + a.getPlatformPath(); |
| infos.put(path, new Info(Type.ADDED, path)); |
| } |
| } |
| |
| ImportInfo ret = info.out.close(); |
| if (ret != null) { |
| allInfos.merge(ret); |
| if (verbose) { |
| for (Map.Entry e: ret.getModifications().entrySet()) { |
| log.info("...comitting {} {}", e.getValue(), e.getKey()); |
| } |
| } |
| } |
| // modify parent |
| infos.put(info.parentFile.getPath(), new Info(Type.MODIFIED, info.parentFile.getPath())); |
| |
| } else { |
| // this was a modification |
| ImportInfo ret = info.out.close(); |
| if (ret != null) { |
| allInfos.merge(ret); |
| } |
| for (VaultFile file: info.original.values()) { |
| infos.put(file.getPath(), new Info(Type.MODIFIED, file.getPath())); |
| if (verbose) { |
| log.info("...comitting UPD {}", file.getPath()); |
| } |
| } |
| if (verbose && ret != null) { |
| for (Map.Entry e: ret.getModifications().entrySet()) { |
| log.info("...comitting {} {}", e.getValue(), e.getKey()); |
| } |
| } |
| } |
| } |
| } |
| modified.clear(); |
| fs.invalidate(); |
| } |
| if (verbose) { |
| log.info("Persisting changes..."); |
| } |
| if (allInfos.numErrors() > 0) { |
| try { |
| fs.getAggregateManager().getSession().refresh(false); |
| } catch (RepositoryException e) { |
| // ignore |
| } |
| throw new RepositoryException("There were errors during commit. Aborting transaction."); |
| } |
| fs.getAggregateManager().getSession().save(); |
| allInfos.checkinNodes(fs.getAggregateManager().getSession()); |
| fs.invalidate(); |
| return infos.values(); |
| } |
| |
| |
| private boolean processChange(Change change, Map<String, TxInfo> modified, boolean ignoreMP) |
| throws RepositoryException, IOException { |
| switch (change.type) { |
| case ADDED_X: { |
| // special handling for .content.xml |
| // filePath: /vltTest/foo/.content.xml |
| // repoPath: /vltTest/foo |
| |
| // parentPath: /vltTest/foo |
| String parentPath = Text.getRelativeParent(change.filePath, 1); |
| VaultFile parent = fs.getFile(parentPath); |
| TxInfo txInfo; |
| String repoPath; |
| if (parent == null) { |
| // parentPath: /vltTest |
| parentPath = Text.getRelativeParent(parentPath, 1); |
| parent = fs.getFile(parentPath); |
| repoPath = change.repoPath; |
| String repoName = Text.getName(repoPath); |
| if (parent == null) { |
| // special case if parent is an intermediate directory |
| // that is not created yet. for example _jcr_content |
| // /header.png/_jcr_content/renditions |
| |
| // check if parent node exists |
| if (!fs.getAggregateManager().getSession().nodeExists(Text.getRelativeParent(repoPath, 1))) { |
| return false; |
| } |
| while ((parent == null || parent.getAggregate() == null) |
| && parentPath.length() > 0) { |
| String parentName = Text.getName(parentPath); |
| if (parentName.endsWith(".dir")) { |
| parentName = parentName.substring(0, parentName.length() - 4); |
| } |
| repoName = PlatformNameFormat.getRepositoryName(parentName) + "/" + repoName; |
| parentPath = Text.getRelativeParent(parentPath, 1); |
| parent = fs.getFile(parentPath); |
| } |
| if (parent == null || parent.getAggregate() == null) { |
| return false; |
| } |
| String repoRelPath = Text.getName(parentPath) + "/" + repoName; |
| txInfo = modified.get(parent.getAggregate().getPath()); |
| if (txInfo == null) { |
| txInfo = new TxInfo(parent.getAggregate()); |
| modified.put(parent.getAggregate().getPath(), txInfo); |
| } |
| txInfo.out.getArtifacts().add(new InputSourceArtifact(null, |
| repoRelPath, change.isa.getExtension(), |
| ArtifactType.FILE, |
| change.isa.getInputSource(), change.isa.getSerializationType() |
| )); |
| } else { |
| // repoPath: /vltTest.foo |
| assertInFilter(repoPath); |
| txInfo = modified.get(repoPath); |
| if (txInfo == null) { |
| txInfo = new TxInfo(repoPath, |
| ((AggregateImpl) parent.getAggregate()).create(repoName)); |
| txInfo.parentFile = parent; |
| modified.put(repoPath, txInfo); |
| } |
| txInfo.out.getArtifacts().add(change.isa); |
| } |
| } else { |
| // repoPath: /vltTest/foo |
| repoPath = parent.getAggregate().getPath(); |
| assertInFilter(repoPath); |
| txInfo = modified.get(repoPath); |
| if (txInfo == null) { |
| txInfo = new TxInfo(parent.getAggregate()); |
| txInfo.parentFile = parent; |
| modified.put(repoPath, txInfo); |
| } |
| txInfo.out.getArtifacts().add(change.isa); |
| } |
| if (txInfo == null) { |
| return false; |
| } |
| // add sub changes |
| if (change.subChanges != null) { |
| for (Change sc: change.subChanges) { |
| // need to adjust relative path of input |
| // repoPath = /vltTest/foo |
| // sc.repoPath = /vltTest/foo/text/file |
| // relPath = foo/text/file |
| String relPath = PathUtil.getRelativePath(repoPath, sc.repoPath); |
| relPath = Text.getName(repoPath) + "/" + relPath; |
| if (!relPath.equals(sc.isa.getRelativePath())) { |
| // todo: check if correct platform path |
| sc.isa = new InputSourceArtifact( |
| null, |
| relPath, |
| "", |
| sc.isa.getType(), |
| sc.isa.getInputSource(), |
| sc.isa.getSerializationType() |
| ); |
| } |
| txInfo.out.getArtifacts().add(sc.isa); |
| } |
| } |
| if (verbose) { |
| log.info("...scheduling ADD {}/{}", parent.getPath(), Constants.DOT_CONTENT_XML); |
| } |
| } break; |
| case ADDED: { |
| // get parent file |
| String parentPath = Text.getRelativeParent(change.filePath, 1); |
| |
| // stop processing if parent file does not exist. |
| VaultFile parent = fs.getFile(parentPath); |
| String repoName = change.isa.getRelativePath(); |
| if (parent == null || parent.getAggregate() == null) { |
| if (ignoreMP) { |
| return false; |
| } |
| // Hack: if parent is intermediate directory, search |
| // next valid parent and modify its artifact set. |
| // since we cannot easily determine if the parent is an |
| // intermediate directory, we just process all failing ones |
| // at the end. |
| while ((parent == null || parent.getAggregate() == null) |
| && parentPath.length() > 0) { |
| String parentName = Text.getName(parentPath); |
| if (parentName.endsWith(".dir")) { |
| parentName = parentName.substring(0, parentName.length() - 4); |
| } |
| repoName = PlatformNameFormat.getRepositoryName(parentName) + "/" + repoName; |
| parentPath = Text.getRelativeParent(parentPath, 1); |
| parent = fs.getFile(parentPath); |
| } |
| if (parent == null) { |
| // no parent found ? |
| return false; |
| } |
| String repoPath = parent.getAggregate().getPath(); |
| String repoRelPath = Text.getName(repoPath) + "/" + repoName; |
| if (!repoPath.endsWith("/")) { |
| repoPath += "/"; |
| } |
| repoPath += repoName; |
| assertInFilter(repoPath); |
| if (false && change.isa.getSerializationType() == SerializationType.XML_DOCVIEW) { |
| // special case that full coverage is below a intermediate |
| // ignore and wait for next cycle |
| } else { |
| TxInfo txInfo = modified.get(parent.getAggregate().getPath()); |
| if (txInfo == null) { |
| txInfo = new TxInfo(parent.getAggregate()); |
| modified.put(parent.getAggregate().getPath(), txInfo); |
| } |
| txInfo.out.getArtifacts().add(new InputSourceArtifact(null, |
| repoRelPath, change.isa.getExtension(), |
| ArtifactType.FILE, |
| change.isa.getInputSource(), change.isa.getSerializationType() |
| )); |
| } |
| } else { |
| String repoPath = parent.getAggregate().getPath(); |
| |
| if (!repoPath.endsWith("/")) { |
| repoPath += "/"; |
| } |
| repoPath += repoName; |
| assertInFilter(repoPath); |
| TxInfo txInfo = modified.get(repoPath); |
| if (txInfo == null) { |
| txInfo = new TxInfo(repoPath, ((AggregateImpl) parent.getAggregate()).create(repoName)); |
| txInfo.setParentFile(parent); |
| modified.put(repoPath, txInfo); |
| } |
| txInfo.out.getArtifacts().add(change.isa); |
| |
| } |
| if (verbose) { |
| log.info("...scheduling ADD {}/{}", parent.getPath(), repoName); |
| } |
| } break; |
| case MKDIR:{ |
| // get parent file |
| String parentPath = Text.getRelativeParent(change.filePath, 1); |
| String name = Text.getName(change.filePath); |
| VaultFile parent = fs.getFile(parentPath); |
| if (parent == null || parent.isTransient()) { |
| return false; |
| } |
| String repoName = PlatformNameFormat.getRepositoryName(name); |
| int idx = repoName.lastIndexOf('.'); |
| if (idx > 0) { |
| String base = repoName.substring(0, idx); |
| String ext = repoName.substring(idx); |
| if (ext.equals(".dir")) { |
| // assume no directories with .dir extension |
| repoName = base; |
| } |
| } |
| String repoPath = parent.getAggregate().getPath(); |
| if (!repoPath.endsWith("/")) { |
| repoPath += "/"; |
| } |
| repoPath += repoName; |
| assertInFilter(repoPath); |
| TxInfo txInfo = modified.get(repoPath); |
| if (txInfo == null) { |
| txInfo = new TxInfo(repoPath, ((AggregateImpl) parent.getAggregate()).create(repoName)); |
| txInfo.setParentFile(parent); |
| modified.put(repoPath, txInfo); |
| } |
| txInfo.out.addArtifact(new DirectoryArtifact(repoName)); |
| if (verbose) { |
| log.info("...scheduling MKD {}/{}", parent.getPath(), repoName); |
| } |
| } break; |
| case DELETED: { |
| Aggregate an = change.file.getAggregate(); |
| if (an == null) { |
| // intermediate directory |
| // can't handle here |
| assertInFilter(change.repoPath); |
| TxInfo txInfo = new TxInfo(change.repoPath, null); |
| txInfo.original.put(change.file.getPath(), change.file); |
| modified.put(txInfo.artifactsPath, txInfo); |
| } else { |
| assertInFilter(an.getPath()); |
| TxInfo txInfo = modified.get(an.getPath()); |
| if (txInfo == null) { |
| txInfo = new TxInfo(an); |
| VaultFile dir = null; |
| for (VaultFile rel : change.file.getRelated()) { |
| txInfo.original.put(rel.getPath(), rel); |
| if (rel.isDirectory()) { |
| dir = rel; |
| } |
| } |
| modified.put(txInfo.artifactsPath, txInfo); |
| // set parent file |
| if (dir == null) { |
| txInfo.parentFile = change.file.getParent(); |
| } else { |
| txInfo.parentFile = dir.getParent(); |
| } |
| } |
| txInfo.out.getArtifacts().remove(change.file.getArtifact()); |
| if (verbose) { |
| log.info("...scheduling DEL {}", an.getPath()); |
| } |
| } |
| } break; |
| case MODIFIED: { |
| Aggregate an = change.file.getAggregate(); |
| TxInfo txInfo = modified.get(an.getPath()); |
| if (txInfo == null) { |
| txInfo = new TxInfo(an); |
| VaultFile dir = null; |
| for (VaultFile rel: change.file.getRelated()) { |
| txInfo.original.put(rel.getPath(), rel); |
| if (rel.isDirectory()) { |
| dir = rel; |
| } |
| } |
| modified.put(txInfo.artifactsPath, txInfo); |
| // set parent file |
| if (dir == null) { |
| txInfo.parentFile = change.file.getParent(); |
| } else { |
| txInfo.parentFile = dir.getParent(); |
| } |
| } |
| InputSourceArtifact isa = new InputSourceArtifact(change.file.getArtifact(), change.input); |
| txInfo.out.getArtifacts().put(isa); |
| // add sub changes |
| if (change.subChanges != null) { |
| for (Change sc: change.subChanges) { |
| // need to adjust relative path of input |
| // repoPath = /vltTest/foo |
| // sc.repoPath = /vltTest/foo/text/file |
| // relPath = foo/text/file |
| String relPath = PathUtil.getRelativePath(change.repoPath, sc.repoPath); |
| relPath = Text.getName(change.repoPath) + "/" + relPath; |
| if (!relPath.equals(sc.isa.getRelativePath())) { |
| // todo: check if correct platform path |
| sc.isa = new InputSourceArtifact( |
| null, |
| relPath, |
| sc.isa.getExtension(), |
| sc.isa.getType(), |
| sc.isa.getInputSource(), |
| sc.isa.getSerializationType() |
| ); |
| } |
| txInfo.out.getArtifacts().add(sc.isa); |
| } |
| } |
| |
| if (verbose) { |
| log.info("...scheduling UPD {}/{}", isa.getRelativePath()); |
| } |
| } break; |
| case MOVED: |
| case ERROR: |
| break; |
| } |
| return true; |
| } |
| |
| private void assertInFilter(String repoPath) { |
| if (!fs.getWorkspaceFilter().contains(repoPath)) { |
| log.warn("{} is excluded by the workspace filter. continuing with unknown results.", repoPath); |
| } |
| } |
| |
| protected static class Change { |
| |
| private final Type type; |
| |
| private VaultFile file; |
| |
| private VaultInputSource input; |
| |
| private String filePath; |
| |
| private String repoPath; |
| |
| private InputSourceArtifact isa; |
| |
| private LinkedList<Change> subChanges; |
| |
| public Change(Type type, VaultFile file, VaultInputSource input) { |
| this.type = type; |
| this.file = file; |
| this.repoPath = file.getAggregatePath(); |
| String relPath = file.getRepoRelPath(); |
| if (relPath != null && relPath.length() > 0) { |
| this.repoPath += "/" + relPath; |
| } |
| this.input = input; |
| } |
| |
| public Change(Type type, String repoPath, String filePath, VaultInputSource input) { |
| this.type = type; |
| this.repoPath = repoPath; |
| this.input = input; |
| this.filePath = filePath; |
| } |
| |
| public void setInputSource(VaultInputSource input) { |
| this.input = input; |
| } |
| |
| public void setContentType(String contentType) { |
| if (isa != null) { |
| isa.setContentType(contentType); |
| } |
| } |
| |
| public void add(Change c) { |
| if (subChanges == null) { |
| subChanges = new LinkedList<Change>(); |
| } |
| subChanges.add(c); |
| } |
| } |
| |
| private static class DotXmlInfo { |
| |
| private final Change change; |
| |
| private final boolean intermediate; |
| |
| private DotXmlInfo(Change change, boolean intermediate) { |
| this.change = change; |
| this.intermediate = intermediate; |
| } |
| } |
| private static class TxInfo { |
| |
| private final AggregateImpl aggregate; |
| |
| private final String artifactsPath; |
| |
| private final AggregateBuilder out; |
| |
| private final Map<String, VaultFile> original = new HashMap<String, VaultFile>(); |
| |
| private VaultFile parentFile; |
| |
| public TxInfo(Aggregate a) throws RepositoryException { |
| aggregate = (AggregateImpl) a; |
| artifactsPath = a.getPath(); |
| out = aggregate.getBuilder(); |
| } |
| |
| public TxInfo(String artifactsPath, AggregateBuilder out) { |
| aggregate = null; |
| this.artifactsPath = artifactsPath; |
| this.out = out; |
| } |
| |
| public void setParentFile(VaultFile parentFile) { |
| this.parentFile = parentFile; |
| } |
| } |
| |
| } |
