private void enqueueHealthAndNewTaskChecks() {
    final long start = System.currentTimeMillis();

    final List<SingularityTask> activeTasks = taskManager.getActiveTasks();
    final Map<SingularityTaskId, SingularityTask> activeTaskMap =
        Maps.uniqueIndex(activeTasks, SingularityTaskIdHolder.getTaskIdFunction());

    final Map<SingularityTaskId, List<SingularityTaskHistoryUpdate>> taskUpdates =
        taskManager.getTaskHistoryUpdates(activeTaskMap.keySet());

    final Map<SingularityDeployKey, SingularityPendingDeploy> pendingDeploys =
        Maps.uniqueIndex(
            deployManager.getPendingDeploys(), SingularityDeployKey.FROM_PENDING_TO_DEPLOY_KEY);
    final Map<String, SingularityRequestWithState> idToRequest =
        Maps.uniqueIndex(
            requestManager.getRequests(), SingularityRequestWithState.REQUEST_STATE_TO_REQUEST_ID);

    requestManager.getActiveRequests();
    int enqueuedNewTaskChecks = 0;
    int enqueuedHealthchecks = 0;

    for (Map.Entry<SingularityTaskId, SingularityTask> entry : activeTaskMap.entrySet()) {
      SingularityTaskId taskId = entry.getKey();
      SingularityTask task = entry.getValue();
      SimplifiedTaskState simplifiedTaskState =
          SingularityTaskHistoryUpdate.getCurrentState(taskUpdates.get(taskId));

      if (simplifiedTaskState != SimplifiedTaskState.DONE) {
        SingularityDeployKey deployKey =
            new SingularityDeployKey(taskId.getRequestId(), taskId.getDeployId());
        Optional<SingularityPendingDeploy> pendingDeploy =
            Optional.fromNullable(pendingDeploys.get(deployKey));
        Optional<SingularityRequestWithState> request =
            Optional.fromNullable(idToRequest.get(taskId.getRequestId()));

        if (!pendingDeploy.isPresent()) {
          newTaskChecker.enqueueNewTaskCheck(task, request, healthchecker);
          enqueuedNewTaskChecks++;
        }
        if (simplifiedTaskState == SimplifiedTaskState.RUNNING) {
          if (healthchecker.enqueueHealthcheck(task, pendingDeploy, request)) {
            enqueuedHealthchecks++;
          }
        }
      }
    }

    LOG.info(
        "Enqueued {} health checks and {} new task checks (out of {} active tasks) in {}",
        enqueuedHealthchecks,
        enqueuedNewTaskChecks,
        activeTasks.size(),
        JavaUtils.duration(start));
  }
Example #2
0
 private Map<String, MeasureDto> measuresByMetricKey(ComponentDto component, DbSession session) {
   MeasureQuery query =
       MeasureQuery.builder()
           .setComponentUuid(component.uuid())
           .setMetricKeys(METRIC_KEYS)
           .build();
   List<MeasureDto> measures = dbClient.measureDao().selectByQuery(session, query);
   Set<Integer> metricIds =
       measures.stream().map(MeasureDto::getMetricId).collect(Collectors.toSet());
   List<MetricDto> metrics = dbClient.metricDao().selectByIds(session, metricIds);
   Map<Integer, MetricDto> metricsById = Maps.uniqueIndex(metrics, MetricDto::getId);
   return Maps.uniqueIndex(measures, m -> metricsById.get(m.getMetricId()).getKey());
 }
  private Table<String, MetricDto, MeasureDto> searchMeasuresByComponentUuidAndMetric(
      DbSession dbSession,
      ComponentDto baseComponent,
      List<ComponentDto> components,
      List<MetricDto> metrics,
      List<WsMeasures.Period> periods,
      @Nullable Long developerId) {
    List<String> componentUuids = new ArrayList<>();
    componentUuids.add(baseComponent.uuid());
    components.stream().forEach(c -> componentUuids.add(c.uuid()));

    Map<Integer, MetricDto> metricsById = Maps.uniqueIndex(metrics, MetricDtoFunctions.toId());
    MeasureQuery measureQuery =
        MeasureQuery.builder()
            .setPersonId(developerId)
            .setComponentUuids(componentUuids)
            .setMetricIds(metricsById.keySet())
            .build();
    List<MeasureDto> measureDtos = dbClient.measureDao().selectByQuery(dbSession, measureQuery);

    Table<String, MetricDto, MeasureDto> measuresByComponentUuidAndMetric =
        HashBasedTable.create(components.size(), metrics.size());
    for (MeasureDto measureDto : measureDtos) {
      measuresByComponentUuidAndMetric.put(
          measureDto.getComponentUuid(), metricsById.get(measureDto.getMetricId()), measureDto);
    }

    addBestValuesToMeasures(measuresByComponentUuidAndMetric, components, metrics, periods);

    return measuresByComponentUuidAndMetric;
  }
Example #4
0
  public List<CashOutEntry> getBlingCashOutRequests() throws ServiceException {
    Map<Integer, CashOutInfo> blingMap = _moneyLogic.getBlingCashOutRequests();

    // Get all member names for the members in the map.
    final Map<Integer, MemberRecord> names =
        Maps.uniqueIndex(
            _memberRepo.loadMembers(blingMap.keySet()),
            new Function<MemberRecord, Integer>() {
              public Integer apply(MemberRecord record) {
                return record.memberId;
              }
            });

    // Get list of charities
    final List<CharityRecord> charities = _memberRepo.getCharities();

    // Transform the list into cash out entries.
    return Lists.newArrayList(
        Iterables.transform(
            blingMap.entrySet(),
            new Function<Map.Entry<Integer, CashOutInfo>, CashOutEntry>() {
              public CashOutEntry apply(Entry<Integer, CashOutInfo> entry) {
                MemberRecord member = names.get(entry.getKey());
                return new CashOutEntry(
                    entry.getKey(),
                    member.getName().getNormal(),
                    entry.getValue(),
                    member.accountName,
                    isCharity(member.memberId, charities));
              }
            }));
  }
  /**
   * Specifies how this resource maps to underlying resourcesIf the HostResource array contains any
   * entries, this property reflects how the resource maps to those specific resources.
   */
  public static enum MappingBehavior {
    UNKNOWN(0),
    NOT_SUPPORTED(2),
    DEDICATED(3),
    SOFT_AFFINITY(4),
    HARD_AFFINITY(5),
    DMTF_RESERVED(32767),
    VENDOR_RESERVED(65535);

    protected final int code;

    MappingBehavior(int code) {
      this.code = code;
    }

    public String value() {
      return code + "";
    }

    protected static final Map<Integer, MappingBehavior> MAPPING_BEHAVIOR_BY_ID =
        Maps.uniqueIndex(
            ImmutableSet.copyOf(MappingBehavior.values()),
            new Function<MappingBehavior, Integer>() {

              @Override
              public Integer apply(MappingBehavior input) {
                return input.code;
              }
            });

    public static MappingBehavior fromValue(String behavior) {
      return MAPPING_BEHAVIOR_BY_ID.get(new Integer(checkNotNull(behavior, "behavior")));
    }
  }
