public void testPermaLinksForResources() throws Exception {

    Resource r1 = registry.newResource();
    r1.setContent("r1c1");
    registry.put("/test/v13/r1", r1);
    registry.put("/test/v13/r1", r1);

    String[] r1Versions = registry.getVersions("/test/v13/r1");

    Resource r1e1 = registry.get(r1Versions[0]);
    assertEquals("Permalink incorrect", r1e1.getPermanentPath(), r1Versions[0]);

    r1e1.setContent("r1c2");
    registry.put("/test/v13/r1", r1e1);

    r1Versions = registry.getVersions("/test/v13/r1");

    Resource r1e2 = registry.get(r1Versions[0]);
    assertEquals("Permalink incorrect", r1e2.getPermanentPath(), r1Versions[0]);

    registry.restoreVersion(r1Versions[1]);

    Resource r1e3 = registry.get(r1Versions[1]);
    assertEquals("Permalink incorrect", r1e3.getPermanentPath(), r1Versions[1]);
  }
  public void testResourceContentVersioning() throws Exception {

    Resource r1 = registry.newResource();
    r1.setContent("content 1".getBytes());
    registry.put("/v2/r1", r1);

    Resource r12 = registry.get("/v2/r1");
    r12.setContent("content 2".getBytes());
    registry.put("/v2/r1", r12);
    registry.put("/v2/r1", r12);

    String[] r1Versions = registry.getVersions("/v2/r1");

    Resource r1vv1 = registry.get(r1Versions[1]);

    assertEquals(
        "r1's first version's content should be 'content 1'",
        new String((byte[]) r1vv1.getContent()),
        "content 1");

    Resource r1vv2 = registry.get(r1Versions[0]);

    assertEquals(
        "r1's second version's content should be 'content 2'",
        new String((byte[]) r1vv2.getContent()),
        "content 2");
  }
Beispiel #3
0
  private void editingMultivaluedProperties() {
    String path = "/props/t3/r1";
    Resource r1 = registry.newResource();
    try {
      r1.setContent("r1 content");

      r1.addProperty("p1", "v1");
      r1.addProperty("p1", "v2");
      r1.setProperty("test", "value2");
      r1.setProperty("test2", "value2");
      registry.put(path, r1);

      Resource r1e1 = registry.get(path);
      r1e1.setContent("r1 content");
      r1e1.editPropertyValue("p1", "v1", "v3");

      registry.put(path, r1e1);

      Resource r1e2 = registry.get(path);
      assertFalse("Property is not edited.", r1e2.getPropertyValues("p1").contains("v1"));
      assertTrue("Property is not edited.", r1e2.getPropertyValues("p1").contains("v3"));
      assertTrue("Wrong property is removed.", r1e2.getPropertyValues("p1").contains("v2"));

      deleteResources("/props");
      log.info("editingMultivaluedProperties- Passed");
    } catch (RegistryException e) {

      log.error("editingMultivaluedProperties RegistryException thrown :" + e.getMessage());
      Assert.fail("editingMultivaluedProperties RegistryException thrown :" + e.getMessage());
    }
  }
