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));
  }
 private Map<String, Map<String, ServiceBean>> buildServiceVersionHierarchy(
     ServiceBean[] serviceBeans) {
   Map<String, Map<String, ServiceBean>> hierarchy =
       new LinkedHashMap<String, Map<String, ServiceBean>>();
   if (serviceBeans == null) {
     return hierarchy;
   }
   for (ServiceBean serviceBean : serviceBeans) {
     if (serviceBean != null) {
       String path = RegistryUtils.getParentPath(serviceBean.getPath());
       String version = RegistryUtils.getResourceName(path);
       if (!version.replace("-SNAPSHOT", "").matches("^\\d+[.]\\d+[.]\\d+$")) {
         version = "SNAPSHOT";
         serviceBean.setPath(serviceBean.getPath());
       } else {
         serviceBean.setPath(RegistryUtils.getParentPath(path));
       }
       Map<String, ServiceBean> versionMap;
       if (hierarchy.containsKey(serviceBean.getQName())) {
         versionMap = hierarchy.get(serviceBean.getQName());
       } else {
         versionMap = new LinkedHashMap<String, ServiceBean>();
         hierarchy.put(serviceBean.getQName(), versionMap);
       }
       versionMap.put(version, serviceBean);
     }
   }
   return hierarchy;
 }
示例#3
0
 public static boolean generateHandler(Registry configSystemRegistry, String resourceFullPath)
     throws RegistryException, XMLStreamException {
   RegistryContext registryContext = configSystemRegistry.getRegistryContext();
   if (registryContext == null) {
     return false;
   }
   Resource resource = configSystemRegistry.get(resourceFullPath);
   if (resource != null) {
     String content = null;
     if (resource.getContent() != null) {
       content = RegistryUtils.decodeBytes((byte[]) resource.getContent());
     }
     if (content != null) {
       OMElement handler = AXIOMUtil.stringToOM(content);
       if (handler != null) {
         OMElement dummy = OMAbstractFactory.getOMFactory().createOMElement("dummy", null);
         dummy.addChild(handler);
         try {
           configSystemRegistry.beginTransaction();
           boolean status =
               RegistryConfigurationProcessor.updateHandler(
                   dummy,
                   configSystemRegistry.getRegistryContext(),
                   HandlerLifecycleManager.USER_DEFINED_HANDLER_PHASE);
           configSystemRegistry.commitTransaction();
           return status;
         } catch (Exception e) {
           configSystemRegistry.rollbackTransaction();
           throw new RegistryException("Unable to add handler", e);
         }
       }
     }
   }
   return false;
 }
 public static int[] getAdjacentVersions(
     ServletConfig config, HttpSession session, String path, int current) throws Exception {
   String[] nodes =
       Utils.getSortedChildNodes(
           new ResourceServiceClient(config, session).getCollectionContent(path));
   int[] versions = new int[2];
   versions[0] = -1;
   versions[1] = -1;
   int previous = -1;
   for (String node : nodes) {
     String name = RegistryUtils.getResourceName(node);
     try {
       int temp = Integer.parseInt(name);
       if (previous == current) {
         // The last match was the current version. Therefore, the match is the version
         // after the current.
         versions[1] = temp;
         break;
       }
       if (temp == current) {
         // The match is the current version. Therefore, the last match was the version
         // before the current.
         versions[0] = previous;
       }
       previous = temp;
     } catch (NumberFormatException ignore) {
     }
   }
   return versions;
 }
  /**
   * Configures the swagger resource path form its content and returns the swagger document path.
   *
   * @param rootLocation root location of the swagger files.
   * @param content swagger content.
   * @return Common resource path.
   */
  private String getSwaggerDocumentPath(String rootLocation, JsonObject content)
      throws RegistryException {

    String swaggerDocPath = requestContext.getResourcePath().getPath();
    String swaggerDocName =
        swaggerDocPath.substring(swaggerDocPath.lastIndexOf(RegistryConstants.PATH_SEPARATOR) + 1);
    JsonElement infoElement = content.get(SwaggerConstants.INFO);
    JsonObject infoObject = (infoElement != null) ? infoElement.getAsJsonObject() : null;

    if (infoObject == null || infoElement.isJsonNull()) {
      throw new RegistryException("Invalid swagger document.");
    }
    String serviceName = infoObject.get(SwaggerConstants.TITLE).getAsString().replaceAll("\\s", "");
    String serviceProvider = CarbonContext.getThreadLocalCarbonContext().getUsername();

    swaggerResourcesPath =
        rootLocation
            + serviceProvider
            + RegistryConstants.PATH_SEPARATOR
            + serviceName
            + RegistryConstants.PATH_SEPARATOR
            + documentVersion;

    String pathExpression = getSwaggerRegistryPath(swaggerDocName, serviceProvider);

    return RegistryUtils.getAbsolutePath(registry.getRegistryContext(), pathExpression);
  }
  /**
   * 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;
  }
示例#7
0
 public static String getHandlerConfiguration(Registry configSystemRegistry, String name)
     throws RegistryException, XMLStreamException {
   String path = getContextRoot() + name;
   Resource resource;
   if (handlerExists(configSystemRegistry, name)) {
     resource = configSystemRegistry.get(path);
     return RegistryUtils.decodeBytes((byte[]) resource.getContent());
   }
   return null;
 }
 /**
  * Generate REST service path
  *
  * @param requestContext Request Context
  * @param data REST Service content(OMElement)
  * @param serviceName REST Service name
  * @param serviceProvider Service Provider(current user)
  * @return Populated Path
  */
 private static String getRestServicePath(
     RequestContext requestContext, OMElement data, String serviceName, String serviceProvider) {
   String pathExpression =
       Utils.getRxtService().getStoragePath(CommonConstants.REST_SERVICE_MEDIA_TYPE);
   pathExpression = CommonUtil.replaceExpressionOfPath(pathExpression, "name", serviceName);
   pathExpression =
       RegistryUtils.getAbsolutePath(
           requestContext.getRegistryContext(),
           CommonUtil.getPathFromPathExpression(
               pathExpression, data, requestContext.getResource().getProperties()));
   pathExpression =
       CommonUtil.getPathFromPathExpression(
           pathExpression, requestContext.getResource().getProperties(), null);
   pathExpression =
       RegistryUtils.getAbsolutePath(
           requestContext.getRegistryContext(),
           CommonUtil.replaceExpressionOfPath(pathExpression, "provider", serviceProvider));
   return CommonUtil.getRegistryPath(
       requestContext.getRegistry().getRegistryContext(), pathExpression);
 }
  /**
   * Adds swagger 1.2 api resource documents to registry and returns a list of resource documents as
   * JSON objects.
   *
   * @param swaggerDocObject swagger document JSON object.
   * @param sourceUrl source url of the swagger document.
   * @param swaggerDocPath swagger document path. (path of the registry)
   * @return List of api resources.
   * @throws RegistryException If fails to import or save resource docs to the registry.
   */
  private List<JsonObject> addResourceDocsToRegistry(
      JsonObject swaggerDocObject, String sourceUrl, String swaggerDocPath)
      throws RegistryException {

    if (sourceUrl == null) {
      log.debug(CommonConstants.EMPTY_URL);
      log.warn("Resource paths cannot be read. Creating the REST service might fail.");
      return null;
    } else if (sourceUrl.startsWith("file")) {
      sourceUrl = sourceUrl.substring(0, sourceUrl.lastIndexOf("/"));
    }

    List<JsonObject> resourceObjects = new ArrayList<>();
    // Adding Resource documents to registry.
    JsonArray pathResources = swaggerDocObject.get(SwaggerConstants.APIS).getAsJsonArray();
    ByteArrayOutputStream resourceContentStream = null;
    InputStream resourceInputStream = null;
    String path;

    /*
    Loops through apis array of the swagger 1.2 api-doc and reads all the resource documents and saves them in to
    the registry.
     */
    for (JsonElement pathResource : pathResources) {
      JsonObject resourceObj = pathResource.getAsJsonObject();
      path = resourceObj.get(SwaggerConstants.PATH).getAsString();
      try {
        resourceInputStream = new URL(sourceUrl + path).openStream();
      } catch (IOException e) {
        throw new RegistryException("The URL " + sourceUrl + path + " is incorrect.", e);
      }
      resourceContentStream = CommonUtil.readSourceContent(resourceInputStream);
      JsonObject resourceObject = parser.parse(resourceContentStream.toString()).getAsJsonObject();
      resourceObjects.add(resourceObject);
      if (endpointElement == null) {
        createEndpointElement(resourceObject, SwaggerConstants.SWAGGER_VERSION_12);
      }
      // path = swaggerResourcesPath + path;
      path = path.replace("/", "");
      path = CommonUtil.replaceExpressionOfPath(swaggerResourcesPath, "name", path);
      path = RegistryUtils.getAbsolutePath(registry.getRegistryContext(), path);
      // Save Resource document to registry
      if (addSwaggerDocumentToRegistry(resourceContentStream, path, documentVersion)) {
        // Adding an dependency to API_DOC
        registry.addAssociation(swaggerDocPath, path, CommonConstants.DEPENDS);
      }
    }

    CommonUtil.closeOutputStream(resourceContentStream);
    CommonUtil.closeInputStream(resourceInputStream);
    return resourceObjects;
  }
