import org.exist.xmldb.XmldbURI; //导入依赖的package包/类
@Test
public void dropSingleDocument() {
    final BrokerPool pool = existEmbeddedServer.getBrokerPool();
    final TransactionManager transact = pool.getTransactionManager();
    try (final DBBroker broker = pool.get(Optional.of(pool.getSecurityManager().getSystemSubject()));
         final Txn transaction = transact.beginTransaction()) {

        TDBIndexWorker worker = (TDBIndexWorker) broker.getIndexController().getWorkerByIndexId(TDBRDFIndex.ID);

        DocumentSet docs = configureAndStore(COLLECTION_CONFIG, XML, "dropDocument.xml");
        DocumentImpl doc = docs.getDocumentIterator().next();

        assertTrue(worker.isDocumentIndexed(doc));

        root.removeXMLResource(transaction, broker, XmldbURI.create("dropDocument.xml"));

        transact.commit(transaction);

        assertFalse(worker.isDocumentIndexed(doc));

    } catch (Exception e) {
        e.printStackTrace();
        fail(e.getMessage());
    }
}
 

import org.exist.xmldb.XmldbURI; //导入依赖的package包/类
private DocumentSet configureAndStore(String configuration, String data, String docName) {
    MutableDocumentSet docs = new DefaultDocumentSet();
    final BrokerPool pool = existEmbeddedServer.getBrokerPool();
    final TransactionManager transact = pool.getTransactionManager();
    try (final DBBroker broker = pool.get(Optional.of(pool.getSecurityManager().getSystemSubject()));
         final Txn transaction = transact.beginTransaction()) {

        if (configuration != null) {
            CollectionConfigurationManager mgr = pool.getConfigurationManager();
            mgr.addConfiguration(transaction, broker, root, configuration);
        }

        IndexInfo info = root.validateXMLResource(transaction, broker, XmldbURI.create(docName), data);
        assertNotNull(info);
        root.store(transaction, broker, info, data);

        docs.add(info.getDocument());
        transact.commit(transaction);
    } catch (Exception e) {
        e.printStackTrace();
        fail(e.getMessage());
    }
    return docs;
}
 

import org.exist.xmldb.XmldbURI; //导入依赖的package包/类
@After
    public void cleanup() throws EXistException {
        final BrokerPool pool = existEmbeddedServer.getBrokerPool();
        final TransactionManager transact = pool.getTransactionManager();
        try (final DBBroker broker = pool.get(Optional.of(pool.getSecurityManager().getSystemSubject()));
             final Txn transaction = transact.beginTransaction()) {

            Collection collConfig = broker.getOrCreateCollection(transaction,
                    XmldbURI.create(XmldbURI.CONFIG_COLLECTION + "/db"));
            assertNotNull(collConfig);
            broker.removeCollection(transaction, collConfig);

            if (root != null) {
                assertNotNull(root);
                broker.removeCollection(transaction, root);
            }
            transact.commit(transaction);

//            Configuration config = BrokerPool.getInstance().getConfiguration();
//            config.setProperty(Indexer.PROPERTY_PRESERVE_WS_MIXED_CONTENT, savedConfig);
        } catch (Exception e) {
            e.printStackTrace();
            fail(e.getMessage());
        }
    }
 

import org.exist.xmldb.XmldbURI; //导入依赖的package包/类
@Override
public void configure(final DBBroker broker, final Collection collection, final Map<String, List<? extends Object>> parameters) throws TriggerException {

    //extract the black list parameter value from the parameters
    final List<String> lst = (List<String>)parameters.get(BLACKLIST_PARAM);
    if(lst == null) {
        throw new TriggerException("The parameter '" + blacklist + "' has not been provided in the collection configuration of '" + collection.getURI() + "' for '" + getClass().getName() + "'.");
    }

    for(final String blacklisted : lst) {
        try {
            this.blacklist.add(XmldbURI.create(blacklisted));
        } catch(final IllegalArgumentException iae) {
            LOG.warn("Skipping... collection uri '" + blacklisted + "' provided in the black list is invalid: " + iae.getMessage());
        }
    }

    //extract the optional protectMode parameter value from the parameters
    final List<String> protect = (List<String>)parameters.get(PROTECT_MOVE_PARAM);
    if(protect != null && protect.size() == 1) {
        this.protectMove = Boolean.parseBoolean(protect.get(0));
    }
}
 