/**
 * This enum maps the commands for the <a href=
 * "http://dragonfly.opera.com/app/scope-interface/services/Exec/Exec_2_0.html" >Exec 2.0</a>.
 */
public enum ExecMessage implements Message {
  EXEC(1),
  GET_ACTION_LIST(2),
  SETUP_SCREEN_WATCHER(3),
  SEND_MOUSE_ACTION(5),
  DEFAULT(-1);

  private static final Map<Integer, ExecMessage> lookup =
      Maps.uniqueIndex(
          ImmutableList.copyOf(values()),
          new Function<ExecMessage, Integer>() {
            public Integer apply(ExecMessage message) {
              return message.getID();
            }
          });

  private final int code;

  private ExecMessage(int code) {
    this.code = code;
  }

  public int getID() {
    return code;
  }

  public String getServiceName() {
    return Exec.SERVICE_NAME;
  }

  public static ExecMessage get(int code) {
    ExecMessage message = lookup.get(code);
    return (message != null) ? message : DEFAULT;
  }
}
Example #7
0
  public static String printLogical(List<PlanFragment> fragments) {
    Map<PlanFragmentId, PlanFragment> fragmentsById =
        Maps.uniqueIndex(
            fragments,
            new Function<PlanFragment, PlanFragmentId>() {
              @Override
              public PlanFragmentId apply(PlanFragment input) {
                return input.getId();
              }
            });
    PlanNodeIdGenerator idGenerator = new PlanNodeIdGenerator();

    StringBuilder output = new StringBuilder();
    output.append("digraph logical_plan {\n");

    for (PlanFragment fragment : fragments) {
      printFragmentNodes(output, fragment, idGenerator);
    }

    for (PlanFragment fragment : fragments) {
      fragment.getRoot().accept(new EdgePrinter(output, fragmentsById, idGenerator), null);
    }

    output.append("}\n");

    return output.toString();
  }
  @Override
  public void setGroupMapping(Map<String, String> mapping) {
    Map<String, String> internal;
    if (mapping == null) {
      internal = Collections.emptyMap();
    } else {
      // we store ids internally but external users use the group names
      try {
        final Map<String, Role> nameToRole =
            Maps.uniqueIndex(roleService.loadAll(), Roles.roleToNameFunction());

        internal =
            Maps.newHashMap(
                Maps.transformValues(
                    mapping,
                    new Function<String, String>() {
                      @Nullable
                      @Override
                      public String apply(@Nullable String groupName) {
                        if (groupName == null || !nameToRole.containsKey(groupName)) {
                          return null;
                        }
                        return nameToRole.get(groupName).getId();
                      }
                    }));
      } catch (NotFoundException e) {
        LOG.error("Unable to convert group names to ids", e);
        throw new IllegalStateException("Unable to convert group names to ids", e);
      }
    }

    fields.put(GROUP_MAPPING, internal);
  }
 private void blockUntilRunningAndAssignElasticIpsToInstancesOrPutIntoBadMap(
     Set<RunningInstance> input, Map<NodeMetadata, Exception> badNodes) {
   Map<RegionAndName, RunningInstance> instancesById =
       Maps.uniqueIndex(input, instanceToRegionAndName);
   for (Map.Entry<RegionAndName, RunningInstance> entry : instancesById.entrySet()) {
     RegionAndName id = entry.getKey();
     RunningInstance instance = entry.getValue();
     try {
       logger.debug("<< allocating elastic IP instance(%s)", id);
       String ip = client.getElasticIPAddressServices().allocateAddressInRegion(id.getRegion());
       // block until instance is running
       logger.debug(">> awaiting status running instance(%s)", id);
       AtomicReference<NodeMetadata> node =
           newReference(runningInstanceToNodeMetadata.apply(instance));
       nodeRunning.apply(node);
       logger.trace("<< running instance(%s)", id);
       logger.debug(">> associating elastic IP %s to instance %s", ip, id);
       client
           .getElasticIPAddressServices()
           .associateAddressInRegion(id.getRegion(), ip, id.getName());
       logger.trace("<< associated elastic IP %s to instance %s", ip, id);
       // add mapping of instance to ip into the cache
       elasticIpCache.put(id, ip);
     } catch (RuntimeException e) {
       badNodes.put(runningInstanceToNodeMetadata.apply(instancesById.get(id)), e);
     }
   }
 }
  @Override
  public void setAdditionalDefaultGroups(Set<String> groupNames) {
    try {
      if (groupNames == null) return;

      final Map<String, Role> nameToRole =
          Maps.uniqueIndex(roleService.loadAll(), Roles.roleToNameFunction());
      final List<String> groupIds =
          Lists.newArrayList(
              Collections2.transform(
                  groupNames,
                  new Function<String, String>() {
                    @Nullable
                    @Override
                    public String apply(@Nullable String groupName) {
                      if (groupName == null || !nameToRole.containsKey(groupName)) {
                        return null;
                      }
                      return nameToRole.get(groupName).getId();
                    }
                  }));
      fields.put(ADDITIONAL_DEFAULT_GROUPS, groupIds);
    } catch (NotFoundException e) {
      LOG.error("Unable to convert group names to ids", e);
      throw new IllegalStateException("Unable to convert group names to ids", e);
    }
  }
