示例#1
0
 protected Optional<Build> lookupBuild(
     SVNLocation location, SVNLocation firstCopy, Branch branch) {
   // Gets the SVN configuration for the branch
   Property<SVNBranchConfigurationProperty> configurationProperty =
       propertyService.getProperty(branch, SVNBranchConfigurationPropertyType.class);
   if (configurationProperty.isEmpty()) {
     return Optional.empty();
   }
   // Gets the build link
   ConfiguredBuildSvnRevisionLink<Object> revisionLink =
       buildSvnRevisionLinkService.getConfiguredBuildSvnRevisionLink(
           configurationProperty.getValue().getBuildRevisionLink());
   // Gets the earliest build
   return revisionLink.getEarliestBuild(
       branch, location, firstCopy, configurationProperty.getValue());
 }
 private static void processElement(
     Object element,
     ClassLoader classLoader,
     Method putMethod,
     Object context,
     Method putByNameMethod)
     throws ClassNotFoundException, InstantiationException, InvocationTargetException,
         ConfigurationException, IllegalAccessException, IllegalArgumentException {
   if (element instanceof Component) {
     Component c = (Component) element;
     Class compClass = Class.forName(c.getClazz(), true, classLoader);
     String name = c.getName();
     Object instance = compClass.newInstance();
     for (Property p : c.getProperty()) {
       setPropertyOnComponent(instance, p.getName(), p.getValue());
       log.log(
           Level.FINER,
           MessageNames.SET_PROPERTY_ON_COMPONENT,
           new Object[] {p.getName(), c.getClazz(), c.getName(), p.getValue()});
     }
     if (name == null || name.trim().length() == 0) {
       putMethod.invoke(context, instance);
     } else {
       putByNameMethod.invoke(context, name, instance);
     }
   } else if (element instanceof Property) {
     Property p = (Property) element;
     putByNameMethod.invoke(context, p.getName(), p.getValue());
   } else if (element instanceof DiscoveryContextType) {
     /*
     Just drop the element into the context under the appropriate name.
     */
     DiscoveryContextType dct = (DiscoveryContextType) element;
     if (dct.getName() == null) {
       putByNameMethod.invoke(context, Strings.DEFAULT_DISCOVERY_CONTEXT, dct);
     } else {
       putByNameMethod.invoke(context, dct.getName(), dct);
     }
   } else {
     throw new ConfigurationException(
         MessageNames.UNSUPPORTED_ELEMENT, element.getClass().getName());
   }
 }
示例#3
0
  @Override
  public OntrackSVNRevisionInfo getOntrackRevisionInfo(SVNRepository repository, long revision) {

    // Gets information about the revision
    SVNRevisionInfo basicInfo = svnService.getRevisionInfo(repository, revision);
    SVNChangeLogRevision changeLogRevision =
        svnService.createChangeLogRevision(repository, basicInfo);

    // Gets the first copy event on this path after this revision
    SVNLocation firstCopy = svnService.getFirstCopyAfter(repository, basicInfo.toLocation());

    // Data to collect
    Collection<BuildView> buildViews = new ArrayList<>();
    Collection<BranchStatusView> branchStatusViews = new ArrayList<>();
    // Loops over all authorised branches
    for (Project project : structureService.getProjectList()) {
      // Filter on SVN configuration: must be present and equal to the one the revision info is
      // looked into
      Property<SVNProjectConfigurationProperty> projectSvnConfig =
          propertyService.getProperty(project, SVNProjectConfigurationPropertyType.class);
      if (!projectSvnConfig.isEmpty()
          && repository
              .getConfiguration()
              .getName()
              .equals(projectSvnConfig.getValue().getConfiguration().getName())) {
        for (Branch branch : structureService.getBranchesForProject(project.getId())) {
          // Filter on branch type
          // Filter on SVN configuration: must be present
          if (branch.getType() != BranchType.TEMPLATE_DEFINITION
              && propertyService.hasProperty(branch, SVNBranchConfigurationPropertyType.class)) {
            // Identifies a possible build given the path/revision and the first copy
            Optional<Build> build = lookupBuild(basicInfo.toLocation(), firstCopy, branch);
            // Build found
            if (build.isPresent()) {
              // Gets the build view
              BuildView buildView = structureService.getBuildView(build.get());
              // Adds it to the list
              buildViews.add(buildView);
              // Collects the promotions for the branch
              branchStatusViews.add(structureService.getEarliestPromotionsAfterBuild(build.get()));
            }
          }
        }
      }
    }

    // OK
    return new OntrackSVNRevisionInfo(
        repository.getConfiguration(), changeLogRevision, buildViews, branchStatusViews);
  }
示例#4
0
 protected void addPropertyInternal(Property property) {
   if (property.getKey() == null) {
     throw new IllegalArgumentException("key is required for property");
   }
   Object propertyValue = property.getValue();
   if (propertyValue instanceof PropertyValue && !((PropertyValue) propertyValue).isStore()) {
     return;
   }
   Property existingProperty =
       getProperty(property.getKey(), property.getName(), property.getVisibility());
   if (existingProperty == null) {
     this.properties.add(property);
   } else {
     if (existingProperty instanceof MutableProperty) {
       ((MutableProperty) existingProperty).update(property);
     } else {
       throw new VertexiumException(
           "Could not update property of type: " + existingProperty.getClass().getName());
     }
   }
 }