示例#10
0
 public static String getGreatestChildVersion(
     ServletConfig config, HttpSession session, String path) throws Exception {
   String[] nodes =
       Utils.getSortedChildNodes(
           new ResourceServiceClient(config, session).getCollectionContent(path));
   String last = "";
   for (String node : nodes) {
     String name = RegistryUtils.getResourceName(node);
     try {
       Integer.parseInt(name);
       last = name;
     } catch (NumberFormatException ignore) {
     }
   }
   return last;
 }
  /**
   * Adds the service endpoint element to the registry.
   *
   * @param requestContext current request information.
   * @param endpointElement endpoint metadata element.
   * @param endpointPath endpoint location.
   * @return The resource path of the endpoint.
   * @throws RegistryException If fails to add the endpoint to the registry.
   */
  public static String addEndpointToRegistry(
      RequestContext requestContext, OMElement endpointElement, String endpointPath)
      throws RegistryException {

    if (requestContext == null || endpointElement == null || endpointPath == null) {
      throw new IllegalArgumentException(
          "Some or all of the arguments may be null. Cannot add the endpoint to registry. ");
    }

    endpointPath = getEndpointPath(requestContext, endpointElement, endpointPath);

    Registry registry = requestContext.getRegistry();
    // Creating new resource.
    Resource endpointResource = new ResourceImpl();
    // setting endpoint media type.
    endpointResource.setMediaType(CommonConstants.ENDPOINT_MEDIA_TYPE);
    // set content.
    endpointResource.setContent(RegistryUtils.encodeString(endpointElement.toString()));
    // copy other property
    endpointResource.setProperties(copyProperties(requestContext));
    // set path
    // endpointPath = getChrootedEndpointLocation(requestContext.getRegistryContext()) +
    // endpointPath;

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

    endpointResource.setUUID(resourceId);
    // saving the api resource to repository.
    registry.put(endpointPath, endpointResource);
    if (log.isDebugEnabled()) {
      log.debug("Endpoint created at " + endpointPath);
    }
    return endpointPath;
  }
示例#12
0
 public static void buildMenuItems(HttpServletRequest request, String s, String s1, String s2) {
   int menuOrder = 50;
   if (CarbonUIUtil.isUserAuthorized(request, "/permission/admin/manage/resources/ws-api")) {
     HttpSession session = request.getSession();
     String cookie = (String) session.getAttribute(ServerConstants.ADMIN_SERVICE_COOKIE);
     try {
       WSRegistryServiceClient registry = new WSRegistryServiceClient(s2, cookie);
       List<GovernanceArtifactConfiguration> configurations =
           GovernanceUtils.findGovernanceArtifactConfigurations(registry);
       Map<String, String> customAddUIMap = new LinkedHashMap<String, String>();
       Map<String, String> customViewUIMap = new LinkedHashMap<String, String>();
       List<Menu> userCustomMenuItemsList = new LinkedList<Menu>();
       for (GovernanceArtifactConfiguration configuration : configurations) {
         Component component = new Component();
         OMElement uiConfigurations = configuration.getUIConfigurations();
         String key = configuration.getKey();
         String configurationPath =
             RegistryConstants.CONFIG_REGISTRY_BASE_PATH
                 + RegistryConstants.GOVERNANCE_COMPONENT_PATH
                 + "/configuration/";
         String layoutStoragePath = configurationPath + key;
         RealmService realmService = registry.getRegistryContext().getRealmService();
         if (realmService
                 .getTenantUserRealm(realmService.getTenantManager().getTenantId(s1))
                 .getAuthorizationManager()
                 .isUserAuthorized(s, configurationPath, ActionConstants.PUT)
             || registry.resourceExists(layoutStoragePath)) {
           List<Menu> menuList = component.getMenusList();
           if (uiConfigurations != null) {
             ComponentBuilder.processMenus("artifactType", uiConfigurations, component);
             ComponentBuilder.processCustomUIs(uiConfigurations, component);
           }
           if (menuList.size() == 0) {
             // if no menu definitions were present, define the default ones.
             menuOrder = buildMenuList(request, configuration, menuList, key, menuOrder);
           }
           userCustomMenuItemsList.addAll(menuList);
           customAddUIMap.putAll(component.getCustomAddUIMap());
           Map<String, String> viewUIMap = component.getCustomViewUIMap();
           if (viewUIMap.isEmpty()) {
             // if no custom UI definitions were present, define the default.
             buildViewUI(configuration, viewUIMap, key);
           }
           customViewUIMap.putAll(viewUIMap);
           OMElement layout = configuration.getContentDefinition();
           if (layout != null && !registry.resourceExists(layoutStoragePath)) {
             Resource resource = registry.newResource();
             resource.setContent(RegistryUtils.encodeString(layout.toString()));
             resource.setMediaType("application/xml");
             registry.put(layoutStoragePath, resource);
           }
         }
       }
       session.setAttribute(
           MenuAdminClient.USER_CUSTOM_MENU_ITEMS,
           userCustomMenuItemsList.toArray(new Menu[userCustomMenuItemsList.size()]));
       session.setAttribute("customAddUI", customAddUIMap);
       session.setAttribute("customViewUI", customViewUIMap);
     } catch (RegistryException e) {
       log.error("unable to create connection to registry");
     } catch (org.wso2.carbon.user.api.UserStoreException e) {
       log.error("unable to realm service");
     }
   }
 }
示例#13
0
 private String getChrootedSchemaLocation(RegistryContext registryContext) {
   return RegistryUtils.getAbsolutePath(
       registryContext,
       RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH + getCommonSchemaLocation());
 }