Example #11
0
  private static String generateHelpText() {
    Map<Integer, String> details =
        Maps.transformValues(
            Maps.uniqueIndex(RESPONSE_CODES.values(), Pair::getFirst), Pair::getSecond);

    return "This endpoint can indicate to a load balancer which among a group of schedulers "
        + "is leading.\n\nThe response codes are:\n"
        + Joiner.on("\n").withKeyValueSeparator(": ").join(details);
  }
  public NetconfMessageTransformer(final SchemaContext schemaContext, final boolean strictParsing) {
    this.counter = new MessageCounter();
    this.schemaContext = schemaContext;
    parserFactory =
        DomToNormalizedNodeParserFactory.getInstance(
            XmlUtils.DEFAULT_XML_CODEC_PROVIDER, schemaContext, strictParsing);

    mappedRpcs = Maps.uniqueIndex(schemaContext.getOperations(), QNAME_FUNCTION);
    mappedNotifications = Multimaps.index(schemaContext.getNotifications(), QNAME_NOREV_FUNCTION);
  }
  @Override
  public Map<NamedKey, byte[]> getBulk(Iterable<NamedKey> keys) {
    try (ResourceHolder<MemcachedClientIF> clientHolder = client.get()) {
      Map<String, NamedKey> keyLookup =
          Maps.uniqueIndex(
              keys,
              new Function<NamedKey, String>() {
                @Override
                public String apply(@Nullable NamedKey input) {
                  return computeKeyHash(memcachedPrefix, input);
                }
              });

      Map<NamedKey, byte[]> results = Maps.newHashMap();

      BulkFuture<Map<String, Object>> future;
      try {
        future = clientHolder.get().asyncGetBulk(keyLookup.keySet());
      } catch (IllegalStateException e) {
        // operation did not get queued in time (queue is full)
        errorCount.incrementAndGet();
        log.warn(e, "Unable to queue cache operation");
        return results;
      }

      try {
        Map<String, Object> some = future.getSome(timeout, TimeUnit.MILLISECONDS);

        if (future.isTimeout()) {
          future.cancel(false);
          timeoutCount.incrementAndGet();
        }
        missCount.addAndGet(keyLookup.size() - some.size());
        hitCount.addAndGet(some.size());

        for (Map.Entry<String, Object> entry : some.entrySet()) {
          final NamedKey key = keyLookup.get(entry.getKey());
          final byte[] value = (byte[]) entry.getValue();
          if (value != null) {
            results.put(key, deserializeValue(key, value));
          }
        }

        return results;
      } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw Throwables.propagate(e);
      } catch (ExecutionException e) {
        errorCount.incrementAndGet();
        log.warn(e, "Exception pulling item from cache");
        return results;
      }
    }
  }
  @Test
  public void testFindAll() {
    // load users from db
    Map<String, User> resultMap = Maps.uniqueIndex(userRepository.findAll(), userName());

    assertThat(resultMap).hasSameSizeAs(userMap.values());

    // verify
    for (User user : userMap.values()) {
      assertThat(user).is(sameAsUser(resultMap.get(user.getUserName())));
    }
  }
  public void addConnectorSessionProperties(
      ConnectorId connectorId, List<PropertyMetadata<?>> properties) {
    requireNonNull(connectorId, "connectorId is null");
    requireNonNull(properties, "properties is null");

    Map<String, PropertyMetadata<?>> propertiesByName =
        Maps.uniqueIndex(properties, PropertyMetadata::getName);
    checkState(
        connectorSessionProperties.putIfAbsent(connectorId, propertiesByName) == null,
        "Session properties for connectorId '%s' are already registered",
        connectorId);
  }
  /**
   * Filters SchemaContext for yang modules
   *
   * @param delegate original SchemaContext
   * @param rootModules modules (yang schemas) to be available and all their dependencies (modules
   *     importing rootModule and whole chain of their imports)
   * @param additionalModuleIds (additional) modules (yang schemas) to be available and whole chain
   *     of their imports
   */
  public FilteringSchemaContextProxy(
      final SchemaContext delegate,
      final Collection<ModuleId> rootModules,
      final Set<ModuleId> additionalModuleIds) {

    Preconditions.checkArgument(rootModules != null, "Base modules cannot be null.");
    Preconditions.checkArgument(additionalModuleIds != null, "Additional modules cannot be null.");

    final Builder<Module> filteredModulesBuilder = new Builder<>();

    final SetMultimap<URI, Module> nsMap =
        Multimaps.newSetMultimap(new TreeMap<URI, Collection<Module>>(), MODULE_SET_SUPPLIER);
    final SetMultimap<String, Module> nameMap =
        Multimaps.newSetMultimap(new TreeMap<String, Collection<Module>>(), MODULE_SET_SUPPLIER);

    ImmutableMap.Builder<ModuleIdentifier, String> identifiersToSourcesBuilder =
        ImmutableMap.builder();

    // preparing map to get all modules with one name but difference in revision
    final TreeMultimap<String, Module> nameToModulesAll = getStringModuleTreeMultimap();

    nameToModulesAll.putAll(getStringModuleMap(delegate));

    // in case there is a particular dependancy to view filteredModules/yang models
    // dependancy is checked for module name and imports
    processForRootModules(delegate, rootModules, filteredModulesBuilder);

    // adding additional modules
    processForAdditionalModules(delegate, additionalModuleIds, filteredModulesBuilder);

    filteredModulesBuilder.addAll(
        getImportedModules(
            Maps.uniqueIndex(delegate.getModules(), ModuleId.MODULE_TO_MODULE_ID),
            filteredModulesBuilder.build(),
            nameToModulesAll));

    /**
     * Instead of doing this on each invocation of getModules(), pre-compute it once and keep it
     * around -- better than the set we got in.
     */
    this.filteredModules = filteredModulesBuilder.build();

    for (final Module module : filteredModules) {
      nameMap.put(module.getName(), module);
      nsMap.put(module.getNamespace(), module);
      identifiersToSourcesBuilder.put(module, module.getSource());
    }

    namespaceToModules = ImmutableSetMultimap.copyOf(nsMap);
    nameToModules = ImmutableSetMultimap.copyOf(nameMap);
    identifiersToSources = identifiersToSourcesBuilder.build();
  }
  @Override
  public Map<Integer, DataApprovalLevel> getDataApprovalLevelMap() {
    List<DataApprovalLevel> levels = dataApprovalLevelStore.getAllDataApprovalLevels();

    return Maps.uniqueIndex(
        levels,
        new Function<DataApprovalLevel, Integer>() {
          @Override
          public Integer apply(DataApprovalLevel level) {
            return level.getLevel();
          }
        });
  }