import org.exist.xmldb.XmldbURI; //导入依赖的package包/类
@Override
public void beforeMoveCollection(final DBBroker broker, final Txn txn, final Collection collection, final XmldbURI newUri) throws TriggerException {
    /**
     * If we are protecting moves (as a form
     * of delete) and the collection is on
     * the blacklist, we throw a TriggerException
     * to abort the operation which is attempting
     * to move the collection.
     *
     * After all a Move would remove the
     * original location of the collection!
     */
    if(protectMove && blacklist.contains(collection.getURI())) {
        LOG.info("Preventing move of blacklisted collection '" + collection.getURI() + "'.");
        throw new TriggerException("The collection '" + collection.getURI().lastSegment() + "' is black-listed by the NoDeleteCollectionTrigger and may not be moved, consider a copy instead!");
    }
}
 

import org.exist.xmldb.XmldbURI; //导入依赖的package包/类
private Either<XmldbURI, InputStream> getPipelineArgument(final Sequence[] args) throws IOException, XPathException, SAXException {
    final Sequence pipe = args[0];
    if (Type.subTypeOf(pipe.getItemType(), Type.DOCUMENT) || Type.subTypeOf(pipe.getItemType(), Type.ELEMENT)) {
        try (final StringWriter writer = new StringWriter()) {
            final XQuerySerializer xqSerializer = new XQuerySerializer(context.getBroker(), new Properties(), writer);
            xqSerializer.serialize(pipe);
            return Either.Right(new ByteArrayInputStream(writer.toString().getBytes(UTF_8)));
        }
    } else if(Type.subTypeOf(pipe.getItemType(), Type.ANY_URI)) {
        return Either.Left(((AnyURIValue)pipe.itemAt(0).convertTo(Type.ANY_URI)).toXmldbURI());
    } else if(Type.subTypeOf(pipe.getItemType(), Type.STRING)) {
        return Either.Left(XmldbURI.create(pipe.itemAt(0).getStringValue()));
    } else {
        throw new XPathException(this, "$pipeline must be either document(), element() or xs:anyURI (or xs:anyURI as xs:string)");
    }
}
 

import org.exist.xmldb.XmldbURI; //导入依赖的package包/类
private DocumentSet configureAndStore(final String configuration, final String data, final String docName) throws EXistException, CollectionConfigurationException, LockException, SAXException, PermissionDeniedException, IOException {
    final MutableDocumentSet docs = new DefaultDocumentSet();
    final TransactionManager transact = pool.getTransactionManager();
    try (final DBBroker broker = pool.get(Optional.of(pool.getSecurityManager().getSystemSubject()));
         final Txn transaction = transact.beginTransaction()) {

        if (configuration != null) {
            final CollectionConfigurationManager mgr = pool.getConfigurationManager();
            mgr.addConfiguration(transaction, broker, root, configuration);
        }

        final IndexInfo info = root.validateXMLResource(transaction, broker, XmldbURI.create(docName), data);
        assertNotNull(info);
        root.store(transaction, broker, info, data);

        docs.add(info.getDocument());
        transact.commit(transaction);
    }
    return docs;
}
 

import org.exist.xmldb.XmldbURI; //导入依赖的package包/类
@Before
public void setup() throws EXistException, PermissionDeniedException, IOException, TriggerException {
    final TransactionManager transact = pool.getTransactionManager();
    try (final DBBroker broker = pool.get(Optional.of(pool.getSecurityManager().getSystemSubject()));
         final Txn transaction = transact.beginTransaction()) {

        root = broker.getOrCreateCollection(transaction, XmldbURI.ROOT_COLLECTION_URI.append("test"));
        assertNotNull(root);

        //root.setPermissions(0770);

        broker.saveCollection(transaction, root);

        transact.commit(transaction);

    }
}
 