示例#14
0
 public static String decorateVersionElement(
     String version,
     String basicVersionElement,
     String path,
     String type,
     String append,
     String screenWidth,
     ServletConfig config,
     HttpSession session,
     HttpServletRequest request) {
   String hrefPrefix = "../resources/resource.jsp?region=region3&item=resource_browser_menu&path=";
   String hrefPostfix = (screenWidth != null) ? "&screenWidth=" + screenWidth : "";
   String patchPath = RegistryUtils.getParentPath(path);
   String minorPath = RegistryUtils.getParentPath(patchPath);
   String majorPath = RegistryUtils.getParentPath(minorPath);
   String servicePath = RegistryUtils.getParentPath(majorPath);
   String versions[] = version.split("[.]");
   StringBuffer sb = new StringBuffer("$1type=\"hidden\"$2");
   if (type.equals("collection")) {
     sb.append("<a href=\"")
         .append(hrefPrefix)
         .append(majorPath.replaceAll("&", "%26"))
         .append(hrefPostfix)
         .append("\">")
         .append(versions[0])
         .append("</a>");
     sb.append(".");
     sb.append("<a href=\"")
         .append(hrefPrefix)
         .append(minorPath.replaceAll("&", "%26"))
         .append(hrefPostfix)
         .append("\">")
         .append(versions[1])
         .append("</a>");
     sb.append(".");
     sb.append("<a href=\"")
         .append(hrefPrefix)
         .append(patchPath.replaceAll("&", "%26"))
         .append(hrefPostfix)
         .append("\">")
         .append(versions[2])
         .append("</a>");
     sb.append(append);
   } else if (type.equals("patch")) {
     sb.append("<a href=\"")
         .append(hrefPrefix)
         .append(majorPath.replaceAll("&", "%26"))
         .append(hrefPostfix)
         .append("\">")
         .append(versions[0])
         .append("</a>");
     sb.append(".");
     sb.append("<a href=\"")
         .append(hrefPrefix)
         .append(minorPath.replaceAll("&", "%26"))
         .append(hrefPostfix)
         .append("\">")
         .append(versions[1])
         .append("</a>");
     sb.append(".");
     sb.append("<a href=\"javascript:void(0)\">").append(versions[2]).append("</a>");
     sb.append(append);
     try {
       int[] adjacentVersions =
           getAdjacentVersions(config, session, minorPath, Integer.parseInt(versions[2]));
       sb.append("&nbsp;");
       if (adjacentVersions[0] > -1) {
         sb.append("<a class=\"icon-link\" style=\"background-image: ")
             .append("url(../resources/images/arrow-up.gif);float:none !important;")
             .append("margin-bottom:0px !important;margin-top:0px !important;")
             .append("margin-left:0px !important\" href=\"")
             .append(hrefPrefix)
             .append(minorPath.replaceAll("&", "%26"))
             .append(hrefPostfix)
             .append("/")
             .append(adjacentVersions[0])
             .append("\" title=\"")
             .append(
                 CarbonUIUtil.geti18nString(
                     "previous.version",
                     "org.wso2.carbon.governance.generic.ui.i18n.Resources",
                     request.getLocale()))
             .append(": ")
             .append(versions[0])
             .append(".")
             .append(versions[1])
             .append(".")
             .append(adjacentVersions[0])
             .append("\"/>");
       }
       if (adjacentVersions[1] > -1) {
         sb.append("<a class=\"icon-link\" style=\"background-image: ")
             .append("url(../resources/images/arrow-right.gif);float:none !important;")
             .append("margin-bottom:0px !important;margin-top:0px !important;")
             .append("margin-left:0px !important\" href=\"")
             .append(hrefPrefix)
             .append(minorPath.replaceAll("&", "%26"))
             .append(hrefPostfix)
             .append("/")
             .append(adjacentVersions[1])
             .append("\" title=\"")
             .append(
                 CarbonUIUtil.geti18nString(
                     "next.version",
                     "org.wso2.carbon.governance.generic.ui.i18n.Resources",
                     request.getLocale()))
             .append(": ")
             .append(versions[0])
             .append(".")
             .append(versions[1])
             .append(".")
             .append(adjacentVersions[1])
             .append("\"/>");
       }
     } catch (Exception ignore) {
     }
   } else if (type.equals("minor")) {
     sb.append("<a href=\"")
         .append(hrefPrefix)
         .append(majorPath.replaceAll("&", "%26"))
         .append(hrefPostfix)
         .append("\">")
         .append(versions[0])
         .append("</a>");
     sb.append(".");
     sb.append("<a href=\"javascript:void(0)\">").append(versions[1]).append("</a>");
     sb.append(".");
     sb.append("<a href=\"")
         .append(hrefPrefix)
         .append(patchPath.replaceAll("&", "%26"))
         .append(hrefPostfix)
         .append("\">")
         .append(versions[2])
         .append("</a>");
     sb.append(append);
     try {
       int[] adjacentVersions =
           getAdjacentVersions(config, session, majorPath, Integer.parseInt(versions[1]));
       sb.append("&nbsp;");
       if (adjacentVersions[0] > -1) {
         String latestPatch =
             getGreatestChildVersion(config, session, majorPath + "/" + adjacentVersions[0]);
         sb.append("<a class=\"icon-link\" style=\"background-image: ")
             .append("url(../resources/images/arrow-up.gif);float:none !important;")
             .append("margin-bottom:0px !important;margin-top:0px !important;")
             .append("margin-left:0px !important\" href=\"")
             .append(hrefPrefix)
             .append(majorPath.replaceAll("&", "%26"))
             .append(hrefPostfix)
             .append("/")
             .append(adjacentVersions[0])
             .append("\" title=\"")
             .append(
                 CarbonUIUtil.geti18nString(
                     "previous.version",
                     "org.wso2.carbon.governance.generic.ui.i18n.Resources",
                     request.getLocale()))
             .append(": ")
             .append(versions[0])
             .append(".")
             .append(adjacentVersions[0])
             .append(".")
             .append(latestPatch)
             .append("\"/>");
       }
       if (adjacentVersions[1] > -1) {
         String latestPatch =
             getGreatestChildVersion(config, session, majorPath + "/" + adjacentVersions[1]);
         sb.append("<a class=\"icon-link\" style=\"background-image: ")
             .append("url(../resources/images/arrow-right.gif);float:none !important;")
             .append("margin-bottom:0px !important;margin-top:0px !important;")
             .append("margin-left:0px !important\" href=\"")
             .append(hrefPrefix)
             .append(majorPath.replaceAll("&", "%26"))
             .append(hrefPostfix)
             .append("/")
             .append(adjacentVersions[1])
             .append("\" title=\"")
             .append(
                 CarbonUIUtil.geti18nString(
                     "next.version",
                     "org.wso2.carbon.governance.generic.ui.i18n.Resources",
                     request.getLocale()))
             .append(": ")
             .append(versions[0])
             .append(".")
             .append(adjacentVersions[1])
             .append(".")
             .append(latestPatch)
             .append("\"/>");
       }
     } catch (Exception ignore) {
     }
   } else if (type.equals("major")) {
     sb.append("<a href=\"javascript:void(0)\">").append(versions[0]).append("</a>");
     sb.append(".");
     sb.append("<a href=\"")
         .append(hrefPrefix)
         .append(minorPath.replaceAll("&", "%26"))
         .append(hrefPostfix)
         .append("\">")
         .append(versions[1])
         .append("</a>");
     sb.append(".");
     sb.append("<a href=\"")
         .append(hrefPrefix)
         .append(patchPath.replaceAll("&", "%26"))
         .append(hrefPostfix)
         .append("\">")
         .append(versions[2])
         .append("</a>");
     sb.append(append);
     try {
       int[] adjacentVersions =
           getAdjacentVersions(config, session, servicePath, Integer.parseInt(versions[0]));
       sb.append("&nbsp;");
       if (adjacentVersions[0] > -1) {
         String latestMinor =
             getGreatestChildVersion(config, session, servicePath + "/" + adjacentVersions[0]);
         String latestPatch =
             getGreatestChildVersion(
                 config, session, servicePath + "/" + adjacentVersions[0] + "/" + latestMinor);
         sb.append("<a class=\"icon-link\" style=\"background-image: ")
             .append("url(../resources/images/arrow-up.gif);float:none !important;")
             .append("margin-bottom:0px !important;margin-top:0px !important;")
             .append("margin-left:0px !important\" href=\"")
             .append(hrefPrefix)
             .append(servicePath.replaceAll("&", "%26"))
             .append(hrefPostfix)
             .append("/")
             .append(adjacentVersions[0])
             .append("\" title=\"")
             .append(
                 CarbonUIUtil.geti18nString(
                     "previous.version",
                     "org.wso2.carbon.governance.generic.ui.i18n.Resources",
                     request.getLocale()))
             .append(": ")
             .append(adjacentVersions[0])
             .append(".")
             .append(latestMinor)
             .append(".")
             .append(latestPatch)
             .append("\"/>");
       }
       if (adjacentVersions[1] > -1) {
         String latestMinor =
             getGreatestChildVersion(config, session, servicePath + "/" + adjacentVersions[1]);
         String latestPatch =
             getGreatestChildVersion(
                 config, session, servicePath + "/" + adjacentVersions[1] + "/" + latestMinor);
         sb.append("<a class=\"icon-link\" style=\"background-image: ")
             .append("url(../resources/images/arrow-right.gif);float:none !important;")
             .append("margin-bottom:0px !important;margin-top:0px !important;")
             .append("margin-left:0px !important\" href=\"")
             .append(hrefPrefix)
             .append(servicePath.replaceAll("&", "%26"))
             .append(hrefPostfix)
             .append("/")
             .append(adjacentVersions[1])
             .append("\" title=\"")
             .append(
                 CarbonUIUtil.geti18nString(
                     "next.version",
                     "org.wso2.carbon.governance.generic.ui.i18n.Resources",
                     request.getLocale()))
             .append(": ")
             .append(adjacentVersions[1])
             .append(".")
             .append(latestMinor)
             .append(".")
             .append(latestPatch)
             .append("\"/>");
       }
     } catch (Exception ignore) {
     }
   }
   return basicVersionElement.replaceAll(
       "(<input[^>]*)type=\"text\"([^>]*id=\"id_Overview_Version\"[^>]*>)", sb.toString());
 }
  /**
   * Saves the REST Service registry artifact created from the imported swagger definition.
   *
   * @param requestContext information about current request.
   * @param data service artifact metadata.
   * @throws RegistryException If a failure occurs when adding the api to registry.
   */
  public static String addServiceToRegistry(RequestContext requestContext, OMElement data)
      throws RegistryException {

    if (requestContext == null || data == null) {
      throw new IllegalArgumentException(
          "Some or all of the arguments may be null. Cannot add the rest service to registry. ");
    }

    Registry registry = requestContext.getRegistry();
    // Creating new resource.
    Resource serviceResource = new ResourceImpl();
    // setting API media type.
    serviceResource.setMediaType(CommonConstants.REST_SERVICE_MEDIA_TYPE);
    serviceResource.setProperty(CommonConstants.SOURCE_PROPERTY, CommonConstants.SOURCE_AUTO);

    OMElement overview =
        data.getFirstChildWithName(new QName(CommonConstants.SERVICE_ELEMENT_NAMESPACE, OVERVIEW));
    String serviceVersion =
        overview
            .getFirstChildWithName(new QName(CommonConstants.SERVICE_ELEMENT_NAMESPACE, VERSION))
            .getText();
    String apiName =
        overview
            .getFirstChildWithName(new QName(CommonConstants.SERVICE_ELEMENT_NAMESPACE, NAME))
            .getText();
    serviceVersion =
        (serviceVersion == null) ? CommonConstants.SERVICE_VERSION_DEFAULT_VALUE : serviceVersion;

    String serviceProvider = CarbonContext.getThreadLocalCarbonContext().getUsername();

    String pathExpression = getRestServicePath(requestContext, data, apiName, serviceProvider);

    // set version property.
    serviceResource.setProperty(RegistryConstants.VERSION_PARAMETER_NAME, serviceVersion);
    // copy other property
    serviceResource.setProperties(copyProperties(requestContext));
    // set content.
    serviceResource.setContent(RegistryUtils.encodeString(data.toString()));

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

    serviceResource.setUUID(resourceId);
    String servicePath =
        getChrootedServiceLocation(requestContext.getRegistryContext())
            + CarbonContext.getThreadLocalCarbonContext().getUsername()
            + RegistryConstants.PATH_SEPARATOR
            + apiName
            + RegistryConstants.PATH_SEPARATOR
            + serviceVersion
            + RegistryConstants.PATH_SEPARATOR
            + apiName
            + "-rest_service";
    // saving the api resource to repository.

    registry.put(pathExpression, serviceResource);

    String defaultLifeCycle = CommonUtil.getDefaultLifecycle(registry, "restservice");
    if (defaultLifeCycle != null && !defaultLifeCycle.isEmpty()) {
      registry.associateAspect(serviceResource.getId(), defaultLifeCycle);
    }

    if (log.isDebugEnabled()) {
      log.debug("REST Service created at " + pathExpression);
    }
    return pathExpression;
  }
  public void put(RequestContext requestContext) throws RegistryException {
    WSDLProcessor wsdl = null;

    if (!CommonUtil.isUpdateLockAvailable()) {
      return;
    }
    CommonUtil.acquireUpdateLock();
    try {
      Registry registry = requestContext.getRegistry();
      Resource resource = requestContext.getResource();
      if (resource == null) {
        throw new RegistryException("The resource is not available.");
      }
      String originalServicePath = requestContext.getResourcePath().getPath();
      String resourceName = RegistryUtils.getResourceName(originalServicePath);

      OMElement serviceInfoElement, previousServiceInfoElement = null;
      Object resourceContent = resource.getContent();
      String serviceInfo;
      if (resourceContent instanceof String) {
        serviceInfo = (String) resourceContent;
      } else {
        serviceInfo = RegistryUtils.decodeBytes((byte[]) resourceContent);
      }
      try {
        XMLStreamReader reader =
            XMLInputFactory.newInstance().createXMLStreamReader(new StringReader(serviceInfo));
        StAXOMBuilder builder = new StAXOMBuilder(reader);
        serviceInfoElement = builder.getDocumentElement();
      } catch (Exception e) {
        String msg =
            "Error in parsing the service content of the service. "
                + "The requested path to store the service: "
                + originalServicePath
                + ".";
        log.error(msg);
        throw new RegistryException(msg, e);
      }
      // derive the service path that the service should be saved.
      String serviceName = CommonUtil.getServiceName(serviceInfoElement);
      String serviceNamespace = CommonUtil.getServiceNamespace(serviceInfoElement);

      String servicePath = "";
      if (serviceInfoElement.getChildrenWithLocalName("newServicePath").hasNext()) {
        Iterator OmElementIterator = serviceInfoElement.getChildrenWithLocalName("newServicePath");

        while (OmElementIterator.hasNext()) {
          OMElement next = (OMElement) OmElementIterator.next();
          servicePath = next.getText();
          break;
        }
      } else {
        if (registry.resourceExists(originalServicePath)) {
          // Fixing REGISTRY-1790. Save the Service to the given original
          // service path if there is a service already exists there
          servicePath = originalServicePath;
        } else {
          servicePath =
              RegistryUtils.getAbsolutePath(
                  registry.getRegistryContext(),
                  registry.getRegistryContext().getServicePath()
                      + (serviceNamespace == null
                          ? ""
                          : CommonUtil.derivePathFragmentFromNamespace(serviceNamespace))
                      + serviceName);
        }
      }
      String serviceVersion =
          org.wso2.carbon.registry.common.utils.CommonUtil.getServiceVersion(serviceInfoElement);

      if (serviceVersion.length() == 0) {
        serviceVersion = defaultServiceVersion;
        CommonUtil.setServiceVersion(serviceInfoElement, serviceVersion);
        resource.setContent(serviceInfoElement.toString());
      }
      // saving the artifact id.
      String serviceId = resource.getUUID();
      if (serviceId == null) {
        // generate a service id
        serviceId = UUID.randomUUID().toString();
        resource.setUUID(serviceId);
      }

      if (registry.resourceExists(servicePath)) {
        Resource oldResource = registry.get(servicePath);
        String oldContent;
        Object content = oldResource.getContent();
        if (content instanceof String) {
          oldContent = (String) content;
        } else {
          oldContent = RegistryUtils.decodeBytes((byte[]) content);
        }
        OMElement oldServiceInfoElement = null;
        if (serviceInfo.equals(oldContent)) {
          // TODO: This needs a better solution. This fix was put in place to avoid
          // duplication of services under /_system/governance, when no changes were made.
          // However, the fix is not perfect and needs to be rethought. Perhaps the logic
          // below can be reshaped a bit, or may be we don't need to compare the
          // difference over here with a little fix to the Governance API end. - Janaka.

          // We have fixed this assuming that the temp path where services are stored is under
          // /_system/governance/[serviceName]
          // Hence if we are to change that location, then we need to change the following code
          // segment as well
          String tempPath =
              RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH
                  + RegistryConstants.PATH_SEPARATOR
                  + resourceName;

          if (!originalServicePath.equals(tempPath)) {
            String path =
                RegistryUtils.getRelativePathToOriginal(
                    servicePath, RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH);
            ArtifactManager.getArtifactManager().getTenantArtifactRepository().addArtifact(path);
            return;
          }
          requestContext.setProcessingComplete(true);
          return;
        }
        if ("true".equals(resource.getProperty("registry.DefinitionImport"))) {
          resource.removeProperty("registry.DefinitionImport");
          try {
            XMLStreamReader reader =
                XMLInputFactory.newInstance().createXMLStreamReader(new StringReader(oldContent));
            StAXOMBuilder builder = new StAXOMBuilder(reader);
            oldServiceInfoElement = builder.getDocumentElement();
            CommonUtil.setServiceName(
                oldServiceInfoElement, CommonUtil.getServiceName(serviceInfoElement));
            CommonUtil.setServiceNamespace(
                oldServiceInfoElement, CommonUtil.getServiceNamespace(serviceInfoElement));
            CommonUtil.setDefinitionURL(
                oldServiceInfoElement, CommonUtil.getDefinitionURL(serviceInfoElement));
            CommonUtil.setEndpointEntries(
                oldServiceInfoElement, CommonUtil.getEndpointEntries(serviceInfoElement));
            CommonUtil.setServiceVersion(
                oldServiceInfoElement,
                org.wso2.carbon.registry.common.utils.CommonUtil.getServiceVersion(
                    serviceInfoElement));
            serviceInfoElement = oldServiceInfoElement;
            resource.setContent(serviceInfoElement.toString());
            resource.setDescription(oldResource.getDescription());
          } catch (Exception e) {
            String msg =
                "Error in parsing the service content of the service. "
                    + "The requested path to store the service: "
                    + originalServicePath
                    + ".";
            log.error(msg);
            throw new RegistryException(msg, e);
          }
        }

        try {
          previousServiceInfoElement = AXIOMUtil.stringToOM(oldContent);
        } catch (XMLStreamException e) {
          String msg =
              "Error in parsing the service content of the service. "
                  + "The requested path to store the service: "
                  + originalServicePath
                  + ".";
          log.error(msg);
          throw new RegistryException(msg, e);
        }
      } else if ("true".equals(resource.getProperty("registry.DefinitionImport"))) {
        resource.removeProperty("registry.DefinitionImport");
      }
      //            CommonUtil.addGovernanceArtifactEntryWithAbsoluteValues(
      //                    CommonUtil.getUnchrootedSystemRegistry(requestContext),
      //                    serviceId, servicePath);

      String definitionURL = CommonUtil.getDefinitionURL(serviceInfoElement);
      if (previousServiceInfoElement != null) {
        String oldDefinition = CommonUtil.getDefinitionURL(previousServiceInfoElement);
        if ((!"".equals(oldDefinition) && "".equals(definitionURL))
            || (!"".endsWith(oldDefinition) && !oldDefinition.equals(definitionURL))) {
          try {
            registry.removeAssociation(servicePath, oldDefinition, CommonConstants.DEPENDS);
            registry.removeAssociation(oldDefinition, servicePath, CommonConstants.USED_BY);
            EndpointUtils.removeEndpointEntry(oldDefinition, serviceInfoElement, registry);
            resource.setContent(
                RegistryUtils.decodeBytes((serviceInfoElement.toString()).getBytes()));
          } catch (RegistryException e) {
            throw new RegistryException(
                "Failed to remove endpoints from Service UI : " + serviceName, e);
          }
        }
      }

      boolean alreadyAdded = false;
      if (definitionURL != null
          && (definitionURL.startsWith("http://") || definitionURL.startsWith("https://"))) {
        String definitionPath;
        if (definitionURL.toLowerCase().endsWith("wsdl")) {
          wsdl = buildWSDLProcessor(requestContext);
          RequestContext context =
              new RequestContext(
                  registry, requestContext.getRepository(), requestContext.getVersionRepository());
          context.setResourcePath(
              new ResourcePath(RegistryConstants.PATH_SEPARATOR + serviceName + ".wsdl"));
          context.setSourceURL(definitionURL);
          context.setResource(new ResourceImpl());
          definitionPath =
              wsdl.addWSDLToRegistry(
                  context,
                  definitionURL,
                  null,
                  false,
                  false,
                  disableWSDLValidation,
                  disableSymlinkCreation);

        } else if (definitionURL.toLowerCase().endsWith("wadl")) {
          WADLProcessor wadlProcessor = buildWADLProcessor(requestContext);
          wadlProcessor.setCreateService(false);
          RequestContext context =
              new RequestContext(
                  registry, requestContext.getRepository(), requestContext.getVersionRepository());
          context.setResourcePath(
              new ResourcePath(RegistryConstants.PATH_SEPARATOR + serviceName + ".wadl"));
          context.setSourceURL(definitionURL);
          context.setResource(new ResourceImpl());
          definitionPath = wadlProcessor.importWADLToRegistry(context, null, disableWADLValidation);
        } else {
          throw new RegistryException(
              "Invalid service definition found. " + "Please enter a valid WSDL/WADL URL");
        }

        if (definitionPath == null) {
          return;
        }
        definitionURL =
            RegistryUtils.getRelativePath(requestContext.getRegistryContext(), definitionPath);
        CommonUtil.setDefinitionURL(serviceInfoElement, definitionURL);
        resource.setContent(RegistryUtils.decodeBytes((serviceInfoElement.toString()).getBytes()));
        // updating the wsdl/wadl url
        ((ResourceImpl) resource).prepareContentForPut();
        persistServiceResource(registry, resource, servicePath);
        alreadyAdded = true;
        // and make the associations
        registry.addAssociation(servicePath, definitionPath, CommonConstants.DEPENDS);
        registry.addAssociation(definitionPath, servicePath, CommonConstants.USED_BY);

      } else if (definitionURL != null && definitionURL.startsWith(RegistryConstants.ROOT_PATH)) {
        // it seems definitionUrl is a registry path..
        String definitionPath =
            RegistryUtils.getAbsolutePath(requestContext.getRegistryContext(), definitionURL);
        if (!definitionPath.startsWith(
            RegistryUtils.getAbsolutePath(
                requestContext.getRegistryContext(),
                RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH))) {

          definitionPath = RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH + definitionPath;
        }
        boolean addItHere = false;
        if (!registry.resourceExists(definitionPath)) {
          String msg =
              "Associating service to a non-existing WSDL. wsdl url: "
                  + definitionPath
                  + ", "
                  + "service path: "
                  + servicePath
                  + ".";
          log.error(msg);
          throw new RegistryException(msg);
        }
        if (!registry.resourceExists(servicePath)) {
          addItHere = true;
        } else {
          Association[] dependencies =
              registry.getAssociations(servicePath, CommonConstants.DEPENDS);
          boolean dependencyFound = false;
          if (dependencies != null) {
            for (Association dependency : dependencies) {
              if (definitionPath.equals(dependency.getDestinationPath())) {
                dependencyFound = true;
              }
            }
          }
          if (!dependencyFound) {
            addItHere = true;
          }
        }
        if (addItHere) { // add the service right here..
          ((ResourceImpl) resource).prepareContentForPut();
          persistServiceResource(registry, resource, servicePath);
          alreadyAdded = true;
          // and make the associations

          registry.addAssociation(servicePath, definitionPath, CommonConstants.DEPENDS);
          registry.addAssociation(definitionPath, servicePath, CommonConstants.USED_BY);
        }
      }

      if (!alreadyAdded) {
        // we are adding the resource anyway.
        ((ResourceImpl) resource).prepareContentForPut();
        persistServiceResource(registry, resource, servicePath);
      }

      /*
                  if (!servicePath.contains(registry.getRegistryContext().getServicePath())) {
                      if (defaultEnvironment == null) {
                          String serviceDefaultEnvironment = registry.getRegistryContext().getServicePath();
                          String relativePath = serviceDefaultEnvironment.replace(RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH, "");
                          relativePath = relativePath.replace(CommonUtil.derivePathFragmentFromNamespace(serviceNamespace),"");
                          defaultEnvironment = relativePath;
                      }

                      String currentRelativePath = servicePath.substring(0, servicePath.indexOf(CommonUtil.derivePathFragmentFromNamespace(serviceNamespace)));
                      currentRelativePath = currentRelativePath.replace(RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH,"");

                      String endpointEnv = EndpointUtils.getEndpointLocation();

                      String[] pathSegments = defaultEnvironment.split(RegistryConstants.PATH_SEPARATOR);

                      for (String pathSegment : pathSegments) {
                          endpointEnv = endpointEnv.replace(pathSegment,"");
                          currentRelativePath = currentRelativePath.replace(pathSegment,"");
                      }

                      while(endpointEnv.startsWith(RegistryConstants.PATH_SEPARATOR)){
                          endpointEnv = endpointEnv.replaceFirst(RegistryConstants.PATH_SEPARATOR,"");
                      }

                      environment = currentRelativePath + endpointEnv;
                  }
      */

      EndpointUtils.saveEndpointsFromServices(
          servicePath,
          serviceInfoElement,
          registry,
          CommonUtil.getUnchrootedSystemRegistry(requestContext));

      String symlinkLocation =
          RegistryUtils.getAbsolutePath(
              requestContext.getRegistryContext(),
              requestContext.getResource().getProperty(RegistryConstants.SYMLINK_PROPERTY_NAME));
      if (!servicePath.equals(originalServicePath)) {
        // we are creating a sym link from service path to original service path.
        Resource serviceResource =
            requestContext.getRegistry().get(RegistryUtils.getParentPath(originalServicePath));
        String isLink = serviceResource.getProperty("registry.link");
        String mountPoint = serviceResource.getProperty("registry.mountpoint");
        String targetPoint = serviceResource.getProperty("registry.targetpoint");
        String actualPath = serviceResource.getProperty("registry.actualpath");
        if (isLink != null && mountPoint != null && targetPoint != null) {
          symlinkLocation = actualPath + RegistryConstants.PATH_SEPARATOR;
        }
        if (symlinkLocation != null) {
          requestContext
              .getSystemRegistry()
              .createLink(symlinkLocation + resourceName, servicePath);
        }
      }
      // in this flow the resource is already added. marking the process completed..
      requestContext.setProcessingComplete(true);

      if (wsdl != null
          && CommonConstants.ENABLE.equals(
              System.getProperty(CommonConstants.UDDI_SYSTEM_PROPERTY))) {
        AuthToken authToken = UDDIUtil.getPublisherAuthToken();
        if (authToken == null) {
          return;
        }

        // creating the business service info bean
        BusinessServiceInfo businessServiceInfo = new BusinessServiceInfo();
        // Following lines removed  for fixing REGISTRY-1898.
        //              businessServiceInfo.setServiceName(serviceName.trim());
        //              businessServiceInfo.setServiceNamespace(serviceNamespace.trim());
        //
        // businessServiceInfo.setServiceEndpoints(CommonUtil.getEndpointEntries(serviceInfoElement));
        //
        // businessServiceInfo.setDocuments(CommonUtil.getDocLinks(serviceInfoElement));

        businessServiceInfo.setServiceDescription(
            CommonUtil.getServiceDescription(serviceInfoElement));
        WSDLInfo wsdlInfo = wsdl.getMasterWSDLInfo();
        businessServiceInfo.setServiceWSDLInfo(wsdlInfo);
        UDDIPublisher publisher = new UDDIPublisher();
        publisher.publishBusinessService(authToken, businessServiceInfo);
      }

      String path =
          RegistryUtils.getRelativePathToOriginal(
              servicePath, RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH);
      ArtifactManager.getArtifactManager().getTenantArtifactRepository().addArtifact(path);
    } finally {
      CommonUtil.releaseUpdateLock();
    }
  }