Example #18
0
  /**
   * Creates a new vocabulary backed by the given {@link Enum} class and with properties having the
   * common URI stem <code>base</code> and prefix <code>prefix</code>
   *
   * @param clazz the enumeration backing this vocabulary.
   * @param base the common stem URI of properties in this vocabulary.
   * @param prefix the common prefix of properties in this vocabulary.
   */
  public <T extends Enum<T>> EnumVocab(
      final Class<T> clazz, final String base, final String prefix) {
    this.index =
        ImmutableMap.copyOf(
            Maps.transformEntries(
                Maps.uniqueIndex(EnumSet.allOf(clazz), ENUM_TO_NAME),
                new EntryTransformer<String, T, Property>() {

                  @Override
                  public Property transformEntry(String name, T enumee) {
                    return Property.newFrom(name, base, prefix, enumee);
                  }
                }));
  }
Example #19
0
  public static String printDistributed(SubPlan plan) {
    List<PlanFragment> fragments = plan.getAllFragments();
    Map<PlanFragmentId, PlanFragment> fragmentsById =
        Maps.uniqueIndex(fragments, PlanFragment.idGetter());
    PlanNodeIdGenerator idGenerator = new PlanNodeIdGenerator();

    StringBuilder output = new StringBuilder();
    output.append("digraph distributed_plan {\n");

    printSubPlan(plan, fragmentsById, idGenerator, output);

    output.append("}\n");

    return output.toString();
  }
Example #20
0
  public void set(Collection<Comment> comments, Map<Long, Vote> votes, String op) {
    ImmutableMap<Long, Comment> byId = Maps.uniqueIndex(comments, Comment::getId);

    this.op = Optional.fromNullable(op);
    this.comments =
        FluentIterable.from(sort(comments, op))
            .transform(
                comment -> {
                  int depth = getCommentDepth(byId, comment);
                  Vote baseVote = firstNonNull(votes.get(comment.getId()), Vote.NEUTRAL);
                  return new CommentEntry(comment, baseVote, depth);
                })
            .toList();

    notifyDataSetChanged();
  }
  /** Describes the consumers visibility to the allocated resource. */
  public static enum ConsumerVisibility {
    UNKNOWN(0),
    /**
     * indicates the underlying or host resource is utilized and passed through to the consumer,
     * possibly using partitioning. At least one item shall be present in the HostResource property.
     */
    PASSED_THROUGH(2),
    /**
     * indicates the resource is virtualized and may not map directly to an underlying/host
     * resource. Some implementations may support specific assignment for virtualized resources, in
     * which case the host resource(s) are exposed using the HostResource property.
     */
    VIRTUALIZED(3),
    /**
     * indicates a representation of the resource does not exist within the context of the resource
     * consumer.
     */
    NOT_REPRESENTED(4),
    DMTF_RESERVED(32767),
    VENDOR_RESERVED(65535);

    protected final int code;

    ConsumerVisibility(int code) {
      this.code = code;
    }

    public String value() {
      return code + "";
    }

    protected static final Map<Integer, ConsumerVisibility> MAPPING_BEHAVIOR_BY_ID =
        Maps.uniqueIndex(
            ImmutableSet.copyOf(ConsumerVisibility.values()),
            new Function<ConsumerVisibility, Integer>() {

              @Override
              public Integer apply(ConsumerVisibility input) {
                return input.code;
              }
            });

    public static ConsumerVisibility fromValue(String behavior) {
      return MAPPING_BEHAVIOR_BY_ID.get(new Integer(checkNotNull(behavior, "behavior")));
    }
  }
  private Map<String, SourcedDeviceUpnp> convertToSourcedDimmableLightMap(
      Collection<SourcedDeviceUpnp> devices, Source source) {

    for (SourcedDeviceUpnp device : devices) {
      device.setSources(EnumSet.of(source));
    }
    return Maps.transformValues(
        Maps.uniqueIndex(
            devices,
            new Function<SourcedDeviceUpnp, String>() {
              @Override
              public String apply(SourcedDeviceUpnp device) {
                return device.getKey();
              }
            }),
        new SourcedDeviceUpnpConverterFunction(EnumSet.of(source)));
  }