import org.exist.xmldb.XmldbURI; //导入依赖的package包/类
@After
    public void cleanup() throws EXistException, PermissionDeniedException, IOException, TriggerException {
        final BrokerPool pool = BrokerPool.getInstance();
        final TransactionManager transact = pool.getTransactionManager();
        try (final DBBroker broker = pool.get(Optional.of(pool.getSecurityManager().getSystemSubject()));
             final Txn transaction = transact.beginTransaction()) {

            final Collection collConfig = broker.getOrCreateCollection(transaction, XmldbURI.CONFIG_COLLECTION_URI.append("db"));
            assertNotNull(collConfig);
            broker.removeCollection(transaction, collConfig);

//            if (root != null) {
//                assertNotNull(root);
//                broker.removeCollection(transaction, root);
//            }
            transact.commit(transaction);

        }
    }
 

import org.exist.xmldb.XmldbURI; //导入依赖的package包/类
public Sequence run(final BinaryDocument xq) throws Exception {
    try (final DBBroker broker = pool.get(Optional.of(pool.getSecurityManager().getSystemSubject()))) {
        assertNotNull(broker);

        final XQuery xquery = pool.getXQueryService();
        assertNotNull(xquery);

        final DBSource source = new DBSource(broker, xq, true);
        final XQueryContext context = new XQueryContext(pool);
        context.setModuleLoadPath(XmldbURI.EMBEDDED_SERVER_URI.append(xq.getCollection().getURI()).toString());
        context.setStaticallyKnownDocuments(new XmldbURI[]{
                xq.getCollection().getURI()
        });

        final CompiledXQuery compiled = xquery.compile(broker, context, source);
        return xquery.execute(broker, compiled, null);

    }
}
 

import org.exist.xmldb.XmldbURI; //导入依赖的package包/类
private DocumentSet configureAndStore(final String configuration, final String data, final String docName) throws EXistException, CollectionConfigurationException, LockException, SAXException, PermissionDeniedException, IOException {
    final TransactionManager transact = pool.getTransactionManager();
    final MutableDocumentSet docs = new DefaultDocumentSet();
    try (final DBBroker broker = pool.get(Optional.of(pool.getSecurityManager().getSystemSubject()));
         final Txn transaction = transact.beginTransaction()) {

        if (configuration != null) {
            final CollectionConfigurationManager mgr = pool.getConfigurationManager();
            mgr.addConfiguration(transaction, broker, root, configuration);
        }

        final IndexInfo info = root.validateXMLResource(transaction, broker, XmldbURI.create(docName), data);
        assertNotNull(info);
        root.store(transaction, broker, info, data);

        docs.add(info.getDocument());
        transact.commit(transaction);
    }
    return docs;
}
 

import org.exist.xmldb.XmldbURI; //导入依赖的package包/类
public void start() throws Exception {
    synchronized (started) {
        if (database == null) {
            database = new DatabaseImpl();
            database.setProperty("create-database", "true");

            if (configuration != null && configuration.length() > 0) {
                database.setProperty("configuration", configuration);
            }

            current = database.getCollection(XmldbURI.EMBEDDED_SERVER_URI, null, null);
            DatabaseManager.registerDatabase(database);
            started  = true;
        }
    }
}
 

import org.exist.xmldb.XmldbURI; //导入依赖的package包/类
private String getCollectionPath(final String aCollectionPath) {
    final StringBuilder builder = new StringBuilder();

    if (!aCollectionPath.startsWith(XmldbURI.ROOT_COLLECTION)) {
        builder.append(XmldbURI.ROOT_COLLECTION);

        if (!aCollectionPath.startsWith("/")) {
            builder.append('/');
        }
    }

    return builder.append(aCollectionPath).toString();
}
 