Beispiel #4
0
  private void removingProperties() {
    String path = "/props/t1/r1";
    Resource r1 = registry.newResource();
    try {
      r1.setContent("r1 content");

      r1.setProperty("p1", "v1");
      r1.setProperty("p2", "v2");
      registry.put(path, r1);

      Resource r1e1 = registry.get(path);
      r1e1.setContent("r1 content");
      r1e1.removeProperty("p1");
      registry.put(path, r1e1);

      Resource r1e2 = registry.get(path);

      assertEquals("Property is not removed.", r1e2.getProperty("p1"), null);
      assertNotNull("Wrong property is removed.", r1e2.getProperty("p2"));

      deleteResources("/props");
      log.info("removingProperties - Passed");
    } catch (RegistryException e) {

      log.error("removingProperties RegistryException thrown :" + e.getMessage());
      Assert.fail("removingProperties RegistryException thrown :" + e.getMessage());
    }
  }
  public void testDefaultQuery() throws Exception {
    Resource r1 = registry.newResource();
    String r1Content = "this is r1 content";
    r1.setContent(r1Content.getBytes());
    r1.setDescription("production ready.");
    String r1Path = "/c3/r1";
    registry.put(r1Path, r1);

    Resource r2 = registry.newResource();
    String r2Content = "content for r2 :)";
    r2.setContent(r2Content);
    r2.setDescription("ready for production use.");
    String r2Path = "/c3/r2";
    registry.put(r2Path, r2);

    Resource r3 = registry.newResource();
    String r3Content = "content for r3 :)";
    r3.setContent(r3Content);
    r3.setDescription("only for government use.");
    String r3Path = "/c3/r3";
    registry.put(r3Path, r3);

    registry.applyTag("/c3/r1", "java");
    registry.applyTag("/c3/r2", "jsp");
    registry.applyTag("/c3/r3", "ajax");

    String sql1 =
        "SELECT RT.REG_TAG_ID FROM REG_RESOURCE_TAG RT, REG_RESOURCE R "
            + "WHERE (R.REG_VERSION=RT.REG_VERSION OR "
            + "(R.REG_PATH_ID=RT.REG_PATH_ID AND R.REG_NAME=RT.REG_RESOURCE_NAME)) "
            + "AND R.REG_DESCRIPTION LIKE ? ORDER BY RT.REG_TAG_ID";

    Resource q1 = systemRegistry.newResource();
    q1.setContent(sql1);
    q1.setMediaType(RegistryConstants.SQL_QUERY_MEDIA_TYPE);
    q1.addProperty(RegistryConstants.RESULT_TYPE_PROPERTY_NAME, RegistryConstants.TAGS_RESULT_TYPE);
    systemRegistry.put("/qs/q3", q1);

    Map<String, String> parameters = new HashMap<String, String>();
    parameters.put("1", "%production%");
    Collection result = registry.executeQuery("/qs/q3", parameters);

    String[] tagPaths = result.getChildren();
    assertEquals("There should be two matching tags.", tagPaths.length, 2);

    Resource tag2 = registry.get(tagPaths[0]);
    assertEquals("First matching tag should be 'java'", (String) tag2.getContent(), "java");

    Resource tag1 = registry.get(tagPaths[1]);
    assertEquals("Second matching tag should be 'jsp'", (String) tag1.getContent(), "jsp");
  }
  public void testPermaLinksForCollections() throws Exception {

    Collection c1 = registry.newCollection();
    registry.put("/test/v14/c1", c1);

    registry.createVersion("/test/v14/c1");

    String[] c1Versions = registry.getVersions("/test/v14/c1");
    Resource c1e1 = registry.get(c1Versions[0]);
    assertEquals("Permalink incorrect", c1e1.getPermanentPath(), c1Versions[0]);

    Resource r1 = registry.newResource();
    r1.setContent("r1c1");
    registry.put("/test/v14/c1/r1", r1);

    registry.createVersion("/test/v14/c1");

    c1Versions = registry.getVersions("/test/v14/c1");
    Resource c1e2 = registry.get(c1Versions[0]);
    assertEquals("Permalink incorrect", c1e2.getPermanentPath(), c1Versions[0]);

    registry.restoreVersion(c1Versions[1]);

    Resource c1e3 = registry.get(c1Versions[1]);
    assertEquals("Permalink incorrect", c1e3.getPermanentPath(), c1Versions[1]);
  }