Example #23
0
  public static InitAction create(
      File prideDirectory,
      RuntimeConfiguration globalConfig,
      VcsManager vcsManager,
      boolean force,
      boolean addExisting,
      boolean ignoreExistingConfig)
      throws Exception {
    boolean prideExistsAlready = Pride.containsPride(prideDirectory);
    if (prideExistsAlready && !force) {
      throw new PrideException("A pride already exists in " + prideDirectory);
    }

    Configuration existingPrideConfig = new BaseConfiguration();
    Map<String, Module> modulesFromExistingPrideConfig = Collections.emptyMap();

    if (prideExistsAlready && !ignoreExistingConfig) {
      try {
        Pride pride = Pride.getPride(prideDirectory, globalConfig, vcsManager);
        existingPrideConfig = pride.getLocalConfiguration();
        // Get existing modules
        if (addExisting) {
          modulesFromExistingPrideConfig =
              Maps.uniqueIndex(
                  pride.getModules(),
                  new Function<Module, String>() {
                    @Override
                    public String apply(Module module) {
                      return module.getName();
                    }
                  });
        }
      } catch (Exception ex) {
        logger.warn("Could not load existing pride, ignoring existing configuration");
        logger.debug("Exception was", ex);
      }
    }
    return new InitAction(
        prideDirectory,
        globalConfig,
        existingPrideConfig,
        vcsManager,
        modulesFromExistingPrideConfig,
        addExisting);
  }
  WorkflowSchemeBean asBean(AssignableWorkflowScheme parent, DraftWorkflowScheme child) {
    final WorkflowSchemeBean bean = new WorkflowSchemeBean();
    bean.setName(parent.getName());
    bean.setDescription(parent.getDescription());

    WorkflowScheme scheme = child != null ? child : parent;

    bean.setDefaultWorkflow(scheme.getConfiguredDefaultWorkflow());
    bean.setIssueTypeMappings(asIssueTypeMap(scheme));
    bean.setId(scheme.getId());
    bean.setDraft(scheme.isDraft());
    bean.setDefaultWorkflow(scheme.getActualDefaultWorkflow());

    final IssueTypeBeanBuilder builder =
        new IssueTypeBeanBuilder().context(info).jiraBaseUrls(jiraBaseUrls);
    bean.setIssueTypes(
        Maps.uniqueIndex(
            Collections2.transform(
                issueTypeManager.getIssueTypes(),
                new Function<IssueType, IssueTypeJsonBean>() {
                  @Override
                  public IssueTypeJsonBean apply(IssueType issueType) {
                    return builder.issueType(issueType).build();
                  }
                }),
            new Function<IssueTypeJsonBean, String>() {
              @Override
              public String apply(IssueTypeJsonBean issueType) {
                return issueType.getId();
              }
            }));

    if (child != null) {
      bean.setLastModifiedUser(beanForUser(child.getLastModifiedUser()));
      bean.setLastModified(formatter.forLoggedInUser().format(child.getLastModifiedDate()));
      bean.setOriginalIssueTypeMappings(asIssueTypeMap(parent));
      bean.setSelf(getUrlForParent(parent).path("draft").build());
      bean.setOriginalDefaultWorkflow(child.getParentScheme().getActualDefaultWorkflow());
    } else {
      bean.setSelf(getUrlForParent(parent).build());
    }

    return bean;
  }
Example #25
0
  /**
   * The primary loading code
   *
   * <p>The found resources are first loaded into the {@link #modClassLoader} (always) then scanned
   * for class resources matching the specification above.
   *
   * <p>If they provide the {@link Mod} annotation, they will be loaded as "FML mods"
   *
   * <p>Finally, if they are successfully loaded as classes, they are then added to the available
   * mod list.
   */
  private ModDiscoverer identifyMods() {
    FMLLog.fine("Building injected Mod Containers %s", injectedContainers);
    // Add in the MCP mod container
    mods.add(new InjectedModContainer(mcp, new File("minecraft.jar")));
    for (String cont : injectedContainers) {
      ModContainer mc;
      try {
        mc = (ModContainer) Class.forName(cont, true, modClassLoader).newInstance();
      } catch (Exception e) {
        FMLLog.log(
            Level.ERROR, e, "A problem occured instantiating the injected mod container %s", cont);
        throw new LoaderException(e);
      }
      mods.add(new InjectedModContainer(mc, mc.getSource()));
    }
    ModDiscoverer discoverer = new ModDiscoverer();
    FMLLog.fine(
        "Attempting to load mods contained in the minecraft jar file and associated classes");
    discoverer.findClasspathMods(modClassLoader);
    FMLLog.fine("Minecraft jar mods loaded successfully");

    FMLLog.getLogger()
        .log(
            Level.INFO,
            "Found {} mods from the command line. Injecting into mod discoverer",
            ModListHelper.additionalMods.size());
    FMLLog.info("Searching %s for mods", canonicalModsDir.getAbsolutePath());
    discoverer.findModDirMods(
        canonicalModsDir, ModListHelper.additionalMods.values().toArray(new File[0]));
    File versionSpecificModsDir = new File(canonicalModsDir, mccversion);
    if (versionSpecificModsDir.isDirectory()) {
      FMLLog.info("Also searching %s for mods", versionSpecificModsDir);
      discoverer.findModDirMods(versionSpecificModsDir);
    }

    mods.addAll(discoverer.identifyMods());
    identifyDuplicates(mods);
    namedMods = Maps.uniqueIndex(mods, new ModIdFunction());
    FMLLog.info(
        "Forge Mod Loader has identified %d mod%s to load",
        mods.size(), mods.size() != 1 ? "s" : "");
    return discoverer;
  }
Example #26
0
  public static enum Relationship {
    ABOUT("about"),
    TWITTER_AUDIENCE("twitter:audience"),
    TWITTER_AUDIENCE_RELATED("twitter:audience-related"),
    TWITTER_AUDIENCE_REALTIME("twitter:audience:realtime"),
    TRANSCRIPTION("transcription"),
    TRANSCRIPTION_SUBTITLES("transcription:subtitles"),
    TRANSCRIPTION_SUBTITLES_REALTIME("transcription:subtitles:realtime");
    private final String name;

    private Relationship(String name) {
      this.name = name;
    }

    @Override
    public String toString() {
      return name;
    }

    private static ImmutableSet<Relationship> ALL = ImmutableSet.copyOf(values());

    public static ImmutableSet<Relationship> all() {
      return ALL;
    }

    private static ImmutableMap<String, Optional<Relationship>> LOOKUP =
        ImmutableMap.copyOf(
            Maps.transformValues(
                Maps.uniqueIndex(all(), Functions.toStringFunction()),
                new Function<Relationship, Optional<Relationship>>() {
                  @Override
                  public Optional<Relationship> apply(@Nullable Relationship input) {
                    return Optional.fromNullable(input);
                  }
                }));

    public static Optional<Relationship> fromString(String relationship) {
      Optional<Relationship> possibleRelationship = LOOKUP.get(relationship);
      return possibleRelationship != null ? possibleRelationship : Optional.<Relationship>absent();
    }
  }
 @Test
 public void releasableReferenceManagers() {
   ImmutableMap<Class<? extends Annotation>, ReleasableReferenceManager> managers =
       Maps.uniqueIndex(
           component.managers(),
           new Function<ReleasableReferenceManager, Class<? extends Annotation>>() {
             @Override
             public Class<? extends Annotation> apply(
                 ReleasableReferenceManager releasableReferenceManager) {
               return releasableReferenceManager.scope();
             }
           });
   assertThat(managers)
       .containsEntry(ParentReleasableScope1.class, component.parentReleasableScope1Manager());
   assertThat(managers)
       .containsEntry(ParentReleasableScope2.class, component.parentReleasableScope2Manager());
   assertThat(managers)
       .containsEntry(ChildReleasableScope1.class, component.childReleasableScope1Manager());
   assertThat(managers)
       .containsEntry(ChildReleasableScope2.class, component.childReleasableScope2Manager());
   // Should contain a manager for ChildReleasableScope3 even though
   // @ForReleasableReferences(Scope5.class) isn't needed.
   assertThat(managers).containsKey(ChildReleasableScope3.class);
 }