import org.exist.xmldb.XmldbURI; //导入依赖的package包/类
/**
 * Gets the correct CollectionManagementService for internal use
 * @return
 * @throws Exception
 */
private CollectionManagementService getCollectionManagementService() throws Exception 
{
	
	Collection root = DatabaseManager.getCollection(_uri+XmldbURI.ROOT_COLLECTION+"/RootCollection", _user, _pass);
       return (CollectionManagementService)root.getService("CollectionManagementService", "1.0");
}
 

import org.exist.xmldb.XmldbURI; //导入依赖的package包/类
/**
 * Stores a document into the weather collection
 *
 * @param broker The broker for accessing the database
 * @param targetCollection The collection to store the document into
 * @param document The document to store
 * @param lockCollection Should the collection be locked whilst storing the document?
 */
public static void storeDocument(final DBBroker broker, final String targetCollection, final Node document, final boolean lockCollection) throws StoreException {

    Collection collection = null;
    final TransactionManager transact = broker.getBrokerPool().getTransactionManager();
    final Txn txn = transact.beginTransaction();
    final IndexInfo indexInfo;
    try {

        //prepare to store
        try {

            //open the weather collection
            collection = broker.openCollection(XmldbURI.create(targetCollection), lockCollection ? Lock.WRITE_LOCK : Lock.NO_LOCK);
            if(collection == null) {
                transact.abort(txn);
                throw new JobException(JobException.JobExceptionAction.JOB_ABORT_THIS, "Collection: " + targetCollection + " not found!");
            }

            //generate a unique name for the document
            final String documentName = UUID.randomUUID().toString() + ".xml";

            //validate the document
            indexInfo = collection.validateXMLResource(txn, broker, XmldbURI.create(documentName), document);
        } finally {
            //release the lock on the weather collection
            if(collection != null && lockCollection) {
                collection.release(Lock.WRITE_LOCK);
            }
        }

        //store
        collection.store(txn, broker, indexInfo, document, false);
        transact.commit(txn);

    } catch(final Exception e) {
        transact.abort(txn);
        throw new StoreException(e);
    }
}
 

import org.exist.xmldb.XmldbURI; //导入依赖的package包/类
@Override
public void execute(final DBBroker broker) throws EXistException {

    try {

        //setup an output document
        final MemTreeBuilder builder = new MemTreeBuilder();
        builder.startDocument();

        final DatatypeFactory datatypeFactory = DatatypeFactory.newInstance();
        final XMLGregorianCalendar xmlCal = datatypeFactory.newXMLGregorianCalendar(new GregorianCalendar());

        final AttributesImpl attribs = new AttributesImpl();
        attribs.addAttribute(null, "timestamp", "timestamp", "string", xmlCal.toXMLFormat());
        builder.startElement(new QName("stats"), attribs);

        //collect stats
        collectStats(broker, XmldbURI.DB, builder);

        //finalise output document
        builder.endElement();
        builder.endDocument();

        //store stats document
        storeDocument(broker, statsCollection, builder.getDocument(), false);

    } catch(final DatatypeConfigurationException dce) {
        final String msg = "Unable to configure XML DatatypeFactory: " + dce.getMessage();
        LOG.error(msg, dce);
        throw new EXistException(msg, dce);
    } catch(final PermissionDeniedException pde) {
        LOG.error(pde);
        throw new EXistException(pde);
    } catch(final StoreException se) {
        LOG.error(se);
        throw new EXistException(se);
    }
}
 

import org.exist.xmldb.XmldbURI; //导入依赖的package包/类
/**
 * Collects statistics about a Collection and its documents and sub-collections recursively
 * writes the results to the builder
 *
 * @param broker The database broker to use to access the database
 * @param collUri The absolute database URI of the collection to generate statistics for
 * @param builder The builder to write the statistics output to
 */