Beispiel #7
0
 /**
  * custom query for all the tags search is set as a resource and saved at the config
  * registry.space
  */
 private boolean setTagSearchQuery() {
   if (log.isDebugEnabled()) {
     log.debug("tag search customs query is set");
   }
   String tagsQueryPath =
       RegistryConstants.CONFIG_REGISTRY_BASE_PATH
           + RegistryConstants.QUERIES_COLLECTION_PATH
           + "/tags";
   try {
     if (!super.getUserRegistry().resourceExists(tagsQueryPath)) {
       // set-up query for tag-search.
       Resource resource = super.getUserRegistry().newResource();
       resource.setContent(
           "SELECT RT.REG_TAG_ID FROM REG_RESOURCE_TAG RT ORDER BY " + "RT.REG_TAG_ID");
       resource.setMediaType(RegistryConstants.SQL_QUERY_MEDIA_TYPE);
       resource.addProperty(
           RegistryConstants.RESULT_TYPE_PROPERTY_NAME, RegistryConstants.TAGS_RESULT_TYPE);
       super.getUserRegistry().put(tagsQueryPath, resource);
     }
     return true;
   } catch (RegistryException e) {
     log.error(e.getCause(), e);
     return false;
   }
 }
 @Test(groups = {"wso2.greg"})
 public void addAssociationToResource() throws Exception {
   Resource r2 = registry.newResource();
   String path = "/testk12/testa/testbsp/test.txt";
   r2.setContent(new String("this is the content").getBytes());
   r2.setDescription("this is test desc");
   r2.setMediaType("plain/text");
   r2.setProperty("test2", "value2");
   registry.put(path, r2);
   registry.addAssociation(path, "/vtr2121/test", "testasstype1");
   registry.addAssociation(path, "/vtr2122/test", "testasstype2");
   registry.addAssociation(path, "/vtr2123/test", "testasstype3");
   assertTrue(
       associationPathExists(path, "/vtr2121/test"), "association Destination path not exist");
   assertTrue(
       associationPathExists(path, "/vtr2122/test"), "association Destination path not exist");
   assertTrue(
       associationPathExists(path, "/vtr2123/test"), "association Destination path not exist");
   assertTrue(associationTypeExists(path, "testasstype1"), "association Type not exist");
   assertTrue(associationTypeExists(path, "testasstype2"), "association Type not exist");
   assertTrue(associationTypeExists(path, "testasstype3"), "association Type not exist");
   assertTrue(associationSourcepathExists(path, path), "association Source path not exist");
   assertTrue(associationSourcepathExists(path, path), "association Source path not exist");
   assertTrue(associationSourcepathExists(path, path), "association Source path not exist");
 }
 @Test(
     groups = {"wso2.greg"},
     dependsOnMethods = {"addAssociationToResource"})
 public void getResourceAssociation() throws Exception {
   Resource r2 = registry.newResource();
   String path = "/testk1234/testa/testbsp/test.txt";
   r2.setContent(new String("this is the content").getBytes());
   r2.setDescription("this is test desc");
   r2.setMediaType("plain/text");
   r2.setProperty("test2", "value2");
   registry.addAssociation(path, "/vtr2121/test", "testasstype1");
   registry.addAssociation(path, "/vtr2122/test", "testasstype2");
   registry.addAssociation(path, "/vtr2123/test", "testasstype3");
   assertTrue(
       getAssocitionbyDestinationByType(path, "testasstype1", "/vtr2121/test"),
       "association Destination path not exist");
   assertTrue(
       getAssocitionbyDestinationByType(path, "testasstype2", "/vtr2122/test"),
       "association Destination path not exist");
   assertTrue(
       getAssocitionbyDestinationByType(path, "testasstype3", "/vtr2123/test"),
       "association Destination path not exist");
   assertTrue(getAssocitionbyType(path, "testasstype1"), "association Type not exist");
   assertTrue(getAssocitionbyType(path, "testasstype2"), "association Type not exist");
   assertTrue(getAssocitionbyType(path, "testasstype3"), "association Type not exist");
   assertTrue(
       getAssocitionbySourceByType(path, "testasstype1"), "association Source path not exist");
   assertTrue(
       getAssocitionbySourceByType(path, "testasstype2"), "association Source path not exist");
   assertTrue(
       getAssocitionbySourceByType(path, "testasstype3"), "association Source path not exist");
 }
  public void persist(String path, byte[] resourceBytes, String tag) throws RegistryException {

    UserRegistry registry = initRegistry();

    try {
      registry.beginTransaction();
      Resource nodeResource = registry.newResource();
      nodeResource.setContent(resourceBytes);
      // store the resource in the registry
      registry.put(path, nodeResource);
      if (tag != null) {
        // apply the tag
        registry.applyTag(path, tag);
      }
      // commit
      registry.commitTransaction();

    } catch (RegistryException e) {
      String errorMsg = "Failed to persist the given resource in registry path " + path;
      log.error(errorMsg, e);
      // rollback
      try {
        registry.rollbackTransaction();

      } catch (RegistryException e1) {
        errorMsg = "Failed to rollback the transaction in registry path " + path;
        log.error(errorMsg, e1);
        throw e1;
      }
      throw e;
    }
  }
Beispiel #11
0
  public void ResourceCopyTest() throws RegistryException {

    Resource r1 = registry.newResource();
    r1.setProperty("test", "copy");
    r1.setContent("c");
    registry.put("/test1/copy/c1/copy1", r1);

    Collection c1 = registry.newCollection();
    registry.put("/test1/move", c1);

    registry.copy("/test1/copy/c1/copy1", "/test1/copy/c2/copy2");

    Resource newR1 = registry.get("/test1/copy/c2/copy2");
    assertEquals(
        "Copied resource should have a property named 'test' with value 'copy'.",
        newR1.getProperty("test"),
        "copy");

    Resource oldR1 = registry.get("/test1/copy/c1/copy1");
    assertEquals(
        "Original resource should have a property named 'test' with value 'copy'.",
        oldR1.getProperty("test"),
        "copy");

    String newContent = new String((byte[]) newR1.getContent());
    String oldContent = new String((byte[]) oldR1.getContent());
    assertEquals("Contents are not equal in copied resources", newContent, oldContent);
  }