Example #28
0
  @XmlType
  @XmlEnum(String.class)
  public static enum ImageType {
    @XmlEnumValue("iso")
    ISO("iso"),
    @XmlEnumValue("floppy")
    FLOPPY("floppy"),
    UNRECOGNIZED("unrecognized");

    public static final List<ImageType> ALL = ImmutableList.of(ISO, FLOPPY);

    protected final String stringValue;

    ImageType(String stringValue) {
      this.stringValue = stringValue;
    }

    public String value() {
      return stringValue;
    }

    protected static final Map<String, ImageType> STATUS_BY_ID =
        Maps.uniqueIndex(
            ImmutableSet.copyOf(ImageType.values()),
            new Function<ImageType, String>() {
              @Override
              public String apply(ImageType input) {
                return input.stringValue;
              }
            });

    public static ImageType fromValue(String value) {
      ImageType type = STATUS_BY_ID.get(checkNotNull(value, "stringValue"));
      return type == null ? UNRECOGNIZED : type;
    }
  }
  /**
   * 查询可供选择加入投放的宝贝
   *
   * @param userId
   * @param activityId
   * @param onSale
   * @param query
   * @param sellerCids
   * @param pageNum
   * @param pageSize
   * @return
   * @throws TaobaoAccessControlException
   * @throws TaobaoEnhancedApiException
   * @throws TaobaoSessionExpiredException
   */
  @NotNull
  public Page<PublishItem> paginateItems(
      Long userId,
      Long activityId,
      boolean onSale,
      String query,
      List<Long> sellerCids,
      int pageNum,
      int pageSize)
      throws TaobaoAccessControlException, TaobaoEnhancedApiException,
          TaobaoSessionExpiredException {

    Page<Item> itemPage;
    List<PublishItem> returnPublishItems = Lists.newArrayList();

    // 从淘宝 api 获取商品
    if (onSale) {
      itemPage =
          taobaoApiShopService.paginateOnSaleItems(
              userId,
              query,
              ITEM_FIELDS,
              sellerCids,
              pageNum,
              pageSize,
              true,
              null,
              "modified:asc");

    } else {
      itemPage =
          taobaoApiShopService.paginateInventoryItems(
              userId,
              query,
              ITEM_FIELDS,
              Lists.newArrayList(BANNER_FOR_SHELVED),
              sellerCids,
              pageNum,
              pageSize,
              true,
              "modified:asc");
    }

    List<Item> taobaoItems = itemPage.getItems();

    if (CollectionUtils.isEmpty(taobaoItems)) {
      return Page.create(
          itemPage.getTotalSize(), pageNum, pageSize, Lists.<PublishItem>newArrayList());
    }

    Map<Long, PosterRecommendPublishItem> indexMap = Maps.newHashMap();

    if (null != activityId) {
      // 获取已经加入投放的宝贝并且设置是否加入投放的标志位
      List<PosterRecommendPublishItem> posterRecommendPublishItems =
          posterRecommendPublishItemDAO.selectByUserIdAndActivityId(userId, activityId);

      indexMap =
          Maps.uniqueIndex(
              posterRecommendPublishItems,
              new Function<PosterRecommendPublishItem, Long>() {
                @Nullable
                @Override
                public Long apply(@Nullable PosterRecommendPublishItem input) {
                  return input.getItemNumIid();
                }
              });
    }

    for (Item item : taobaoItems) {
      PublishItem publishItem = new PublishItem();
      publishItem.setItem(item);

      if (indexMap.keySet().contains(item.getNumIid())) {
        publishItem.setPublishItemStatus(indexMap.get(item.getNumIid()).getStatus());
      } else {
        publishItem.setPublishItemStatus(PUBLISH_ITEM_STATUS_NOT_IN_DB);
      }
      returnPublishItems.add(publishItem);
    }
    return Page.create(itemPage.getTotalSize(), pageNum, pageSize, returnPublishItems);
  }
public class NetconfMessageTransformer implements MessageTransformer<NetconfMessage> {

  public static final String MESSAGE_ID_PREFIX = "m";

  private static final Logger LOG = LoggerFactory.getLogger(NetconfMessageTransformer.class);

  private static final Function<SchemaNode, QName> QNAME_FUNCTION =
      new Function<SchemaNode, QName>() {
        @Override
        public QName apply(final SchemaNode rpcDefinition) {
          return rpcDefinition.getQName();
        }
      };

  private static final Function<SchemaNode, QName> QNAME_NOREV_FUNCTION =
      new Function<SchemaNode, QName>() {
        @Override
        public QName apply(final SchemaNode notification) {
          return QNAME_FUNCTION.apply(notification).withoutRevision();
        }
      };
  private static final SchemaContext BASE_NETCONF_CTX;

  static {
    try {
      final ModuleInfoBackedContext moduleInfoBackedContext = ModuleInfoBackedContext.create();
      moduleInfoBackedContext.addModuleInfos(
          Lists.newArrayList(
              org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601
                  .$YangModuleInfoImpl.getInstance()));
      BASE_NETCONF_CTX = moduleInfoBackedContext.tryToCreateSchemaContext().get();
    } catch (final RuntimeException e) {
      LOG.error("Unable to prepare schema context for base netconf ops", e);
      throw new ExceptionInInitializerError(e);
    }
  }

  private static final Map<QName, RpcDefinition> MAPPED_BASE_RPCS =
      Maps.uniqueIndex(BASE_NETCONF_CTX.getOperations(), QNAME_FUNCTION);

  private final SchemaContext schemaContext;
  private final MessageCounter counter;
  private final Map<QName, RpcDefinition> mappedRpcs;
  private final Multimap<QName, NotificationDefinition> mappedNotifications;
  private final DomToNormalizedNodeParserFactory parserFactory;