示例#17
0
  public String importWADLToRegistry(
      RequestContext requestContext, String commonLocation, boolean skipValidation)
      throws RegistryException {

    ResourcePath resourcePath = requestContext.getResourcePath();
    String wadlName = RegistryUtils.getResourceName(resourcePath.getPath());
    String version =
        requestContext.getResource().getProperty(RegistryConstants.VERSION_PARAMETER_NAME);

    if (version == null) {
      version = CommonConstants.WADL_VERSION_DEFAULT_VALUE;
      requestContext.getResource().setProperty(RegistryConstants.VERSION_PARAMETER_NAME, version);
    }

    String uri = requestContext.getSourceURL();
    if (!skipValidation) {
      validateWADL(uri);
    }

    Registry registry = requestContext.getRegistry();
    Resource resource = registry.newResource();
    if (resource.getUUID() == null) {
      resource.setUUID(UUID.randomUUID().toString());
    }
    resource.setMediaType(wadlMediaType);
    resource.setProperties(requestContext.getResource().getProperties());

    ByteArrayOutputStream outputStream;
    OMElement wadlElement;
    try {
      InputStream inputStream = new URL(uri).openStream();

      outputStream = new ByteArrayOutputStream();
      int nextChar;
      while ((nextChar = inputStream.read()) != -1) {
        outputStream.write(nextChar);
      }
      outputStream.flush();
      wadlElement = AXIOMUtil.stringToOM(new String(outputStream.toByteArray()));
      // to validate XML
      wadlElement.toString();
    } catch (Exception e) {
      // This exception is unexpected because the WADL already validated
      throw new RegistryException(
          "Unexpected error occured " + "while reading the WADL at" + uri, e);
    }

    String wadlNamespace = wadlElement.getNamespace().getNamespaceURI();
    String namespaceSegment =
        CommonUtil.derivePathFragmentFromNamespace(wadlNamespace).replace("//", "/");

    OMElement grammarsElement =
        wadlElement.getFirstChildWithName(new QName(wadlNamespace, "grammars"));
    String wadlBaseUri = uri.substring(0, uri.lastIndexOf("/") + 1);
    if (grammarsElement != null) {
      grammarsElement.detach();
      wadlElement.addChild(resolveImports(grammarsElement, wadlBaseUri, version));
    }

    String actualPath;
    if (commonLocation != null) {
      actualPath = commonLocation + namespaceSegment + version + "/" + wadlName;
    } else {
      actualPath =
          RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH
              + commonWADLLocation
              + namespaceSegment
              + version
              + "/"
              + wadlName;
    }
    if (resource.getProperty(CommonConstants.SOURCE_PROPERTY) == null) {
      resource.setProperty(CommonConstants.SOURCE_PROPERTY, CommonConstants.SOURCE_AUTO);
    }

    resource.setContent(wadlElement.toString());
    requestContext.setResourcePath(new ResourcePath(actualPath));
    registry.put(actualPath, resource);
    addImportAssociations(actualPath);
    if (createService) {
      OMElement serviceElement =
          RESTServiceUtils.createRestServiceArtifact(
              wadlElement,
              wadlName,
              version,
              RegistryUtils.getRelativePath(requestContext.getRegistryContext(), actualPath));
      String servicePath = RESTServiceUtils.addServiceToRegistry(requestContext, serviceElement);
      addDependency(servicePath, actualPath);
      String endpointPath = createEndpointElement(requestContext, wadlElement, version);
      if (endpointPath != null) {
        addDependency(servicePath, endpointPath);
      }
    }

    return actualPath;
  }