Beispiel #12
0
  public void GeneralCollectionRenameTest() throws RegistryException {

    Resource r1 = registry.newResource();
    r1.setProperty("test", "rename");
    r1.setContent("some text");
    registry.put("/c2/rename3/c1/dummy", r1);

    registry.rename("/c2/rename3", "rename4");

    boolean failed = false;
    try {
      Resource originalR1 = registry.get("/c2/rename3/c1/dummy");
    } catch (RegistryException e) {
      failed = true;
    }
    assertTrue(
        "Resource should not be " + "accessible from the old path after renaming the parent.",
        failed);

    Resource newR1 = registry.get("/c2/rename4/c1/dummy");
    assertEquals(
        "Resource should contain a property with name test and value rename.",
        newR1.getProperty("test"),
        "rename");
  }
Beispiel #13
0
  @Test(groups = {"wso2.greg"})
  public void rootLevelCollectionRename() throws Exception {

    Resource r1 = registry.newResource();
    r1.setProperty("test", "rename");
    r1.setContent("some text");
    registry.put("/rename34k/c1/dummy", r1);

    registry.rename("/rename34k", "/rename44k");

    boolean failed = false;
    try {
      registry.get("/rename34k/c1/dummy");
    } catch (Exception e) {
      failed = true;
    }
    assertTrue(
        failed,
        "Resource should not be " + "accessible from the old path after renaming the parent.");

    Resource newR1 = registry.get("/rename44k/c1/dummy");
    assertEquals(
        newR1.getProperty("test"),
        "rename",
        "Resource should contain a property with name test and value rename.");
  }
  @Test(groups = {"wso2.greg"})
  public void ContinuousDelete() throws RegistryException, InterruptedException {
    int iterations = 100;

    for (int i = 0; i < iterations; i++) {

      Resource res1 = registry.newResource();
      byte[] r1content = "R2 content".getBytes();
      res1.setContent(r1content);
      String path = "/con-delete/test/" + i + 1;

      registry.put(path, res1);

      Resource resource1 = registry.get(path);

      assertEquals(
          new String((byte[]) resource1.getContent()),
          new String((byte[]) res1.getContent()),
          "File content is not matching");

      registry.delete(path);

      boolean value = false;

      if (registry.resourceExists(path)) {
        value = true;
      }

      assertFalse(value, "Resource found at the path");

      res1.discard();
      resource1.discard();
      Thread.sleep(100);
    }
  }
Beispiel #15
0
  public static boolean addHandler(Registry configSystemRegistry, String payload)
      throws RegistryException, XMLStreamException {
    String name;
    OMElement element = AXIOMUtil.stringToOM(payload);
    if (element != null) {
      name = element.getAttributeValue(new QName("class"));
    } else return false;

    if (isHandlerNameInUse(name))
      throw new RegistryException("The added handler name is already in use!");

    String path = getContextRoot() + name;
    Resource resource;
    if (!handlerExists(configSystemRegistry, name)) {
      resource = new ResourceImpl();
    } else {
      throw new RegistryException("The added handler name is already in use!");
    }
    resource.setContent(payload);
    try {
      configSystemRegistry.beginTransaction();
      configSystemRegistry.put(path, resource);
      generateHandler(configSystemRegistry, path);
      configSystemRegistry.commitTransaction();
    } catch (Exception e) {
      configSystemRegistry.rollbackTransaction();
      throw new RegistryException("Unable to generate handler", e);
    }
    return true;
  }