  public NetconfMessageTransformer(final SchemaContext schemaContext, final boolean strictParsing) {
    this.counter = new MessageCounter();
    this.schemaContext = schemaContext;
    parserFactory =
        DomToNormalizedNodeParserFactory.getInstance(
            XmlUtils.DEFAULT_XML_CODEC_PROVIDER, schemaContext, strictParsing);

    mappedRpcs = Maps.uniqueIndex(schemaContext.getOperations(), QNAME_FUNCTION);
    mappedNotifications = Multimaps.index(schemaContext.getNotifications(), QNAME_NOREV_FUNCTION);
  }

  @Override
  public synchronized DOMNotification toNotification(final NetconfMessage message) {
    final Map.Entry<Date, XmlElement> stripped = stripNotification(message);
    final QName notificationNoRev;
    try {
      notificationNoRev =
          QName.create(stripped.getValue().getNamespace(), stripped.getValue().getName())
              .withoutRevision();
    } catch (final MissingNameSpaceException e) {
      throw new IllegalArgumentException(
          "Unable to parse notification " + message + ", cannot find namespace", e);
    }

    final Collection<NotificationDefinition> notificationDefinitions =
        mappedNotifications.get(notificationNoRev);
    Preconditions.checkArgument(
        notificationDefinitions.size() > 0,
        "Unable to parse notification %s, unknown notification. Available notifications: %s",
        notificationDefinitions,
        mappedNotifications.keySet());

    // FIXME if multiple revisions for same notifications are present, we should pick the most
    // recent. Or ?
    // We should probably just put the most recent notification versions into our map. We can expect
    // that the device sends the data according to the latest available revision of a model.
    final NotificationDefinition next = notificationDefinitions.iterator().next();

    // We wrap the notification as a container node in order to reuse the parsers and builders for
    // container node
    final ContainerSchemaNode notificationAsContainerSchemaNode =
        NetconfMessageTransformUtil.createSchemaForNotification(next);

    final Element element = stripped.getValue().getDomElement();
    final ContainerNode content;
    try {
      content =
          parserFactory
              .getContainerNodeParser()
              .parse(Collections.singleton(element), notificationAsContainerSchemaNode);
    } catch (IllegalArgumentException e) {
      throw new IllegalArgumentException(
          String.format("Failed to parse notification %s", element), e);
    }
    return new NetconfDeviceNotification(content, stripped.getKey());
  }

  private static final ThreadLocal<SimpleDateFormat> EVENT_TIME_FORMAT =
      new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected SimpleDateFormat initialValue() {

          final SimpleDateFormat withMillis =
              new SimpleDateFormat(NetconfNotification.RFC3339_DATE_FORMAT_WITH_MILLIS_BLUEPRINT);

          return new SimpleDateFormat(NetconfNotification.RFC3339_DATE_FORMAT_BLUEPRINT) {
            private static final long serialVersionUID = 1L;

            @Override
            public Date parse(final String source) throws ParseException {
              try {
                return super.parse(source);
              } catch (ParseException e) {
                // In case of failure, try to parse with milliseconds
                return withMillis.parse(source);
              }
            }
          };
        }