private void collectStats(final DBBroker broker, final XmldbURI collUri, final MemTreeBuilder builder) throws PermissionDeniedException {

    final Collection collection = broker.getCollection(collUri);

    final AttributesImpl attribs = new AttributesImpl();
    attribs.addAttribute(null, "name", "name", "string", collection.getURI().lastSegment().toString());
    attribs.addAttribute(null, "uri", "uri", "string", collection.getURI().toString());
    attribs.addAttribute(null, "sub-collections", "sub-collections", "string", Integer.toString(collection.getChildCollectionCount(broker)));
    attribs.addAttribute(null, "documents", "documents", "string", Integer.toString(collection.getDocumentCountNoLock(broker)));

    builder.startElement(new QName("collection"), attribs);

    final Iterator<DocumentImpl> itDocs = collection.iteratorNoLock(broker);
    while(itDocs.hasNext()) {
        final DocumentImpl doc = itDocs.next();

        final AttributesImpl docAttribs = new AttributesImpl();
        docAttribs.addAttribute(null, "name", "name", "string", doc.getURI().lastSegment().toString());
        docAttribs.addAttribute(null, "uri", "uri", "string", doc.getURI().toString());
        docAttribs.addAttribute(null, "nodes", "nodes", "string", Long.toString(countNodes(doc)));

        builder.startElement(new QName("document"), docAttribs);
        builder.endElement();
    }

    final Iterator<XmldbURI> itColls = collection.collectionIteratorNoLock(broker);
    while(itColls.hasNext()) {
        final XmldbURI childCollUri = collUri.append(itColls.next());
        collectStats(broker, childCollUri, builder);
    }

    builder.endElement();
}
 

import org.exist.xmldb.XmldbURI; //导入依赖的package包/类
@Override
public void execute(final DBBroker sysBroker, final Map<String, List<? extends Object>> params) {

    //get the target parameter for where to store the modules summary
    final List<? extends Object> maybeTarget = params.get("target");
    if(maybeTarget == null || maybeTarget.size() != 1) {
        LOG.error("Missing 'target' parameter which provides the database uri for storing the modules summary!");
        return;

    } else {
        final String target = (String)maybeTarget.get(0);

        //start a document
        final MemTreeBuilder builder = new MemTreeBuilder();
        builder.startDocument();
        builder.startElement(new QName("modules-summary"), null);

        //get java modules info into document
        final Configuration existConf = sysBroker.getConfiguration();
        buildModulesSummary(existConf, builder);

        //finish document
        builder.endElement();
        builder.endDocument();

        //store document
        storeDocument(sysBroker, XmldbURI.create(target), builder.getDocument());
    }
}
 

import org.exist.xmldb.XmldbURI; //导入依赖的package包/类
/**
 * Stores a document into the database
 *
 * Does not need to use locking, as we have exclusive access
 * inside a Startup Task!
 *
 * @param broker The broker for accessing the database
 * @param target The uri of where the document is to be stored in the database
 * @param document The document to store
 */
public void storeDocument(final DBBroker broker, final XmldbURI target, final DocumentImpl document) {

    final TransactionManager transact = broker.getBrokerPool().getTransactionManager();
    final Txn txn = transact.beginTransaction();
    final IndexInfo indexInfo;
    try {
        //open the collection
        final XmldbURI targetCollection = target.removeLastSegment();
        final Collection collection = broker.openCollection(targetCollection, Lock.NO_LOCK);

        if(collection == null) {
            //no such collection
            transact.abort(txn);
            LOG.error("Collection: " + targetCollection.toString() + " not found!");
            return;

        } else {

            //get the name for the document
            final XmldbURI documentName = target.lastSegment();

            //validate the document
            indexInfo = collection.validateXMLResource(txn, broker, documentName, document);

            //store
            collection.store(txn, broker, indexInfo, document, false);
            transact.commit(txn);
        }
    } catch(final Exception e) {
        transact.abort(txn);
        LOG.error(e);
    }
}
 

import org.exist.xmldb.XmldbURI; //导入依赖的package包/类
@Override
public void afterDeleteCollection(final DBBroker broker, final Txn txn, final XmldbURI uri) throws TriggerException {
    /**
     * Do nothing! The beforeDeleteCollection
     * protects what we need
     */
}