Beispiel #16
0
  private void multiValuedProperties() {
    String path = "/propTest/r1";
    Resource r1 = registry.newResource();

    try {
      r1.setContent("Some content for r1");

      r1.addProperty("p1", "p1v1");
      r1.addProperty("p1", "p1v2");
      registry.put(path, r1);

      Resource r1b = registry.get(path);
      List propValues = r1b.getPropertyValues("p1");

      assertTrue(
          "Property p1 of /propTest/r1 should contain the value p1v1", propValues.contains("p1v1"));

      assertTrue(
          "Property p1 of /propTest/r1 should contain the value p1v2", propValues.contains("p1v2"));

      deleteResources("/propTest");
      log.info("multiValuedProperties - Passed");
    } catch (RegistryException e) {

      log.error("multiValuedProperties RegistryException thrown :" + e.getMessage());
      Assert.fail("multiValuedProperties RegistryException thrown :" + e.getMessage());
    }
  }
  public void testRootLevelVersioning() throws Exception {

    Resource r1 = registry.newResource();
    r1.setContent("r1c1");
    registry.put("/vtr1", r1);

    registry.createVersion("/");

    Collection c2 = registry.newCollection();
    registry.put("/vtc2", c2);

    registry.createVersion("/");

    String[] rootVersions = registry.getVersions("/");

    Collection rootv0 = (Collection) registry.get(rootVersions[0]);
    String[] rootv0Children = (String[]) rootv0.getContent();
    assertTrue(
        "Root should have child vtr1", RegistryUtils.containsAsSubString("/vtr1", rootv0Children));
    assertTrue(
        "Root should have child vtc2", RegistryUtils.containsAsSubString("/vtc2", rootv0Children));

    Collection rootv1 = (Collection) registry.get(rootVersions[1]);
    String[] rootv1Children = (String[]) rootv1.getContent();
    assertTrue(
        "Root should have child vtr1", RegistryUtils.containsAsSubString("/vtr1", rootv1Children));
    assertFalse(
        "Root should not have child vtc2",
        RegistryUtils.containsAsSubString("/vtc2", rootv1Children));
  }
Beispiel #18
0
  public void testBackwardCompatibility() throws RegistryException {
    Registry rootRegistry = embeddedRegistryService.getSystemRegistry();
    Resource r1 = rootRegistry.newResource();
    r1.setContent("r1 content");
    rootRegistry.put("/test/comments/r1", r1);

    rootRegistry.addComment(
        "/test/comments/r1", new Comment("backward-compatibility1 on this resource :)"));
    rootRegistry.addComment(
        "/test/comments/r1", new Comment("backward-compatibility2 on this resource :)"));

    String sql =
        "SELECT REG_COMMENT_ID FROM REG_COMMENT C, REG_RESOURCE_COMMENT RC "
            + "WHERE C.REG_COMMENT_TEXT LIKE ? AND C.REG_ID=RC.REG_COMMENT_ID";

    Resource queryR = rootRegistry.newResource();
    queryR.setMediaType(RegistryConstants.SQL_QUERY_MEDIA_TYPE);
    queryR.addProperty(
        RegistryConstants.RESULT_TYPE_PROPERTY_NAME, RegistryConstants.COMMENTS_RESULT_TYPE);
    rootRegistry.put("/beep/x", queryR);
    Map<String, String> params = new HashMap<String, String>();
    params.put("query", sql);
    params.put(RegistryConstants.RESULT_TYPE_PROPERTY_NAME, RegistryConstants.COMMENTS_RESULT_TYPE);
    params.put("1", "backward-compatibility1%");
    Collection qResults = rootRegistry.executeQuery("/beep/x", params);

    String[] qPaths = (String[]) qResults.getContent();

    assertEquals("Query result count should be 1", qPaths.length, 1);
  }
  public void testResourcePropertyVersioning() throws Exception {

    Resource r1 = registry.newResource();
    r1.setContent("content 1");
    r1.addProperty("p1", "v1");
    registry.put("/v4/r1", r1);

    Resource r1v2 = registry.get("/v4/r1");
    r1v2.addProperty("p2", "v2");
    registry.put("/v4/r1", r1v2);
    registry.put("/v4/r1", r1v2);

    String[] r1Versions = registry.getVersions("/v4/r1");

    Resource r1vv1 = registry.get(r1Versions[1]);

    assertEquals(
        "r1's first version should contain a property p1 with value v1",
        r1vv1.getProperty("p1"),
        "v1");

    Resource r1vv2 = registry.get(r1Versions[0]);

    assertEquals(
        "r1's second version should contain a property p1 with value v1",
        r1vv2.getProperty("p1"),
        "v1");

    assertEquals(
        "r1's second version should contain a property p2 with value v2",
        r1vv2.getProperty("p2"),
        "v2");
  }
Beispiel #20
0
  private void populateResource() throws RegistryException {
    Resource initialResource = registry.newResource();

    //        Adding the resource for the first time
    //        user admin will be the creator and updater of this resource.
    initialResource.setContent("Test content");
    registry.put(resourcePath, initialResource);
  }