        @Override
        public void set(final SimpleDateFormat value) {
          throw new UnsupportedOperationException();
        }
      };

  // FIXME move somewhere to util
  private static Map.Entry<Date, XmlElement> stripNotification(final NetconfMessage message) {
    final XmlElement xmlElement = XmlElement.fromDomDocument(message.getDocument());
    final List<XmlElement> childElements = xmlElement.getChildElements();
    Preconditions.checkArgument(
        childElements.size() == 2, "Unable to parse notification %s, unexpected format", message);

    final XmlElement eventTimeElement;
    final XmlElement notificationElement;

    if (childElements.get(0).getName().equals(EVENT_TIME)) {
      eventTimeElement = childElements.get(0);
      notificationElement = childElements.get(1);
    } else if (childElements.get(1).getName().equals(EVENT_TIME)) {
      eventTimeElement = childElements.get(1);
      notificationElement = childElements.get(0);
    } else {
      throw new IllegalArgumentException(
          "Notification payload does not contain " + EVENT_TIME + " " + message);
    }

    try {
      return new AbstractMap.SimpleEntry<>(
          EVENT_TIME_FORMAT.get().parse(eventTimeElement.getTextContent()), notificationElement);
    } catch (DocumentedException e) {
      throw new IllegalArgumentException(
          "Notification payload does not contain " + EVENT_TIME + " " + message);
    } catch (ParseException e) {
      LOG.warn(
          "Unable to parse event time from {}. Setting time to {}",
          eventTimeElement,
          NetconfNotification.UNKNOWN_EVENT_TIME,
          e);
      return new AbstractMap.SimpleEntry<>(
          NetconfNotification.UNKNOWN_EVENT_TIME, notificationElement);
    }
  }

  @Override
  public NetconfMessage toRpcRequest(SchemaPath rpc, final NormalizedNode<?, ?> payload) {
    // In case no input for rpc is defined, we can simply construct the payload here
    final QName rpcQName = rpc.getLastComponent();
    Map<QName, RpcDefinition> currentMappedRpcs = mappedRpcs;

    // Determine whether a base netconf operation is being invoked and also check if the device
    // exposed model for base netconf
    // If no, use pre built base netconf operations model
    final boolean needToUseBaseCtx = mappedRpcs.get(rpcQName) == null && isBaseRpc(rpcQName);
    if (needToUseBaseCtx) {
      currentMappedRpcs = MAPPED_BASE_RPCS;
    }

    Preconditions.checkNotNull(
        currentMappedRpcs.get(rpcQName),
        "Unknown rpc %s, available rpcs: %s",
        rpcQName,
        currentMappedRpcs.keySet());
    if (currentMappedRpcs.get(rpcQName).getInput() == null) {
      return new NetconfMessage(
          prepareDomResultForRpcRequest(rpcQName).getNode().getOwnerDocument());
    }

    Preconditions.checkNotNull(
        payload, "Transforming an rpc with input: %s, payload cannot be null", rpcQName);
    Preconditions.checkArgument(
        payload instanceof ContainerNode,
        "Transforming an rpc with input: %s, payload has to be a container, but was: %s",
        rpcQName,
        payload);

    // Set the path to the input of rpc for the node stream writer
    rpc = rpc.createChild(QName.create(rpcQName, "input").intern());
    final DOMResult result = prepareDomResultForRpcRequest(rpcQName);

    try {
      // If the schema context for netconf device does not contain model for base netconf
      // operations, use default pre build context with just the base model
      // This way operations like lock/unlock are supported even if the source for base model was
      // not provided
      writeNormalizedRpc(
          ((ContainerNode) payload),
          result,
          rpc,
          needToUseBaseCtx ? BASE_NETCONF_CTX : schemaContext);
    } catch (final XMLStreamException | IOException | IllegalStateException e) {
      throw new IllegalStateException("Unable to serialize " + rpc, e);
    }

    final Document node = result.getNode().getOwnerDocument();

    return new NetconfMessage(node);
  }

  private static boolean isBaseRpc(final QName rpc) {
    return rpc.getNamespace().equals(NETCONF_URI);
  }

  private DOMResult prepareDomResultForRpcRequest(final QName rpcQName) {
    final Document document = XmlUtil.newDocument();
    final Element rpcNS =
        document.createElementNS(
            NETCONF_RPC_QNAME.getNamespace().toString(), NETCONF_RPC_QNAME.getLocalName());
    // set msg id
    rpcNS.setAttribute(
        NetconfMessageTransformUtil.MESSAGE_ID_ATTR, counter.getNewMessageId(MESSAGE_ID_PREFIX));
    final Element elementNS =
        document.createElementNS(rpcQName.getNamespace().toString(), rpcQName.getLocalName());
    rpcNS.appendChild(elementNS);
    document.appendChild(rpcNS);
    return new DOMResult(elementNS);
  }

  private static void writeNormalizedRpc(
      final ContainerNode normalized,
      final DOMResult result,
      final SchemaPath schemaPath,
      final SchemaContext baseNetconfCtx)
      throws IOException, XMLStreamException {
    final XMLStreamWriter writer =
        NetconfMessageTransformUtil.XML_FACTORY.createXMLStreamWriter(result);
    try {
      try (final NormalizedNodeStreamWriter normalizedNodeStreamWriter =
          XMLStreamNormalizedNodeStreamWriter.create(writer, baseNetconfCtx, schemaPath)) {
        try (final OrderedNormalizedNodeWriter normalizedNodeWriter =
            new OrderedNormalizedNodeWriter(
                normalizedNodeStreamWriter, baseNetconfCtx, schemaPath)) {
          Collection<DataContainerChild<?, ?>> value = normalized.getValue();
          normalizedNodeWriter.write(value);
          normalizedNodeWriter.flush();
        }
      }
    } finally {
      try {
        writer.close();
      } catch (final Exception e) {
        LOG.warn("Unable to close resource properly", e);
      }
    }
  }

  @Override
  public synchronized DOMRpcResult toRpcResult(final NetconfMessage message, final SchemaPath rpc) {
    final NormalizedNode<?, ?> normalizedNode;
    final QName rpcQName = rpc.getLastComponent();
    if (NetconfMessageTransformUtil.isDataRetrievalOperation(rpcQName)) {
      final Element xmlData = NetconfMessageTransformUtil.getDataSubtree(message.getDocument());
      final ContainerSchemaNode schemaForDataRead =
          NetconfMessageTransformUtil.createSchemaForDataRead(schemaContext);
      final ContainerNode dataNode;

      try {
        dataNode =
            parserFactory
                .getContainerNodeParser()
                .parse(Collections.singleton(xmlData), schemaForDataRead);
      } catch (IllegalArgumentException e) {
        throw new IllegalArgumentException(
            String.format("Failed to parse data response %s", xmlData), e);
      }

      normalizedNode =
          Builders.containerBuilder()
              .withNodeIdentifier(
                  new YangInstanceIdentifier.NodeIdentifier(
                      NetconfMessageTransformUtil.NETCONF_RPC_REPLY_QNAME))
              .withChild(dataNode)
              .build();
    } else {

      Map<QName, RpcDefinition> currentMappedRpcs = mappedRpcs;

      // Determine whether a base netconf operation is being invoked and also check if the device
      // exposed model for base netconf
      // If no, use pre built base netconf operations model
      final boolean needToUseBaseCtx = mappedRpcs.get(rpcQName) == null && isBaseRpc(rpcQName);
      if (needToUseBaseCtx) {
        currentMappedRpcs = MAPPED_BASE_RPCS;
      }

      final RpcDefinition rpcDefinition = currentMappedRpcs.get(rpcQName);
      Preconditions.checkArgument(
          rpcDefinition != null, "Unable to parse response of %s, the rpc is unknown", rpcQName);

      // In case no input for rpc is defined, we can simply construct the payload here
      if (rpcDefinition.getOutput() == null) {
        Preconditions.checkArgument(
            XmlElement.fromDomDocument(message.getDocument())
                .getOnlyChildElementWithSameNamespaceOptionally("ok")
                .isPresent(),
            "Unexpected content in response of rpc: %s, %s",
            rpcDefinition.getQName(),
            message);
        normalizedNode = null;
      } else {
        final Element element = message.getDocument().getDocumentElement();
        try {
          normalizedNode =
              parserFactory
                  .getContainerNodeParser()
                  .parse(Collections.singleton(element), rpcDefinition.getOutput());
        } catch (IllegalArgumentException e) {
          throw new IllegalArgumentException(
              String.format("Failed to parse RPC response %s", element), e);
        }
      }
    }
    return new DefaultDOMRpcResult(normalizedNode);
  }

  private static class NetconfDeviceNotification implements DOMNotification, DOMEvent {
    private final ContainerNode content;
    private final SchemaPath schemaPath;
    private final Date eventTime;

    NetconfDeviceNotification(final ContainerNode content, final Date eventTime) {
      this.content = content;
      this.eventTime = eventTime;
      this.schemaPath = toPath(content.getNodeType());
    }

    @Nonnull
    @Override
    public SchemaPath getType() {
      return schemaPath;
    }

    @Nonnull
    @Override
    public ContainerNode getBody() {
      return content;
    }

    @Override
    public Date getEventTime() {
      return eventTime;
    }
  }
}