示例#18
0
  /**
   * Adds the given WSDL artifact to the registry.
   *
   * @param wsdl the WSDL artifact.
   * @throws GovernanceException if the operation failed.
   */
  public void addWsdl(Wsdl wsdl) throws GovernanceException {
    boolean succeeded = false;
    try {
      registry.beginTransaction();
      String url = wsdl.getUrl();
      Resource wsdlResource = registry.newResource();
      wsdlResource.setMediaType(GovernanceConstants.WSDL_MEDIA_TYPE);

      // setting the wsdl content
      setContent(wsdl, wsdlResource);
      wsdlResource.setUUID(wsdl.getId());

      String tmpPath;
      if (wsdl.getQName() != null) {
        tmpPath = "/" + wsdl.getQName().getLocalPart();
      } else if (url != null && !url.startsWith("name://")) {
        tmpPath = RegistryUtils.getResourceName(new URL(url).getFile().replace("~", ""));
      } else if (url != null) {
        tmpPath = url.substring("name://".length());
      } else {
        tmpPath = wsdl.getId() + ".wsdl";
      }
      // OK this is a hack to get the UUID of the newly added artifact. This needs to be fixed
      // properly with the fix for UUID support at Kernel-level - Janaka.
      //            Resource resource;
      if (url == null || url.startsWith("name://")) {
        //                resource = registry.get(registry.put("/" + tmpPath, wsdlResource));
        registry.put("/" + tmpPath, wsdlResource);
      } else {
        //                resource = registry.get(registry.importResource(tmpPath, url,
        // wsdlResource));
        registry.importResource(tmpPath, url, wsdlResource);
      }
      //            wsdl.setId(resource.getUUID());
      wsdl.updatePath();
      //    wsdl.loadWsdlDetails();
      succeeded = true;
    } catch (RegistryException e) {
      String msg = "Error in adding the wsdl. wsdl id: " + wsdl.getId() + ".";
      log.error(msg, e);
      throw new GovernanceException(msg, e);
    } catch (MalformedURLException e) {
      String msg = "Malformed policy url provided. url: " + wsdl.getUrl() + ".";
      log.error(msg, e);
      throw new GovernanceException(msg, e);
    } finally {
      if (succeeded) {
        try {
          registry.commitTransaction();
        } catch (RegistryException e) {
          String msg =
              "Error in committing transactions. Add wsdl failed: wsdl id: "
                  + wsdl.getId()
                  + ", path: "
                  + wsdl.getPath()
                  + ".";
          log.error(msg, e);
        }
      } else {
        try {
          registry.rollbackTransaction();
        } catch (RegistryException e) {
          String msg =
              "Error in rolling back transactions. Add wsdl failed: wsdl id: "
                  + wsdl.getId()
                  + ", path: "
                  + wsdl.getPath()
                  + ".";
          log.error(msg, e);
        }
      }
    }
  }
  public void put(RequestContext requestContext) throws RegistryException {
    Resource resource = requestContext.getResource();
    Object content = resource.getContent();
    String contentString;
    if (content instanceof String) {
      contentString = (String) content;
    } else {
      contentString = RegistryUtils.decodeBytes((byte[]) content);
    }
    OMElement payload;
    try {
      payload = AXIOMUtil.stringToOM(contentString);
    } catch (XMLStreamException e) {
      String msg = "Unable to serialize resource content";
      log.error(msg, e);
      throw new RegistryException(msg, e);
    }
    OMNamespace namespace = payload.getNamespace();
    String namespaceURI = namespace.getNamespaceURI();
    OMElement definition = payload.getFirstChildWithName(new QName(namespaceURI, "definition"));
    OMElement projectPath =
        definition.getFirstChildWithName(new QName(namespaceURI, "projectPath"));
    String projectMetadataPath = null;
    if (projectPath != null) {
      projectMetadataPath = RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH + projectPath.getText();
    }

    Resource metadataResource = requestContext.getRegistry().get(projectMetadataPath);

    String remainingWork = metadataResource.getProperty("Remaining Work");
    String scheduledWork = metadataResource.getProperty("Scheduled Work");
    String actualWork = metadataResource.getProperty("Actual Work");

    String remainingCost = metadataResource.getProperty("Remaining Cost");
    String scheduledCost = metadataResource.getProperty("Scheduled Cost");
    String actualCost = metadataResource.getProperty("Actual Cost");

    String duration = metadataResource.getProperty("Duration");
    String startDate = metadataResource.getProperty("Start Date");
    String endDate = metadataResource.getProperty("Finish Date");

    OMFactory factory = payload.getOMFactory();
    OMElement work = payload.getFirstChildWithName(new QName(namespaceURI, "work"));
    if (work == null) {
      work = factory.createOMElement("work", namespace, payload);
    }
    OMElement remainingWorkElement =
        work.getFirstChildWithName(new QName(namespaceURI, "remaining"));
    if (remainingWorkElement == null) {
      remainingWorkElement = factory.createOMElement("remaining", namespace, work);
    }
    remainingWorkElement.setText(remainingWork);
    OMElement actualWorkElement = work.getFirstChildWithName(new QName(namespaceURI, "actual"));
    if (actualWorkElement == null) {
      actualWorkElement = factory.createOMElement("actual", namespace, work);
    }
    actualWorkElement.setText(remainingWork);
    OMElement scheduledWorkElement =
        work.getFirstChildWithName(new QName(namespaceURI, "scheduled"));
    if (scheduledWorkElement == null) {
      scheduledWorkElement = factory.createOMElement("scheduled", namespace, work);
    }
    scheduledWorkElement.setText(remainingWork);

    OMElement cost = payload.getFirstChildWithName(new QName(namespaceURI, "cost"));
    if (cost == null) {
      cost = factory.createOMElement("cost", namespace, payload);
    }
    OMElement remainingCostElement =
        cost.getFirstChildWithName(new QName(namespaceURI, "remaining"));
    if (remainingCostElement == null) {
      remainingCostElement = factory.createOMElement("remaining", namespace, cost);
    }
    remainingCostElement.setText(remainingCost);
    OMElement actualCostElement = cost.getFirstChildWithName(new QName(namespaceURI, "actual"));
    if (actualCostElement == null) {
      actualCostElement = factory.createOMElement("actual", namespace, cost);
    }
    actualCostElement.setText(remainingCost);
    OMElement scheduledCostElement =
        cost.getFirstChildWithName(new QName(namespaceURI, "scheduled"));
    if (scheduledCostElement == null) {
      scheduledCostElement = factory.createOMElement("scheduled", namespace, cost);
    }
    scheduledCostElement.setText(remainingCost);

    OMElement timeline = payload.getFirstChildWithName(new QName(namespaceURI, "timeline"));
    if (timeline == null) {
      timeline = factory.createOMElement("timeline", namespace, payload);
    }
    OMElement durationElement = timeline.getFirstChildWithName(new QName(namespaceURI, "duration"));
    if (durationElement == null) {
      durationElement = factory.createOMElement("duration", namespace, timeline);
    }
    durationElement.setText(duration);
    OMElement startDateElement =
        timeline.getFirstChildWithName(new QName(namespaceURI, "startDate"));
    if (startDateElement == null) {
      startDateElement = factory.createOMElement("startDate", namespace, timeline);
    }
    startDateElement.setText(startDate);
    OMElement endDateElement = timeline.getFirstChildWithName(new QName(namespaceURI, "endDate"));
    if (endDateElement == null) {
      endDateElement = factory.createOMElement("endDate", namespace, timeline);
    }
    endDateElement.setText(endDate);

    resource.setContent(payload.toString());
  }
 /**
  * Returns the root location of the endpoint.
  *
  * @param registryContext registry context
  * @return The root location of the Endpoint artifact.
  */
 private static String getChrootedEndpointLocation(RegistryContext registryContext) {
   return RegistryUtils.getAbsolutePath(
       registryContext, RegistryConstants.GOVERNANCE_REGISTRY_BASE_PATH + commonEndpointLocation);
 }
  public void testLifecycle() throws RegistryException {

    Resource r1 = registry.newResource();
    byte[] r1content = RegistryUtils.encodeString("R1 content");
    r1.setContent(r1content);
    registry.put("/d12/r1", r1);

    String text1 = "this can be used as a test resource.";
    String text2 = "I like this";
    final Comment comment1 = new Comment(text1);
    comment1.setUser("someone");
    registry.addComment("/d12/r1", comment1);
    final Comment comment2 = new Comment(text2);
    comment2.setUser("someone");
    registry.addComment("/d12/r1", comment2);

    Comment[] comments = registry.getComments("/d12/r1");
    Assert.assertNotNull(registry.get("/d12/r1").getContent());

    boolean commentFound = false;
    for (Comment comment : comments) {
      if (comment.getText().equals(text1)) {
        commentFound = true;
        break;
      }
    }
    Assert.assertTrue(
        "comment '" + text1 + "' is not associated with the artifact /d12/r1", commentFound);

    Resource commentsResource = registry.get("/d12/r1;comments");
    Assert.assertTrue(
        "Comment collection resource should be a directory.",
        commentsResource instanceof Collection);
    comments = (Comment[]) commentsResource.getContent();

    List commentTexts = new ArrayList();
    for (Comment comment : comments) {
      Resource commentResource = registry.get(comment.getPath());
      commentTexts.add(commentResource.getContent());
    }

    Assert.assertTrue(
        text1 + " is not associated for resource /d12/r1.", commentTexts.contains(text1));
    Assert.assertTrue(
        text2 + " is not associated for resource /d12/r1.", commentTexts.contains(text2));

    registry.associateAspect("/d12/r1", LIFECYCLE_NAME);

    registry.invokeAspect("/d12/r1", LIFECYCLE_NAME, "promote");

    Resource resource = registry.get("/developed/d12/r1");
    Assert.assertNotNull(resource);
    Assert.assertNotNull(resource.getContent());

    comments = registry.getComments("/developed/d12/r1");

    commentFound = false;
    for (Comment comment : comments) {
      if (comment.getText().equals(text1)) {
        commentFound = true;
        break;
      }
    }
    Assert.assertTrue(
        "comment '" + text1 + "' is not associated with the artifact /developed/d12/r1",
        commentFound);

    commentsResource = registry.get("/developed/d12/r1;comments");
    Assert.assertTrue(
        "Comment collection resource should be a directory.",
        commentsResource instanceof Collection);
    comments = (Comment[]) commentsResource.getContent();

    commentTexts = new ArrayList();
    for (Comment comment : comments) {
      Resource commentResource = registry.get(comment.getPath());
      commentTexts.add(commentResource.getContent());
    }

    Assert.assertTrue(
        text1 + " is not associated for resource /developed/d12/r1.", commentTexts.contains(text1));
    Assert.assertTrue(
        text2 + " is not associated for resource /developed/d12/r1.", commentTexts.contains(text2));
  }