Beispiel #21
0
  public void testWithoutTableParamsQuery() throws Exception {
    Resource r1 = registry.newResource();
    String r1Content = "this is r1 content";
    r1.setContent(r1Content.getBytes());
    r1.setDescription("production ready.");
    String r1Path = "/c1/r1";
    registry.put(r1Path, r1);

    Resource r2 = registry.newResource();
    String r2Content = "content for r2 :)";
    r2.setContent(r2Content);
    r2.setDescription("ready for production use.");
    String r2Path = "/c2/r2";
    registry.put(r2Path, r2);

    Resource r3 = registry.newResource();
    String r3Content = "content for r3 :)";
    r3.setContent(r3Content);
    r3.setDescription("only for government use.");
    String r3Path = "/c2/r3";
    registry.put(r3Path, r3);

    String sql1 =
        "SELECT REG_PATH_ID, REG_NAME FROM REG_RESOURCE, " + "REG_TAG WHERE REG_DESCRIPTION LIKE ?";
    Resource q1 = systemRegistry.newResource();
    q1.setContent(sql1);
    q1.setMediaType(RegistryConstants.SQL_QUERY_MEDIA_TYPE);
    q1.addProperty(
        RegistryConstants.RESULT_TYPE_PROPERTY_NAME, RegistryConstants.RESOURCES_RESULT_TYPE);
    systemRegistry.put("/qs/q1", q1);

    Map<String, String> parameters = new HashMap<String, String>();
    parameters.put("1", "%production%");
    Resource result = registry.executeQuery("/qs/q1", parameters);

    assertTrue(
        "Search with result type Resource should return a directory.",
        result instanceof org.wso2.carbon.registry.core.Collection);

    List<String> matchingPaths = new ArrayList<String>();
    String[] paths = (String[]) result.getContent();
    matchingPaths.addAll(Arrays.asList(paths));

    assertTrue("Path /c1/r1 should be in the results.", matchingPaths.contains("/c1/r1"));
    assertTrue("Path /c2/r2 should be in the results.", matchingPaths.contains("/c2/r2"));
  }
  /**
   * @param policyStoreDTO
   * @return
   */
  public static void addPolicyToPDP(PolicyStoreDTO policyStoreDTO) throws EntitlementException {

    Registry registry;
    String policyPath;
    Collection policyCollection;
    Resource resource;

    Map.Entry<PolicyStoreManageModule, Properties> entry =
        EntitlementServiceComponent.getEntitlementConfig()
            .getPolicyStore()
            .entrySet()
            .iterator()
            .next();
    String policyStorePath = entry.getValue().getProperty("policyStorePath");

    if (policyStorePath == null) {
      policyStorePath = "/repository/identity/Entitlement/actualStore/";
    }

    if (policyStoreDTO == null
        || policyStoreDTO.getPolicy() == null
        || policyStoreDTO.getPolicy().trim().length() == 0
        || policyStoreDTO.getPolicyId() == null
        || policyStoreDTO.getPolicyId().trim().length() == 0) {
      return;
    }

    try {
      registry = EntitlementServiceComponent.getRegistryService().getGovernanceSystemRegistry();

      if (registry.resourceExists(policyStorePath)) {
        policyCollection = (Collection) registry.get(policyStorePath);
      } else {
        policyCollection = registry.newCollection();
      }

      registry.put(policyStorePath, policyCollection);
      policyPath = policyStorePath + policyStoreDTO.getPolicyId();

      if (registry.resourceExists(policyPath)) {
        resource = registry.get(policyPath);
      } else {
        resource = registry.newResource();
      }

      resource.setProperty("policyOrder", Integer.toString(policyStoreDTO.getPolicyOrder()));
      resource.setContent(policyStoreDTO.getPolicy());
      resource.setMediaType("application/xacml-policy+xml");
      AttributeDTO[] attributeDTOs = policyStoreDTO.getAttributeDTOs();
      if (attributeDTOs != null) {
        setAttributesAsProperties(attributeDTOs, resource);
      }
      registry.put(policyPath, resource);
    } catch (RegistryException e) {
      log.error(e);
      throw new EntitlementException("Error while adding policy to PDP", e);
    }
  }
  /**
   * Saves a swagger document in the registry.
   *
   * @param contentStream resource content.
   * @param path resource path.
   * @param documentVersion version of the swagger document.
   * @throws RegistryException If fails to add the swagger document to registry.
   */
  private boolean addSwaggerDocumentToRegistry(
      ByteArrayOutputStream contentStream, String path, String documentVersion)
      throws RegistryException {
    Resource resource;
    /*
    Checks if a resource is already exists in the given path.
    If exists,
    	Compare resource contents and if updated, updates the document, if not skip the updating process
    If not exists,
    	Creates a new resource and add to the resource path.
     */
    if (registry.resourceExists(path)) {
      resource = registry.get(path);
      Object resourceContentObj = resource.getContent();
      String resourceContent;
      if (resourceContentObj instanceof String) {
        resourceContent = (String) resourceContentObj;
        resource.setContent(RegistryUtils.encodeString(resourceContent));
      } else if (resourceContentObj instanceof byte[]) {
        resourceContent = RegistryUtils.decodeBytes((byte[]) resourceContentObj);
      } else {
        throw new RegistryException(CommonConstants.INVALID_CONTENT);
      }
      if (resourceContent.equals(contentStream.toString())) {
        log.info("Old content is same as the new content. Skipping the put action.");
        return false;
      }
    } else {
      // If a resource does not exist in the given path.
      resource = new ResourceImpl();
    }

    String resourceId =
        (resource.getUUID() == null) ? UUID.randomUUID().toString() : resource.getUUID();

    resource.setUUID(resourceId);
    resource.setMediaType(CommonConstants.SWAGGER_MEDIA_TYPE);
    resource.setContent(contentStream.toByteArray());
    resource.addProperty(RegistryConstants.VERSION_PARAMETER_NAME, documentVersion);
    CommonUtil.copyProperties(this.requestContext.getResource(), resource);
    registry.put(path, resource);

    return true;
  }
  @Test(groups = {"wso2.greg"})
  public void ContinuousUpdate() throws RegistryException, InterruptedException {

    int iterations = 100;

    for (int i = 0; i < iterations; i++) {

      Resource res1 = registry.newResource();
      byte[] r1content = "R2 content".getBytes();
      res1.setContent(r1content);
      String path = "/con-delete/test-update/" + i + 1;

      registry.put(path, res1);

      Resource resource1 = registry.get(path);

      assertEquals(
          new String((byte[]) resource1.getContent()),
          new String((byte[]) res1.getContent()),
          "File content is not matching");

      Resource resource = new ResourceImpl();
      byte[] r1content1 = "R2 content updated".getBytes();
      resource.setContent(r1content1);
      resource.setProperty("abc", "abc");

      registry.put(path, resource);

      Resource resource2 = registry.get(path);

      assertEquals(
          new String((byte[]) resource2.getContent()),
          new String((byte[]) resource.getContent()),
          "File content is not matching");

      resource.discard();
      res1.discard();
      resource1.discard();
      resource2.discard();
      Thread.sleep(100);
    }
  }
  public void testResourceRestore() throws Exception {

    Resource r1 = registry.newResource();
    r1.setContent("content 1".getBytes());
    registry.put("/test/v10/r1", r1);

    Resource r1e1 = registry.get("/test/v10/r1");
    r1e1.setContent("content 2".getBytes());
    registry.put("/test/v10/r1", r1e1);
    registry.put("/test/v10/r1", r1e1);

    String[] r1Versions = registry.getVersions("/test/v10/r1");
    registry.restoreVersion(r1Versions[1]);

    Resource r1r1 = registry.get("/test/v10/r1");

    assertEquals(
        "Restored resource should have content 'content 1'",
        "content 1",
        new String((byte[]) r1r1.getContent()));
  }
