Exemple #1
0
  public void execute(Connection connection) throws XMLDBException, EXistException {
    Collection collection = connection.getCollection("/db");
    XQueryService service = (XQueryService) collection.getService("XQueryService", "1.0");
    service.declareVariable("filename", "");
    service.declareVariable("count", "0");
    String query = IMPORT + xqueryContent;
    System.out.println("query: " + query);
    CompiledExpression compiled = service.compile(query);
    try {
      for (int i = 0; i < count; i++) {
        File nextFile = new File(directory, prefix + i + ".xml");

        service.declareVariable("filename", nextFile.getName());
        service.declareVariable("count", new IntegerValue(i));
        ResourceSet results = service.execute(compiled);

        Writer out = new OutputStreamWriter(new FileOutputStream(nextFile), "UTF-8");
        for (ResourceIterator iter = results.getIterator(); iter.hasMoreResources(); ) {
          Resource r = iter.nextResource();
          out.write(r.getContent().toString());
        }
        out.close();
      }
    } catch (IOException e) {
      throw new EXistException("exception while storing generated data: " + e.getMessage(), e);
    }
  }
  /**
   * This method retrieves an xml document from the database based on its resource identifier. The
   * document is returned as an org.w3c.dom.Document.
   *
   * @param collection The name of the collection to look for the document.
   * @param resourceId The resource identifier of the document to be retrieved.
   * @param username The identifier of the user calling the method used for authentication.
   * @param password The password of the user calling the method used for authentication.
   * @return The xml document retrieved as an org.w3c.dom.Document.
   */
  public Document retrieveDocument(
      String collection, String resourceId, String username, String password) {
    Document doc = null;

    try {
      // initialize database driver
      Class cl = Class.forName(_driver);
      Database database = (Database) cl.newInstance();
      DatabaseManager.registerDatabase(database);

      // get the collection
      Collection col = DatabaseManager.getCollection(_URI + collection, username, password);
      col.setProperty(OutputKeys.INDENT, "no");
      XMLResource res = (XMLResource) col.getResource(resourceId);
      if (res == null) System.out.println("document not found!");
      else {
        doc = (Document) (res.getContentAsDOM()).getOwnerDocument();
      }

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

    return doc;
  }
  /**
   * This method stores an xml document given as an org.w3c.dom.Document to the database giving it
   * an indentifier. If the identifier provided is null, then the database generates a unique
   * identifier on its own.
   *
   * @param doc The dom represntation of the document to be stored as an org.w3c.dom.Document.
   * @param resourceId The resourceId to give to the document as a unique identifier within the
   *     database. If null a unique identifier is automatically generated.
   * @param collection The name of the collection to store the document under. If it does not exist,
   *     it is created.
   * @param username The identifier of the user calling the method used for authentication.
   * @param password The password of the user calling the method used for authentication.
   */
  public void storeDomDocument(
      Document doc, String resourceId, String collection, String username, String password) {

    try {
      // initialize driver
      Class cl = Class.forName(_driver);
      Database database = (Database) cl.newInstance();
      DatabaseManager.registerDatabase(database);

      // try to get collection
      Collection col = DatabaseManager.getCollection(_URI + collection, username, password);
      if (col == null) {
        // collection does not exist: get root collection and create
        // for simplicity, we assume that the new collection is a
        // direct child of the root collection, e.g. /db/test.
        // the example will fail otherwise.
        Collection root = DatabaseManager.getCollection(_URI + "/db");
        CollectionManagementService mgtService =
            (CollectionManagementService) root.getService("CollectionManagementService", "1.0");
        col = mgtService.createCollection(collection.substring("/db".length()));
      }
      // create new XMLResource; an id will be assigned to the new resource
      XMLResource document = (XMLResource) col.createResource(resourceId, "XMLResource");
      document.setContentAsDOM(doc.getDocumentElement());
      col.storeResource(document);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
Exemple #4
0
  /* (non-Javadoc)
   * @see org.exist.xquery.BasicFunction#eval(org.exist.xquery.value.Sequence[], org.exist.xquery.value.Sequence)
   */
  public Sequence eval(Sequence[] args, Sequence contextSequence) throws XPathException {
    final String userName = args[0].getStringValue();

    Collection collection = null;
    try {
      collection =
          new LocalCollection(
              context.getSubject(),
              context.getBroker().getBrokerPool(),
              XmldbURI.ROOT_COLLECTION_URI,
              context.getAccessContext());
      final UserManagementService ums =
          (UserManagementService) collection.getService("UserManagementService", "1.0");
      final Account user = ums.getAccount(userName);

      if (user == null)
      // todo - why not just return false()? /ljo
      {
        return Sequence.EMPTY_SEQUENCE;
      }
      return user.hasDbaRole() ? BooleanValue.TRUE : BooleanValue.FALSE;
    } catch (final XMLDBException xe) {
      logger.error("Failed to access user " + userName);
      throw new XPathException(this, "Failed to access user " + userName, xe);
    } finally {
      if (null != collection)
        try {
          collection.close();
        } catch (final XMLDBException e) {
          /* ignore */
        }
    }
  }
Exemple #5
0
  /* (non-Javadoc)
   * @see org.apache.tools.ant.Task#execute()
   */
  public void execute() throws BuildException {
    if (uri == null) throw new BuildException("You have to specify an XMLDB collection URI");
    if (resource == null && collection == null)
      throw new BuildException(
          "Missing parameter: either resource or collection should be specified");

    registerDatabase();
    try {
      log("Get base collection: " + uri, Project.MSG_DEBUG);
      Collection base = DatabaseManager.getCollection(uri, user, password);

      if (base == null) {
        throw new BuildException("Collection " + uri + " could not be found.");
      }

      log(
          "Create collection management service for collection " + base.getName(),
          Project.MSG_DEBUG);
      CollectionManagementServiceImpl service =
          (CollectionManagementServiceImpl) base.getService("CollectionManagementService", "1.0");
      if (resource != null) {
        log("Copying resource: " + resource, Project.MSG_INFO);
        Resource res = base.getResource(resource);
        if (res == null) throw new BuildException("Resource " + resource + " not found.");
        service.copyResource(resource, destination, name);
      } else {
        log("Copying collection: " + collection, Project.MSG_INFO);
        service.copy(collection, destination, name);
      }
    } catch (XMLDBException e) {
      throw new BuildException("XMLDB exception during remove: " + e.getMessage(), e);
    }
  }
Exemple #6
0
  public Collection getOrCreateCollection(String path) throws XMLDBException {
    path = StringUtils.removeStart(path, "/");
    path = StringUtils.removeEnd(path, "/");
    path = path.replaceAll("[/]+", "/");

    String pathWithURI = uri + path;

    Collection col = DatabaseManager.getCollection(pathWithURI, userName, password);

    if (col != null) {
      return col;
    } else {
      synchronized (syncLock) {
        col = DatabaseManager.getCollection(pathWithURI, userName, password);
        if (col != null) {
          return col;
        }
        String[] paths = path.split("/");

        String[] parentPath = (String[]) ArrayUtils.remove(paths, paths.length - 1);

        this.getOrCreateCollection(StringUtils.join(parentPath, '/'));

        CollectionManagementService mgt = this.getCollectionManagementService();

        col = mgt.createCollection(StringUtils.join(paths, '/'));

        // If we are creating a new root collection, we need to set up the indexing configuration
        // for this collection,
        // which is done by placing a collection.xconf file into the config path structure.
        if (paths.length == 1 && getCollectionRoot().endsWith(paths[0])) {
          log.info("Configuring Indexes for Collection " + paths[0]);
          // Add the index configuration file for our root config
          try {
            String confFilePath = "/collection.xconf";
            String confFileXml =
                IOUtils.toString(this.getClass().getResourceAsStream(confFilePath), "UTF-8");
            Collection configCol = getOrCreateCollection("/system/config/db/" + paths[0]);
            org.xmldb.api.base.Resource r =
                configCol.createResource("collection.xconf", "XMLResource");
            r.setContent(confFileXml);
            configCol.storeResource(r);
            log.info(
                "Wrote index configuration " + r.getParentCollection().getName() + "/" + r.getId());
          } catch (Exception e) {
            log.error(
                "Failure configuring indexes for collection "
                    + paths[0]
                    + " - indexes will not be available!",
                e);
          }
        }
        return col;
      }
    }
  }
Exemple #7
0
 private XUpdateQueryService createXQueryUpdateService(String collectionPath) {
   XUpdateQueryService service;
   Collection collection;
   try {
     collection = this.getOrCreateCollection(collectionPath);
     service = (XUpdateQueryService) collection.getService("XUpdateQueryService", "1.0");
     service.setCollection(collection);
   } catch (XMLDBException e) {
     throw new Cts2RuntimeException(e);
   }
   return service;
 }
  public final void testDropVirtualCollectionSuccess() throws Exception {
    Collection testColl = this.db.getCollection("/db/vc-colls", "sa", "");

    VirtualCollectionManagementService vcms =
        (VirtualCollectionManagementService)
            testColl.getService("VirtualCollectionManagementService", "1.0");

    int size = testColl.getChildCollectionCount();

    vcms.removeVirtualCollection("test-vc");

    assertEquals(
        "Why is the virtual collection not removed?", size - 1, testColl.getChildCollectionCount());
  }
  public final void testDropResourceSubset() throws Exception {

    Collection article = this.dbColl.getChildCollection("vcl-data/article");

    int size = article.getResourceCount();

    Resource r = article.getResource("article.from.manuel.xml");

    // Just do it if the resource exists.
    if (r != null) {
      article.removeResource(r);
      assertEquals(size - 1, article.getResourceCount());
    }
  }
Exemple #10
0
 private String execQuery(String query) throws XMLDBException {
   XQueryService service = (XQueryService) testCollection.getService("XQueryService", "1.0");
   service.setProperty("indent", "no");
   ResourceSet result = service.query(query);
   assertEquals(result.getSize(), 1);
   return result.getResource(0).getContent().toString();
 }
  @Override
  public void setPermissions(final Collection child, final Permission perm) throws XMLDBException {

    final XmldbURI childUri = XmldbURI.create(child.getName());

    try {
      executeWithBroker(
          new BrokerOperation<Void>() {
            @Override
            public Void withBroker(final DBBroker broker)
                throws XMLDBException, LockException, PermissionDeniedException, IOException,
                    EXistException, TriggerException, SyntaxException {
              return modifyCollection(
                  broker,
                  childUri,
                  new DatabaseItemModifier<org.exist.collections.Collection, Void>() {
                    @Override
                    public Void modify(org.exist.collections.Collection collection)
                        throws PermissionDeniedException, LockException {
                      collection.setPermissions(perm);
                      return null;
                    }
                  });
            }
          });
    } catch (final Exception e) {
      throw new XMLDBException(
          ErrorCodes.VENDOR_ERROR,
          "Failed to modify permission on Collection '" + childUri.toString() + "'",
          e);
    }
  }
  /*
  public final void testDropResourceRoot() throws Exception {

      Collection author = this.dbColl.getChildCollection("vcl-data/author");

      author.removeResource(author.getResource("author.3.hjb.xml"));
  }

  public final void testDropResourceSub() throws Exception {

      Collection article = this.dbColl.getChildCollection("vcl-data/article");

      article.removeResource(article.getResource("article.patent.1.xml"));
  }
  */
  public final void testStoreResourceRoot() throws Exception {

    Collection author = this.dbColl.getChildCollection("vcl-data/author");
    Collection vcoll = this.dbColl.getChildCollection("vcl-data/myvc");

    int size = vcoll.getResourceCount();

    SixdmlResource res =
        (SixdmlResource) author.createResource("author.4.manuel.xml", SixdmlResource.RESOURCE_TYPE);
    res.setContentAsDOM(
        DocumentBuilderFactoryImpl.newInstance()
            .newDocumentBuilder()
            .parse("data/vcl-data/author.4.manuel.xml"));

    author.storeResource(res);
  }
  /**
   * Main method of the example class.
   *
   * @param args (ignored) command-line arguments
   * @throws Exception exception
   */
  public static void main(final String[] args) throws Exception {

    System.out.println("=== XMLDBInsert ===");

    // Collection instance
    Collection col = null;

    try {
      // Register the database
      Class<?> c = Class.forName(DRIVER);
      Database db = (Database) c.newInstance();
      DatabaseManager.registerDatabase(db);

      System.out.println("\n* Get collection.");

      // Receive the collection
      col = DatabaseManager.getCollection(DBNAME);

      // ID for the new document
      String id = "world";

      // Content of the new document
      String doc = "<xml>Hello World!</xml>";

      System.out.println("\n* Create new resource.");

      // Create a new XML resource with the specified ID
      XMLResource res = (XMLResource) col.createResource(id, XMLResource.RESOURCE_TYPE);

      // Set the content of the XML resource as the document
      res.setContent(doc);

      System.out.println("\n* Store new resource.");

      // Store the resource into the database
      col.storeResource(res);

    } catch (final XMLDBException ex) {
      // Handle exceptions
      System.err.println("XML:DB Exception occurred " + ex.errorCode);
      ex.printStackTrace();
    } finally {
      // Close the collection
      if (col != null) col.close();
    }
  }
Exemple #14
0
  /*
   * @see TestCase#tearDown()
   */
  protected void tearDown() {
    try {
      Collection root = DatabaseManager.getCollection(XmldbURI.LOCAL_DB, "admin", "");
      CollectionManagementService service =
          (CollectionManagementService) root.getService("CollectionManagementService", "1.0");
      service.removeCollection(TEST_COLLECTION_NAME);

      DatabaseManager.deregisterDatabase(database);
      DatabaseInstanceManager dim =
          (DatabaseInstanceManager) testCollection.getService("DatabaseInstanceManager", "1.0");
      dim.shutdown();
      database = null;
      testCollection = null;
      System.out.println("tearDown PASSED");
    } catch (XMLDBException e) {
      fail(e.getMessage());
    }
  }
  public final void testVCLSchemaVisitor() throws Exception {

    if (true) return;

    Collection vcl = this.dbColl.getChildCollection("vcl-data");

    VirtualCollectionManagementService vcms =
        (VirtualCollectionManagementService)
            vcl.getService("VirtualCollectionManagementService", "1.0");

    File f = new File("data/vcl-schema/author-articles.vcs");
    URL url = new URL("file://" + f.getAbsolutePath());

    long start = System.currentTimeMillis();
    vcms.createVirtualCollection("myvc", url);
    long end = System.currentTimeMillis();

    System.out.println("Time: " + (end - start) + " msec");
  }
  /**
   * Main method of the example class.
   *
   * @param args (ignored) command-line arguments
   * @throws Exception exception
   */
  public static void main(final String[] args) throws Exception {

    System.out.println("=== XMLDBQuery ===\n");

    System.out.println("* Run query via XML:DB:");

    // Collection instance
    Collection coll = null;

    try {
      // Register the database
      Class<?> c = Class.forName(DRIVER);
      Database db = (Database) c.newInstance();
      DatabaseManager.registerDatabase(db);

      // Receive the database
      coll = DatabaseManager.getCollection(DBNAME);

      // Receive the XPath query service
      XPathQueryService service = (XPathQueryService) coll.getService("XPathQueryService", "1.0");

      // Execute the query and receives all results
      ResourceSet set = service.query(QUERY);

      // Create a result iterator
      ResourceIterator iter = set.getIterator();

      // Loop through all result items
      while (iter.hasMoreResources()) {
        // Receive the next results
        Resource res = iter.nextResource();

        // Write the result to the console
        System.out.println(res.getContent());
      }
    } catch (final XMLDBException ex) {
      // Handle exceptions
      System.err.println("XML:DB Exception occured " + ex.errorCode);
    } finally {
      // Close the collection
      if (coll != null) coll.close();
    }
  }
Exemple #17
0
 /**
  * Store in the "classical" eXist way: the XMLResource stores an XML string before storeResource()
  * stores it in the database.
  */
 public void testQueryStoreContentAsSAX() {
   try {
     ContentHandler databaseInserter = doc.setContentAsSAX();
     (new TabularXMLReader()).writeDocument(databaseInserter);
     root.storeResource(doc);
     querySingleLine("", "testQueryStoreContentAsSAX");
   } catch (Exception e) {
     fail(e.getMessage());
   }
 }
Exemple #18
0
 private static void shutdown(Collection collection) {
   try {
     //		shutdown the database gracefully
     DatabaseInstanceManager manager =
         (DatabaseInstanceManager) collection.getService("DatabaseInstanceManager", "1.0");
     manager.shutdown();
   } catch (XMLDBException e) {
     fail(e.getMessage());
   }
 }
  public final void testDropVirtualResourceFail() throws Exception {

    Collection vcoll = this.dbColl.getChildCollection("vcl-data/myvc");

    String[] names = vcoll.listResources();
    for (int i = 0; i < names.length; i++) {
      Resource res = vcoll.getResource(names[i]);

      assertTrue(
          "Expected instance of VirtualResource and not " + res.getClass(),
          res instanceof VirtualResource);

      try {
        vcoll.removeResource(res);
        assertTrue("Cannot delete a VirtualResource.", false);
      } catch (XMLDBException e) {
        assertTrue(
            "Expected errorCode.INVALID_COLLECTION", e.errorCode == ErrorCodes.INVALID_COLLECTION);
      }
    }
  }
Exemple #20
0
  @Override
  public void afterPropertiesSet() throws Exception {

    if (StringUtils.isNotBlank(this.existHome)) {
      System.setProperty(ExistServiceConstants.EXIST_HOME_PROP, this.existHome);
      System.setProperty("exist.initdb", "true");
    }

    final String driver = "org.exist.xmldb.DatabaseImpl";

    // initialize database driver
    Class<?> cl = Class.forName(driver);
    Database database = (Database) cl.newInstance();
    database.setProperty("create-database", "true");
    DatabaseManager.registerDatabase(database);

    Collection root = this.getOrCreateCollection("");

    xQueryService = (XQueryService) root.getService("XPathQueryService", "1.0");
    collectionManagementService =
        (CollectionManagementService) root.getService("CollectionManagementService", "1.0");
    databaseInstanceManager =
        (DatabaseInstanceManager) root.getService("DatabaseInstanceManager", "1.0");
    indexQueryService = (IndexQueryService) root.getService("IndexQueryService", "1.0");
    xUpdateQueryService = (XUpdateQueryService) root.getService("XUpdateQueryService", "1.0");
    // This doesn't exist in existDB 2.1.  ValidationModule now maybe?  Not sure.  possibly an
    // extension not loaded...
    //		validationService = (ValidationService) root.getService("ValidationService", "1.0");

    this.namespaceMappingProperties = this.cts2Marshaller.getNamespaceMappingProperties();

    this.xQueryService = this.createXQueryService("");
  }
Exemple #21
0
 protected void setUp() {
   try {
     // initialize driver
     Class<?> cl = Class.forName("org.exist.xmldb.DatabaseImpl");
     Database database = (Database) cl.newInstance();
     database.setProperty("create-database", "true");
     DatabaseManager.registerDatabase(database);
     root = DatabaseManager.getCollection(XmldbURI.LOCAL_DB, "admin", "");
     CollectionManagementService service =
         (CollectionManagementService) root.getService("CollectionManagementService", "1.0");
     root = service.createCollection("test");
     FILE_STORED = "big.xml";
     doc = (XMLResource) root.createResource(FILE_STORED, "XMLResource");
   } catch (ClassNotFoundException e) {
   } catch (InstantiationException e) {
   } catch (IllegalAccessException e) {
   } catch (XMLDBException e) {
     e.printStackTrace();
   } catch (Exception e) {
     e.printStackTrace();
   }
 }
  /**
   * This method performs an XPath query to the database and returns the results as a Vector of
   * Strings.
   *
   * @param collection The name of the collection to look for the document.
   * @param query A string containing an XPath expression which shall act as a query against the
   *     database.
   * @param username The identifier of the user calling the method used for authentication.
   * @param password The password of the user calling the method used for authentication.
   * @return A Vector containing the answers to the query as Strings.
   */
  public Vector query(String collection, String query, String username, String password) {
    Vector response = new Vector();
    try {
      Class cl = Class.forName(_driver);
      Database database = (Database) cl.newInstance();
      DatabaseManager.registerDatabase(database);

      Collection col = DatabaseManager.getCollection(_URI + collection, username, password);
      XPathQueryService service = (XPathQueryService) col.getService("XPathQueryService", "1.0");
      service.setProperty("indent", "yes");

      ResourceSet result = service.query(query);
      ResourceIterator i = result.getIterator();
      while (i.hasMoreResources()) {
        Resource r = i.nextResource();
        response.add((String) r.getContent());
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    return response;
  }
Exemple #23
0
  private void insertTags() throws Exception {
    XUpdateQueryService service =
        (XUpdateQueryService) testCol.getService("XUpdateQueryService", "1.0");
    XPathQueryService xquery = (XPathQueryService) testCol.getService("XPathQueryService", "1.0");

    String[] tagsWritten = new String[RUNS];
    for (int i = 0; i < RUNS; i++) {
      String tag = tags[i];
      String parent;
      if (i > 0 && rand.nextInt(100) < 70) {
        parent = "//" + tagsWritten[rand.nextInt(i) / 2];
      } else parent = "/root";
      String xupdate =
          "<xupdate:modifications version=\"1.0\" xmlns:xupdate=\"http://www.xmldb.org/xupdate\">"
              + "<xupdate:append select=\""
              + parent
              + "\">"
              + "<xupdate:element name=\""
              + tag
              + "\"/>"
              + "</xupdate:append>"
              + "</xupdate:modifications>";

      long mods = service.updateResource("test.xml", xupdate);
      System.out.println("Inserted " + tag + ": " + mods + " ; parent = " + parent);
      assertEquals(mods, 1);

      tagsWritten[i] = tag;
      String query = "//" + tagsWritten[rand.nextInt(i + 1)];
      ResourceSet result = xquery.query(query);
      assertEquals(result.getSize(), 1);

      System.out.println(result.getResource(0).getContent());
    }

    XMLResource res = (XMLResource) testCol.getResource("test.xml");
    assertNotNull(res);
    System.out.println(res.getContent());
  }
Exemple #24
0
  private XQueryService createXQueryService(String collectionPath) {
    XQueryService service;
    Collection collection;
    try {
      collection = this.getOrCreateCollection(collectionPath);

      service = (XQueryService) collection.getService("XPathQueryService", "1.0");

      service.setCollection(collection);
    } catch (XMLDBException e) {
      throw new Cts2RuntimeException(e);
    }

    try {
      for (Entry<Object, Object> entry : namespaceMappingProperties.entrySet()) {
        service.setNamespace((String) entry.getKey(), (String) entry.getValue());
      }
    } catch (XMLDBException e) {
      throw new Cts2RuntimeException(e);
    }

    return service;
  }
  public static void main(String args[]) throws Exception {
    String driver = "org.exist.xmldb.DatabaseImpl";
    Class cl = Class.forName(driver);
    Database database = (Database) cl.newInstance();
    DatabaseManager.registerDatabase(database);

    Collection col = DatabaseManager.getCollection("xmldb:exist:///db", "admin", "");
    XPathQueryService service = (XPathQueryService) col.getService("XPathQueryService", "1.0");
    service.setProperty("indent", "yes");

    ResourceSet result =
        service.query(
            "for $s in //intervention/(speaker|writer)/affiliation[@EPparty ='PSE'] return data($s/../../(speech|writing)/@ref)");
    ResourceIterator i = result.getIterator();
    while (i.hasMoreResources()) {
      Resource r = i.nextResource();
      System.out.println((String) r.getContent());
    }
    // shut down the database
    DatabaseInstanceManager manager =
        (DatabaseInstanceManager) col.getService("DatabaseInstanceManager", "1.0");
    manager.shutdown();
  }
  @Override
  public void setPermissions(
      Collection child,
      final String owner,
      final String group,
      final int mode,
      final List<ACEAider> aces)
      throws XMLDBException {

    final XmldbURI childUri = XmldbURI.create(child.getName());

    try {
      executeWithBroker(
          new BrokerOperation<Void>() {
            @Override
            public Void withBroker(final DBBroker broker)
                throws XMLDBException, LockException, PermissionDeniedException, IOException,
                    EXistException, TriggerException, SyntaxException {
              return modifyCollection(
                  broker,
                  childUri,
                  new DatabaseItemModifier<org.exist.collections.Collection, Void>() {
                    @Override
                    public Void modify(org.exist.collections.Collection collection)
                        throws PermissionDeniedException, LockException {
                      final Permission permission = collection.getPermissions();
                      permission.setOwner(owner);
                      permission.setGroup(group);
                      permission.setMode(mode);
                      if (permission instanceof ACLPermission) {
                        final ACLPermission aclPermission = (ACLPermission) permission;
                        aclPermission.clear();
                        for (final ACEAider ace : aces) {
                          aclPermission.addACE(
                              ace.getAccessType(), ace.getTarget(), ace.getWho(), ace.getMode());
                        }
                      }
                      return null;
                    }
                  });
            }
          });
    } catch (final Exception e) {
      throw new XMLDBException(
          ErrorCodes.VENDOR_ERROR,
          "Failed to modify permission on Collection '" + childUri.toString() + "'",
          e);
    }
  }
  public final void testCreateVirtualCollectionSuccess() throws Exception {
    Collection testColl = this.db.getCollection("/db/vc-colls", "sa", "");

    VirtualCollectionManagementService vcms =
        (VirtualCollectionManagementService)
            testColl.getService("VirtualCollectionManagementService", "1.0");

    int size = testColl.getChildCollectionCount();

    VirtualCollection vc =
        vcms.createVirtualCollection(
            "test-vc", new File("data/vcl-schema/author-articles.no.dtd.vcs").toURL());

    assertNotNull("Expected that an instance of VirtualCollection is returned and not null", vc);
    assertTrue(
        "Expected the returns instance is an instance of VirtualCollection and not "
            + vc.getClass(),
        vc instanceof VirtualCollection);

    assertEquals(
        "Why is the virtual collection not inserted but returned?",
        size + 1,
        testColl.getChildCollectionCount());
  }
Exemple #28
0
 /**
  * @param xquery
  * @param mess
  * @return TODO
  */
 private ResourceSet querySingleLine(String xquery, String mess) throws XMLDBException {
   // query a single line:
   XPathQueryService service = (XPathQueryService) root.getService("XPathQueryService", "1.0");
   ResourceSet result = null;
   if (xquery != "") {
     // xquery = "/*/*[2]";
     System.out.println("Querying \"" + xquery + "\" ...");
     long t0 = System.currentTimeMillis();
     result = service.queryResource("big.xml", xquery);
     // assertEquals(1, result.getSize());
     long t1 = System.currentTimeMillis();
     System.out.println(
         "Time for query \"" + xquery + "\" on " + mess + ": " + (t1 - t0) + " ms.");
   }
   return result;
 }
  public final void testDropResourceRoot() throws Exception {

    Collection author = this.dbColl.getChildCollection("vcl-data/author");
    Collection vcoll = this.dbColl.getChildCollection("vcl-data/myvc");

    int size = vcoll.getResourceCount();

    Resource res = author.getResource("author.4.manuel.xml");

    author.removeResource(res);

    assertEquals(size - 1, vcoll.getResourceCount());
  }
Exemple #30
0
  private void fetchDb() throws Exception {
    XPathQueryService xquery = (XPathQueryService) testCol.getService("XPathQueryService", "1.0");
    ResourceSet result =
        xquery.query(
            "for $n in collection('"
                + XmldbURI.ROOT_COLLECTION
                + "/test')//* return local-name($n)");

    for (int i = 0; i < result.getSize(); i++) {
      Resource r = result.getResource(i);
      String tag = r.getContent().toString();
      System.out.println("Retrieving " + tag);

      ResourceSet result2 = xquery.query("//" + tag);
      assertEquals(result2.getSize(), 1);

      System.out.println(result2.getResource(0).getContent());
    }
  }