示例#22
0
  public String addWadlToRegistry(
      RequestContext requestContext, Resource resource, String resourcePath, boolean skipValidation)
      throws RegistryException {
    String wadlName = RegistryUtils.getResourceName(resourcePath);
    String version =
        requestContext.getResource().getProperty(RegistryConstants.VERSION_PARAMETER_NAME);

    if (version == null) {
      version = CommonConstants.WADL_VERSION_DEFAULT_VALUE;
      requestContext.getResource().setProperty(RegistryConstants.VERSION_PARAMETER_NAME, version);
    }

    OMElement wadlElement;
    String wadlContent;
    Object resourceContent = resource.getContent();
    if (resourceContent instanceof String) {
      wadlContent = (String) resourceContent;
    } else {
      wadlContent = new String((byte[]) resourceContent);
    }

    try {
      XMLStreamReader reader =
          XMLInputFactory.newInstance().createXMLStreamReader(new StringReader(wadlContent));
      StAXOMBuilder builder = new StAXOMBuilder(reader);
      wadlElement = builder.getDocumentElement();
    } catch (XMLStreamException e) {
      // This exception is unexpected because the WADL already validated
      String msg = "Unexpected error occured " + "while reading the WADL at " + resourcePath + ".";
      log.error(msg);
      throw new RegistryException(msg, e);
    }

    String wadlNamespace = wadlElement.getNamespace().getNamespaceURI();
    String namespaceSegment =
        CommonUtil.derivePathFragmentFromNamespace(wadlNamespace).replace("//", "/");
    String actualPath =
        getChrootedWadlLocation(requestContext.getRegistryContext())
            + namespaceSegment
            + version
            + "/"
            + wadlName;

    OMElement grammarsElement =
        wadlElement.getFirstChildWithName(new QName(wadlNamespace, "grammars"));

    if (StringUtils.isNotBlank(requestContext.getSourceURL())) {
      String uri = requestContext.getSourceURL();
      if (!skipValidation) {
        validateWADL(uri);
      }

      if (resource.getUUID() == null) {
        resource.setUUID(UUID.randomUUID().toString());
      }

      String wadlBaseUri = uri.substring(0, uri.lastIndexOf("/") + 1);
      if (grammarsElement != null) {
        // This is to avoid evaluating the grammars import when building AST
        grammarsElement.detach();
        wadlElement.addChild(resolveImports(grammarsElement, wadlBaseUri, version));
      }
    } else {
      if (!skipValidation) {
        File tempFile = null;
        BufferedWriter bufferedWriter = null;
        try {
          tempFile = File.createTempFile(wadlName, null);
          bufferedWriter = new BufferedWriter(new FileWriter(tempFile));
          bufferedWriter.write(wadlElement.toString());
          bufferedWriter.flush();
        } catch (IOException e) {
          String msg = "Error occurred while reading the WADL File";
          log.error(msg, e);
          throw new RegistryException(msg, e);
        } finally {
          if (bufferedWriter != null) {
            try {
              bufferedWriter.close();
            } catch (IOException e) {
              String msg = "Error occurred while closing File writer";
              log.warn(msg, e);
            }
          }
        }
        validateWADL(tempFile.toURI().toString());
        try {
          delete(tempFile);
        } catch (IOException e) {
          String msg =
              "An error occurred while deleting the temporary files from local file system.";
          log.warn(msg, e);
          throw new RegistryException(msg, e);
        }
      }

      if (grammarsElement != null) {
        grammarsElement = resolveImports(grammarsElement, null, version);
        wadlElement.addChild(grammarsElement);
      }
    }

    requestContext.setResourcePath(new ResourcePath(actualPath));
    if (resource.getProperty(CommonConstants.SOURCE_PROPERTY) == null) {
      resource.setProperty(CommonConstants.SOURCE_PROPERTY, CommonConstants.SOURCE_AUTO);
    }
    registry.put(actualPath, resource);
    addImportAssociations(actualPath);
    if (getCreateService()) {
      OMElement serviceElement =
          RESTServiceUtils.createRestServiceArtifact(
              wadlElement,
              wadlName,
              version,
              RegistryUtils.getRelativePath(requestContext.getRegistryContext(), actualPath));
      String servicePath = RESTServiceUtils.addServiceToRegistry(requestContext, serviceElement);
      registry.addAssociation(servicePath, actualPath, CommonConstants.DEPENDS);
      registry.addAssociation(actualPath, servicePath, CommonConstants.USED_BY);
      String endpointPath = createEndpointElement(requestContext, wadlElement, version);
      if (endpointPath != null) {
        registry.addAssociation(servicePath, endpointPath, CommonConstants.DEPENDS);
        registry.addAssociation(endpointPath, servicePath, CommonConstants.USED_BY);
      }
    }

    return resource.getPath();
  }