Beispiel #26
0
  public void testWithoutWhereQuery() throws Exception {
    Resource r1 = registry.newResource();
    String r1Content = "this is r1 content";
    r1.setContent(r1Content.getBytes());
    r1.setDescription("production ready.");
    String r1Path = "/c1/r1";
    registry.put(r1Path, r1);

    Resource r2 = registry.newResource();
    String r2Content = "content for r2 :)";
    r2.setContent(r2Content);
    r2.setDescription("ready for production use.");
    String r2Path = "/c2/r2";
    registry.put(r2Path, r2);

    Resource r3 = registry.newResource();
    String r3Content = "content for r3 :)";
    r3.setContent(r3Content);
    r3.setDescription("only for government use.");
    String r3Path = "/c2/r3";
    registry.put(r3Path, r3);

    String sql1 = "SELECT REG_PATH_ID, REG_NAME FROM REG_RESOURCE, REG_TAG";
    Resource q1 = systemRegistry.newResource();
    q1.setContent(sql1);
    q1.setMediaType(RegistryConstants.SQL_QUERY_MEDIA_TYPE);
    q1.addProperty(
        RegistryConstants.RESULT_TYPE_PROPERTY_NAME, RegistryConstants.RESOURCES_RESULT_TYPE);
    systemRegistry.put("/qs/q1", q1);

    Map parameters = new HashMap();
    Resource result = registry.executeQuery("/qs/q1", parameters);

    assertTrue(
        "Search with result type Resource should return a directory.",
        result instanceof org.wso2.carbon.registry.core.Collection);

    String[] paths = (String[]) result.getContent();
    assertTrue("Should return all the resources", paths.length >= 3);
  }
  public void testCreateVersions() throws Exception {

    Resource r1 = registry.newResource();
    r1.setContent("some content");
    registry.put("/version/r1", r1);
    registry.put("/version/r1", r1);

    // registry.createVersion("/version/r1");

    String[] r1Versions = registry.getVersions("/version/r1");

    assertEquals("/version/r1 should have 1 version.", r1Versions.length, 1);

    Resource r1v2 = registry.get("/version/r1");
    r1v2.setContent("another content");
    registry.put("/version/r1", r1v2);

    // registry.createVersion("/version/r1");

    r1Versions = registry.getVersions("/version/r1");
    assertEquals("/version/r1 should have 2 version.", r1Versions.length, 2);
  }
  /**
   * Persist the keystore in the gov.registry
   *
   * @param keyStore created Keystore of the tenant
   * @param PKCertificate pub. key of the tenant
   * @throws KeyStoreMgtException Exception when storing the keystore in the registry
   */
  private void persistKeyStore(KeyStore keyStore, X509Certificate PKCertificate)
      throws KeyStoreMgtException {
    try {
      ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
      keyStore.store(outputStream, password.toCharArray());
      outputStream.flush();
      outputStream.close();

      String keyStoreName = generateKSNameFromDomainName();
      // Use the keystore using the keystore admin
      KeyStoreAdmin keystoreAdmin = new KeyStoreAdmin(tenantId, govRegistry);
      keystoreAdmin.addKeyStore(
          outputStream.toByteArray(), keyStoreName, password, " ", "JKS", password);

      // Create the pub. key resource
      Resource pubKeyResource = govRegistry.newResource();
      pubKeyResource.setContent(PKCertificate.getEncoded());
      pubKeyResource.addProperty(
          SecurityConstants.PROP_TENANT_PUB_KEY_FILE_NAME_APPENDER,
          generatePubKeyFileNameAppender());

      govRegistry.put(RegistryResources.SecurityManagement.TENANT_PUBKEY_RESOURCE, pubKeyResource);

      // associate the public key with the keystore
      govRegistry.addAssociation(
          RegistryResources.SecurityManagement.KEY_STORES + "/" + keyStoreName,
          RegistryResources.SecurityManagement.TENANT_PUBKEY_RESOURCE,
          SecurityConstants.ASSOCIATION_TENANT_KS_PUB_KEY);

    } catch (RegistryException e) {
      String msg = "Error when writing the keystore/pub.cert to registry";
      log.error(msg, e);
      throw new KeyStoreMgtException(msg, e);
    } catch (Exception e) {
      String msg = "Error when processing keystore/pub. cert to be stored in registry";
      log.error(msg, e);
      throw new KeyStoreMgtException(msg, e);
    }
  }
Beispiel #29
0
  private void singleValuedProperties() {
    String path = "/propTest/r2";
    Resource r2 = registry.newResource();
    try {
      r2.setContent("Some content for r2");

      r2.addProperty("p1", "p1v1");
      registry.put(path, r2);

      Resource r2b = registry.get(path);
      String p1Value = r2b.getProperty("p1");

      assertEquals("Property p1 of /propTest/r2 should contain the value p1v1", p1Value, "p1v1");

      deleteResources("/propTest");
      log.info("singleValuedProperties - Passed");
    } catch (RegistryException e) {

      log.error("singleValuedProperties RegistryException thrown :" + e.getMessage());
      Assert.fail("singleValuedProperties RegistryException thrown :" + e.getMessage());
    }
  }
Beispiel #30
0
  public void RootLevelResourceRenameTest() throws RegistryException {

    Resource r1 = registry.newResource();
    r1.setProperty("test", "rename");
    r1.setContent("some text");
    registry.put("/rename2", r1);

    registry.rename("/rename2", "/rename4");

    boolean failed = false;
    try {
      registry.get("/rename2");
    } catch (RegistryException e) {
      failed = true;
    }
    assertTrue("Resource should not be accessible from the old path after renaming.", failed);

    Resource newR1 = registry.get("/rename4");
    assertEquals(
        "Resource should contain a property with name test and value rename.",
        newR1.getProperty("test"),
        "rename");
  }