/* package */ void updateDepGraphCells(Set<WebGridCell> newCells) {
Set<WebGridCell> currentCells = _depGraphGrids.keySet();
Set<WebGridCell> cellsToRemove = Sets.difference(currentCells, newCells);
Set<WebGridCell> cellsToAdd = Sets.difference(newCells, currentCells);
for (WebGridCell cell : cellsToRemove) {
_depGraphGrids.remove(cell);
}
for (WebGridCell cell : cellsToAdd) {
String gridName = getName() + ".depgraph-" + cell.getRowId() + "-" + cell.getColumnId();
OperationTimer timer = new OperationTimer(s_logger, "depgraph");
Pair<String, ValueSpecification> columnMappingPair =
getGridStructure()
.findCellSpecification(cell, getViewClient().getLatestCompiledViewDefinition());
s_logger.debug("includeDepGraph took {}", timer.finished());
// TODO should this ever happen? it is currently
if (columnMappingPair != null) {
PushWebViewDepGraphGrid grid =
new PushWebViewDepGraphGrid(
gridName,
getViewClient(),
getConverterCache(),
cell,
columnMappingPair.getFirst(),
columnMappingPair.getSecond());
_depGraphGrids.put(cell, grid);
}
}
}
private void updateGeneratedViews(
AbstractBuild<?, ?> build, BuildListener listener, Set<GeneratedView> freshViews)
throws IOException {
Set<GeneratedView> generatedViews =
extractGeneratedObjects(build.getProject(), GeneratedViewsAction.class);
Set<GeneratedView> added = Sets.difference(freshViews, generatedViews);
Set<GeneratedView> existing = Sets.intersection(generatedViews, freshViews);
Set<GeneratedView> removed = Sets.difference(generatedViews, freshViews);
logItems(listener, "Adding views", added);
logItems(listener, "Existing views", existing);
logItems(listener, "Removing views", removed);
// Delete views
if (removedViewAction == RemovedViewAction.DELETE) {
for (GeneratedView removedView : removed) {
String viewName = removedView.getName();
ItemGroup parent = getLookupStrategy().getParent(build.getProject(), viewName);
if (parent instanceof ViewGroup) {
View view = ((ViewGroup) parent).getView(FilenameUtils.getName(viewName));
if (view != null) {
((ViewGroup) parent).deleteView(view);
}
} else if (parent == null) {
LOGGER.log(Level.FINE, "Parent ViewGroup seems to have been already deleted");
} else {
LOGGER.log(Level.WARNING, format("Could not delete view within %s", parent.getClass()));
}
}
}
}
/**
* Helper to add srcs and deps Soy files to a SoyFileSet builder. Also does sanity checks.
*
* @param sfsBuilder The SoyFileSet builder to add to.
* @param inputPrefix The input path prefix to prepend to all the file paths.
* @param srcs The srcs from the --srcs flag. Exactly one of 'srcs' and 'args' must be nonempty.
* @param args The old-style srcs from the command line (that's how they were specified before we
* added the --srcs flag). Exactly one of 'srcs' and 'args' must be nonempty.
* @param deps The deps from the --deps flag, or empty list if not applicable.
* @param exitWithErrorFn A function that exits with an error message followed by a usage message.
*/
static void addSoyFilesToBuilder(
Builder sfsBuilder,
String inputPrefix,
Collection<String> srcs,
Collection<String> args,
Collection<String> deps,
Collection<String> indirectDeps,
Function<String, Void> exitWithErrorFn) {
if (srcs.isEmpty() && args.isEmpty()) {
exitWithErrorFn.apply("Must provide list of source Soy files (--srcs).");
}
if (!srcs.isEmpty() && !args.isEmpty()) {
exitWithErrorFn.apply(
"Found source Soy files from --srcs and from args (please use --srcs only).");
}
// Create Set versions of each of the arguments, and de-dupe. If something is included as
// multiple file kinds, we'll keep the strongest one; a file in both srcs and deps will be a
// src, and one in both deps and indirect_deps will be a dep.
// TODO(gboyer): Maybe stop supporting old style (srcs from command line args) at some point.
Set<String> srcsSet = ImmutableSet.<String>builder().addAll(srcs).addAll(args).build();
Set<String> depsSet = Sets.difference(ImmutableSet.copyOf(deps), srcsSet);
Set<String> indirectDepsSet =
Sets.difference(ImmutableSet.copyOf(indirectDeps), Sets.union(srcsSet, depsSet));
for (String src : srcsSet) {
sfsBuilder.addWithKind(new File(inputPrefix + src), SoyFileKind.SRC);
}
for (String dep : depsSet) {
sfsBuilder.addWithKind(new File(inputPrefix + dep), SoyFileKind.DEP);
}
for (String dep : indirectDepsSet) {
sfsBuilder.addWithKind(new File(inputPrefix + dep), SoyFileKind.INDIRECT_DEP);
}
}
private void refresh() throws KeeperException, InterruptedException {
List<RepositoryModelEvent> events = new ArrayList<RepositoryModelEvent>();
synchronized (reposLock) {
Map<String, RepositoryDefinition> newRepos = loadRepositories(true);
// Find out changes in repositories
Set<String> removedRepos = Sets.difference(repos.keySet(), newRepos.keySet());
for (String id : removedRepos) {
events.add(new RepositoryModelEvent(RepositoryModelEventType.REPOSITORY_REMOVED, id));
}
Set<String> addedRepos = Sets.difference(newRepos.keySet(), repos.keySet());
for (String id : addedRepos) {
events.add(new RepositoryModelEvent(RepositoryModelEventType.REPOSITORY_ADDED, id));
}
for (RepositoryDefinition repoDef : newRepos.values()) {
if (repos.containsKey(repoDef.getName()) && !repos.get(repoDef.getName()).equals(repoDef)) {
events.add(
new RepositoryModelEvent(
RepositoryModelEventType.REPOSITORY_UPDATED, repoDef.getName()));
}
}
repos = newRepos;
}
notifyListeners(events);
}
/**
* Verify that a plan meets the basic sanity checks. E.g., every producer should have a consumer.
* Only producers that support multiple consumers (LocalMultiwayProducer, EOSController) can have
* multiple consumers.
*
* @see #assignWorkersToFragments(List, ConstructArgs)
* @param fragments the fragments of the plan
*/
public static void sanityCheckEdges(final List<PlanFragmentEncoding> fragments) {
/* These maps connect each channel id to the fragment that produces or consumes it. */
// producers must be unique
Map<Integer, PlanFragmentEncoding> producerMap = Maps.newHashMap();
// consumers can be repeated, as long as the producer is a LocalMultiwayProducer
Multimap<Integer, PlanFragmentEncoding> consumerMap = ArrayListMultimap.create();
final Set<Integer> soleConsumer = Sets.newHashSet();
for (PlanFragmentEncoding fragment : fragments) {
for (OperatorEncoding<?> operator : fragment.operators) {
/* Build the producer/consumer map. */
if (operator instanceof AbstractConsumerEncoding) {
AbstractConsumerEncoding<?> consumer = (AbstractConsumerEncoding<?>) operator;
consumerMap.put(consumer.argOperatorId, fragment);
} else if (operator instanceof AbstractProducerEncoding
|| operator instanceof IDBControllerEncoding) {
Integer opId = operator.opId;
PlanFragmentEncoding oldFragment = producerMap.put(opId, fragment);
if (oldFragment != null) {
Preconditions.checkArgument(
false,
"Two different operators cannot produce the same opId %s. Fragments: %s %s",
opId,
fragment.fragmentIndex,
oldFragment.fragmentIndex);
}
if (!(operator instanceof LocalMultiwayProducerEncoding
|| operator instanceof EOSControllerEncoding)) {
soleConsumer.add(opId);
}
}
}
}
/* Sanity check 1: Producer must have corresponding consumers, and vice versa. */
Set<Integer> consumedNotProduced = Sets.difference(consumerMap.keySet(), producerMap.keySet());
Preconditions.checkArgument(
consumedNotProduced.isEmpty(),
"Missing producer(s) for consumer(s): %s",
consumedNotProduced);
Set<Integer> producedNotConsumed = Sets.difference(producerMap.keySet(), consumerMap.keySet());
Preconditions.checkArgument(
producedNotConsumed.isEmpty(),
"Missing consumer(s) for producer(s): %s",
producedNotConsumed);
/* Sanity check 2: Operators that only admit a single consumer should have exactly one consumer. */
for (Integer opId : soleConsumer) {
Collection<PlanFragmentEncoding> consumers = consumerMap.get(opId);
Preconditions.checkArgument(
consumers.size() == 1,
"Producer %s only supports a single consumer, not %s",
opId,
consumers.size());
}
}
public static void assertSuitesEqual(Test suite1, Test suite2) {
Set<Class<?>> caseClasses1 = Sets.newLinkedHashSet(collectCaseClasses(suite1));
Set<Class<?>> caseClasses2 = Sets.newLinkedHashSet(collectCaseClasses(suite2));
assertTrue(
"New tests not found in old suite:\n" + Sets.difference(caseClasses2, caseClasses1),
caseClasses1.containsAll(caseClasses2));
assertTrue(
"Old tests not found in new suite:\n" + Sets.difference(caseClasses1, caseClasses2),
caseClasses2.containsAll(caseClasses1));
}
private Iterable<Object> saveAndDeleteFiles(
JSONArray oldFiles, JSONArray newFiles, String entityPath) {
Iterable<Object> toDelete =
Sets.difference(Sets.newHashSet(oldFiles), Sets.newHashSet(newFiles));
Iterable<Object> toSave = Sets.difference(Sets.newHashSet(newFiles), Sets.newHashSet(oldFiles));
toDelete.forEach(file -> fileStoreService.delete(((LinkedHashMap) file).get("id").toString()));
saveFiles(toSave, entityPath);
return toDelete;
}
@Override
public void process(TransactionBase tx, Bytes row, Column col) throws Exception {
TypedTransactionBase ttx = FluoConstants.TYPEL.wrap(tx);
String nextJson = ttx.get().row(row).col(FluoConstants.PAGE_NEW_COL).toString("");
if (nextJson.isEmpty()) {
log.error("An empty page was set at row {} col {}", row.toString(), col.toString());
return;
}
Gson gson = new Gson();
Page nextPage;
if (nextJson.equals("delete")) {
ttx.mutate().row(row).col(FluoConstants.PAGE_CUR_COL).delete();
nextPage = Page.EMPTY;
} else {
ttx.mutate().row(row).col(FluoConstants.PAGE_CUR_COL).set(nextJson);
nextPage = gson.fromJson(nextJson, Page.class);
}
String curJson = ttx.get().row(row).col(FluoConstants.PAGE_CUR_COL).toString("");
Set<Page.Link> curLinks = Collections.emptySet();
if (!curJson.isEmpty()) {
Page curPage = gson.fromJson(curJson, Page.class);
curLinks = curPage.getOutboundLinks();
} else {
Long score = ttx.get().row(row).col(FluoConstants.PAGE_SCORE_COL).toLong(0);
ttx.mutate().row(row).col(FluoConstants.PAGE_SCORE_COL).set(score + 1);
}
Set<Page.Link> nextLinks = nextPage.getOutboundLinks();
String pageUri = row.toString().substring(2);
Sets.SetView<Page.Link> addLinks = Sets.difference(nextLinks, curLinks);
for (Page.Link link : addLinks) {
String r = "p:" + link.getUri();
ttx.mutate()
.row(r)
.fam(FluoConstants.INLINKS_UPDATE)
.qual(pageUri)
.set("add," + link.getAnchorText());
ttx.mutate().row(r).col(FluoConstants.INLINKS_CHG_NTFY).weaklyNotify();
}
Sets.SetView<Page.Link> delLinks = Sets.difference(curLinks, nextLinks);
for (Page.Link link : delLinks) {
String r = "p:" + link.getUri();
ttx.mutate().row(r).fam(FluoConstants.INLINKS_UPDATE).qual(pageUri).set("del");
ttx.mutate().row(r).col(FluoConstants.INLINKS_CHG_NTFY).weaklyNotify();
}
// clean up
ttx.mutate().row(row).col(FluoConstants.PAGE_NEW_COL).delete();
}
private void updateGeneratedConfigFiles(
AbstractBuild<?, ?> build,
BuildListener listener,
Set<GeneratedConfigFile> freshConfigFiles) {
Set<GeneratedConfigFile> generatedConfigFiles =
extractGeneratedObjects(build.getProject(), GeneratedConfigFilesAction.class);
Set<GeneratedConfigFile> added = Sets.difference(freshConfigFiles, generatedConfigFiles);
Set<GeneratedConfigFile> existing = Sets.intersection(generatedConfigFiles, freshConfigFiles);
Set<GeneratedConfigFile> removed = Sets.difference(generatedConfigFiles, freshConfigFiles);
logItems(listener, "Adding config files", added);
logItems(listener, "Existing config files", existing);
logItems(listener, "Removing config files", removed);
}
private void updateGeneratedUserContents(
AbstractBuild<?, ?> build,
BuildListener listener,
Set<GeneratedUserContent> freshUserContents) {
Set<GeneratedUserContent> generatedUserContents =
extractGeneratedObjects(build.getProject(), GeneratedUserContentsAction.class);
Set<GeneratedUserContent> added = Sets.difference(freshUserContents, generatedUserContents);
Set<GeneratedUserContent> existing =
Sets.intersection(generatedUserContents, freshUserContents);
Set<GeneratedUserContent> removed = Sets.difference(generatedUserContents, freshUserContents);
logItems(listener, "Adding user content", added);
logItems(listener, "Existing user content", existing);
logItems(listener, "Removing user content", removed);
}
/**
* Flushes the rest of the UnManagedProtectionSet changes to the database and cleans up (i.e.,
* removes) any UnManagedProtectionSets that no longer exist on the RecoverPoint device, but are
* still in the database.
*
* @param protectionSystem the ProtectionSystem to clean up
* @param dbClient a reference to the database client
*/
private void cleanUp(ProtectionSystem protectionSystem, DbClient dbClient) {
// flush all remaining changes to the database
handlePersistence(dbClient, true);
// remove any UnManagedProtectionSets found in the database
// but no longer found on the RecoverPoint device
Set<URI> umpsetsFoundInDbForProtectionSystem =
DiscoveryUtils.getAllUnManagedProtectionSetsForSystem(
dbClient, protectionSystem.getId().toString());
SetView<URI> onlyFoundInDb =
Sets.difference(umpsetsFoundInDbForProtectionSystem, unManagedCGsReturnedFromProvider);
if (onlyFoundInDb != null && !onlyFoundInDb.isEmpty()) {
Iterator<UnManagedProtectionSet> umpsesToDelete =
dbClient.queryIterativeObjects(UnManagedProtectionSet.class, onlyFoundInDb, true);
while (umpsesToDelete.hasNext()) {
UnManagedProtectionSet umps = umpsesToDelete.next();
log.info(
"Deleting orphaned UnManagedProtectionSet {} no longer found on RecoverPoint device.",
umps.getNativeGuid());
dbClient.markForDeletion(umps);
}
}
// reset all tracking collections
unManagedCGsInsert = null;
unManagedCGsUpdate = null;
unManagedVolumesToDelete = null;
unManagedVolumesToUpdateByWwn = null;
unManagedCGsReturnedFromProvider = null;
}
private static void mergeConfigMaps(
final Map<String, String> source, final HashMap<String, String> destination) {
checkNotNull(source, "source");
checkNotNull(destination, "destination");
if (source.isEmpty()) {
return;
}
final Sets.SetView<String> sharedKeys =
Sets.intersection(source.keySet(), destination.keySet());
final Sets.SetView<String> newKeys = Sets.difference(source.keySet(), destination.keySet());
// skip empty values in the source map
// if they are already in the destination in order to
// prevent overwrites of populated keys with empty ones
sharedKeys
.stream()
.filter(key -> !source.get(key).trim().isEmpty() && !key.startsWith("#"))
.forEach(key -> destination.put(key, source.get(key)));
// Add new keys regardless of whether or not they're empty
newKeys
.stream()
.filter(key -> !key.startsWith("#"))
.forEach(key -> destination.put(key, source.get(key).trim()));
}
/**
* @return Pair of dep-file rule key and the members of possibleDepFileSourcePaths that actually
* appeared in the dep file
* @throws IOException
*/
public Optional<Pair<RuleKey, ImmutableSet<SourcePath>>> build(
Optional<ImmutableSet<SourcePath>> possibleDepFileSourcePaths) throws IOException {
ImmutableSet<SourcePath> inputs = builder.getInputsSoFar();
ImmutableSet<SourcePath> depFileInputs = inputs;
if (possibleDepFileSourcePaths.isPresent()) {
// possibleDepFileSourcePaths is an ImmutableSortedSet which implements contains() via
// binary search rather than via hashing. Thus taking the intersection/difference
// is O(n*log(n)). Here, we make a hash-based copy of the set, so that intersection
// will be reduced to O(N).
ImmutableSet<SourcePath> possibleDepFileSourcePathsUnsorted =
ImmutableSet.copyOf(possibleDepFileSourcePaths.get());
Sets.SetView<SourcePath> nonDepFileInputs =
Sets.difference(inputs, possibleDepFileSourcePathsUnsorted);
builder.addToRuleKey(nonDepFileInputs);
depFileInputs =
ImmutableSet.copyOf(Sets.intersection(inputs, possibleDepFileSourcePathsUnsorted));
}
Optional<RuleKey> ruleKey = builder.build();
if (ruleKey.isPresent()) {
return Optional.of(new Pair<>(ruleKey.get(), depFileInputs));
} else {
return Optional.empty();
}
}
/**
* Verifies that the the set of windows that have any state stored is exactly {@code
* expectedWindows} and that each of these windows has only tags from {@code allowedTags}.
*/
private void assertHasOnlyGlobalAndAllowedTags(
Set<W> expectedWindows, Set<StateTag<?>> allowedTags) {
runner.persist();
Set<StateNamespace> expectedWindowsSet = new HashSet<>();
for (W expectedWindow : expectedWindows) {
expectedWindowsSet.add(windowNamespace(expectedWindow));
}
Set<StateNamespace> actualWindows = new HashSet<>();
for (StateNamespace namespace : stubContexts.state.getNamespacesInUse()) {
if (namespace instanceof StateNamespaces.GlobalNamespace) {
continue;
} else if (namespace instanceof StateNamespaces.WindowNamespace) {
Set<StateTag<?>> tagsInUse = stubContexts.state.getTagsInUse(namespace);
if (tagsInUse.isEmpty()) {
continue;
}
actualWindows.add(namespace);
Set<StateTag<?>> unexpected = Sets.difference(tagsInUse, allowedTags);
if (unexpected.isEmpty()) {
continue;
} else {
fail(namespace + " has unexpected states: " + tagsInUse);
}
} else if (namespace instanceof StateNamespaces.WindowAndTriggerNamespace) {
Set<StateTag<?>> tagsInUse = stubContexts.state.getTagsInUse(namespace);
assertTrue(namespace + " contains " + tagsInUse, tagsInUse.isEmpty());
} else {
fail("Unrecognized namespace " + namespace);
}
}
assertEquals(expectedWindowsSet, actualWindows);
}
/**
* This method cleans up UnManaged Volumes in DB, which had been deleted manually from the Array
* 1. Get All UnManagedVolumes from DB 2. Store URIs of unmanaged volumes returned from the
* Provider in unManagedVolumesBookKeepingList. 3. If unmanaged volume is found only in DB, but
* not in unManagedVolumesBookKeepingList, then set unmanaged volume to inactive.
*
* <p>DB | Provider
*
* <p>x,y,z | y,z.a [a --> new entry has been added but indexes didn't get added yet into DB]
*
* <p>x--> will be set to inactive
*
* @param storagePoolUri
* @throws IOException
*/
private void performStorageUnManagedVolumeBookKeeping(URI storagePoolUri) throws IOException {
@SuppressWarnings("deprecation")
List<URI> unManagedVolumesInDB =
_dbClient.queryByConstraint(
ContainmentConstraint.Factory.getPoolUnManagedVolumeConstraint(storagePoolUri));
Set<URI> unManagedVolumesInDBSet = new HashSet<URI>(unManagedVolumesInDB);
SetView<URI> onlyAvailableinDB =
Sets.difference(unManagedVolumesInDBSet, unManagedVolumesReturnedFromProvider);
_logger.info("Diff :" + Joiner.on("\t").join(onlyAvailableinDB));
if (onlyAvailableinDB.size() > 0) {
List<UnManagedVolume> unManagedVolumeTobeDeleted = new ArrayList<UnManagedVolume>();
Iterator<UnManagedVolume> unManagedVolumes =
_dbClient.queryIterativeObjects(
UnManagedVolume.class, new ArrayList<URI>(onlyAvailableinDB));
while (unManagedVolumes.hasNext()) {
UnManagedVolume volume = unManagedVolumes.next();
if (null == volume || volume.getInactive()) {
continue;
}
_logger.info("Setting unManagedVolume {} inactive", volume.getId());
volume.setStoragePoolUri(NullColumnValueGetter.getNullURI());
volume.setStorageSystemUri(NullColumnValueGetter.getNullURI());
volume.setInactive(true);
unManagedVolumeTobeDeleted.add(volume);
}
if (unManagedVolumeTobeDeleted.size() > 0) {
_partitionManager.updateAndReIndexInBatches(
unManagedVolumeTobeDeleted, 1000, _dbClient, "UnManagedVolume");
}
}
}
private void backupFlowEntries(NodeId nodeId, Set<DeviceId> deviceIds) {
if (deviceIds.isEmpty()) {
return;
}
log.debug("Sending flowEntries for devices {} to {} as backup.", deviceIds, nodeId);
Map<DeviceId, Map<FlowId, Set<StoredFlowEntry>>> deviceFlowEntries = Maps.newConcurrentMap();
deviceIds.forEach(id -> deviceFlowEntries.put(id, ImmutableMap.copyOf(getFlowTable(id))));
clusterCommunicator
.<Map<DeviceId, Map<FlowId, Set<StoredFlowEntry>>>, Set<DeviceId>>sendAndReceive(
deviceFlowEntries, FLOW_TABLE_BACKUP, SERIALIZER::encode, SERIALIZER::decode, nodeId)
.whenComplete(
(backedupDevices, error) -> {
Set<DeviceId> devicesNotBackedup =
error != null
? deviceFlowEntries.keySet()
: Sets.difference(deviceFlowEntries.keySet(), backedupDevices);
if (devicesNotBackedup.size() > 0) {
log.warn(
"Failed to backup devices: {}. Reason: {}",
devicesNotBackedup,
error.getMessage());
}
if (backedupDevices != null) {
backedupDevices.forEach(
id -> {
lastBackupTimes.put(id, System.currentTimeMillis());
lastBackupNodes.put(id, nodeId);
});
}
});
}
private void addNewTags(Set<Tag> newTags, Set<Tag> orginalTags) {
SetView<Tag> addedTags = Sets.difference(newTags, orginalTags);
logger.debug("addedTags size : {}", addedTags.size());
for (Tag tag : addedTags) {
tag.tagged();
}
}
private void setMarketDataSubscriptions(final Set<ValueRequirement> requiredSubscriptions) {
final Set<ValueRequirement> currentSubscriptions = _marketDataSubscriptions;
final Set<ValueRequirement> unusedMarketData =
Sets.difference(currentSubscriptions, requiredSubscriptions);
if (!unusedMarketData.isEmpty()) {
s_logger.debug(
"{} unused market data subscriptions: {}", unusedMarketData.size(), unusedMarketData);
removeMarketDataSubscriptions(new ArrayList<ValueRequirement>(unusedMarketData));
}
final Set<ValueRequirement> newMarketData =
Sets.difference(requiredSubscriptions, currentSubscriptions);
if (!newMarketData.isEmpty()) {
s_logger.debug("{} new market data requirements: {}", newMarketData.size(), newMarketData);
addMarketDataSubscriptions(new HashSet<ValueRequirement>(newMarketData));
}
}
private ImmutableSet<AspectWithParameters> requiredAspects(
AspectDefinition aspectDefinition,
AspectParameters aspectParameters,
Attribute attribute,
Target target,
Rule originalRule) {
if (!(target instanceof Rule)) {
return ImmutableSet.of();
}
Set<AspectWithParameters> aspectCandidates =
extractAspectCandidates(aspectDefinition, aspectParameters, attribute, originalRule);
RuleClass ruleClass = ((Rule) target).getRuleClassObject();
ImmutableSet.Builder<AspectWithParameters> result = ImmutableSet.builder();
for (AspectWithParameters candidateClass : aspectCandidates) {
ConfiguredAspectFactory candidate =
(ConfiguredAspectFactory) AspectFactory.Util.create(candidateClass.getAspectFactory());
if (Sets.difference(
candidate.getDefinition().getRequiredProviders(), ruleClass.getAdvertisedProviders())
.isEmpty()) {
result.add(candidateClass);
}
}
return result.build();
}
private void installSecondaryDexFiles() throws Exception {
final ImmutableMap<String, Path> hashToSources = getRequiredDexFiles();
final ImmutableSet<String> requiredHashes = hashToSources.keySet();
final ImmutableSet<String> presentHashes = prepareSecondaryDexDir(requiredHashes);
final Set<String> hashesToInstall = Sets.difference(requiredHashes, presentHashes);
Map<String, Path> filesToInstallByHash =
Maps.filterKeys(hashToSources, Predicates.in(hashesToInstall));
// This is a bit gross. It was a late addition. Ideally, we could eliminate this, but
// it wouldn't be terrible if we don't. We store the dexed jars on the device
// with the full SHA-1 hashes in their names. This is the format that the loader uses
// internally, so ideally we would just load them in place. However, the code currently
// expects to be able to copy the jars from a directory that matches the name in the
// metadata file, like "secondary-1.dex.jar". We don't want to give up putting the
// hashes in the file names (because we use that to skip re-uploads), so just hack
// the metadata file to have hash-like names.
String metadataContents =
com.google.common.io.Files.toString(
projectFilesystem
.resolve(exopackageInfo.getDexInfo().get().getMetadata())
.toFile(),
Charsets.UTF_8)
.replaceAll(
"secondary-(\\d+)\\.dex\\.jar (\\p{XDigit}{40}) ", "secondary-$2.dex.jar $2 ");
installFiles(
"secondary_dex",
ImmutableMap.copyOf(filesToInstallByHash),
metadataContents,
"secondary-%s.dex.jar",
SECONDARY_DEX_DIR);
}
protected Set<Plugin> loadPlugins(String pluginPath) {
final File pluginDir = new File(pluginPath);
final Set<Plugin> plugins = new HashSet<>();
final PluginLoader pluginLoader = new PluginLoader(pluginDir);
for (Plugin plugin : pluginLoader.loadPlugins()) {
final PluginMetaData metadata = plugin.metadata();
if (capabilities().containsAll(metadata.getRequiredCapabilities())) {
if (version.sameOrHigher(metadata.getRequiredVersion())) {
plugins.add(plugin);
} else {
LOG.error(
"Plugin \""
+ metadata.getName()
+ "\" requires version "
+ metadata.getRequiredVersion()
+ " - not loading!");
}
} else {
LOG.debug(
"Skipping plugin \"{}\" because some capabilities are missing ({}).",
metadata.getName(),
Sets.difference(plugin.metadata().getRequiredCapabilities(), capabilities()));
}
}
LOG.info("Loaded plugins: " + plugins);
return plugins;
}
public static void assertOldTestsInNewSuite(Test oldSuite, Test newSuite) {
Set<Class<?>> caseClasses1 = Sets.newLinkedHashSet(collectCaseClasses(oldSuite));
Set<Class<?>> caseClasses2 = Sets.newLinkedHashSet(collectCaseClasses(newSuite));
assertTrue(
"Old tests not found in new suite:\n" + Sets.difference(caseClasses1, caseClasses2),
caseClasses2.containsAll(caseClasses1));
}
private void removeTags(Set<Tag> newTags, Set<Tag> orginalTags) {
SetView<Tag> removedTags = Sets.difference(orginalTags, newTags);
logger.debug("removedTags size : {}", removedTags.size());
for (Tag tag : removedTags) {
tag.deTagged();
}
}
public static String translateImplication(
SymbolicConstraint leftHandSide, SymbolicConstraint rightHandSide) {
KILtoSMTLib leftTransformer = new KILtoSMTLib(true);
KILtoSMTLib rightTransformer = new KILtoSMTLib(false);
String leftExpression = ((SMTLibTerm) leftHandSide.accept(leftTransformer)).expression();
String rightExpression = ((SMTLibTerm) rightHandSide.accept(rightTransformer)).expression();
StringBuilder sb = new StringBuilder();
sb.append(
getSortAndFunctionDeclarations(
leftHandSide.termContext().definition(),
Sets.union(leftTransformer.variables(), rightTransformer.variables())));
sb.append(getAxioms(leftHandSide.termContext().definition()));
sb.append(getConstantDeclarations(leftTransformer.variables()));
sb.append("(assert (and ");
sb.append(leftExpression);
sb.append(" (not ");
Set<Variable> rightHandSideOnlyVariables =
Sets.difference(rightTransformer.variables(), leftTransformer.variables());
if (!rightHandSideOnlyVariables.isEmpty()) {
sb.append("(exists (");
sb.append(getQuantifiedVariables(rightHandSideOnlyVariables));
sb.append(") ");
}
sb.append(rightExpression);
if (!rightHandSideOnlyVariables.isEmpty()) {
sb.append(")");
}
sb.append(")))");
return sb.toString();
}
@Test
public void ensureRecordsTest() {
int empId = 11303;
List<PayPeriod> payPeriods =
periodService.getOpenPayPeriods(PayPeriodType.AF, empId, SortOrder.ASC);
// Print existing records
Set<TimeRecord> existingRecords =
timeRecordService
.getTimeRecords(Collections.singleton(empId), payPeriods, TimeRecordStatus.getAll())
.stream()
.map(TimeRecord::new)
.collect(Collectors.toSet());
logger.info("-------- EXISTING RECORDS --------");
printRecords(existingRecords);
Stopwatch sw = Stopwatch.createStarted();
// Generate records
manager.ensureRecords(empId);
logger.info("generation took {} ms", sw.stop().elapsed(TimeUnit.MILLISECONDS));
// Print difference
Set<TimeRecord> newRecords =
new TreeSet<>(
timeRecordService.getTimeRecords(
Collections.singleton(empId), payPeriods, TimeRecordStatus.getAll()));
logger.info("-------- NEW RECORDS --------");
printRecords(Sets.difference(newRecords, existingRecords));
}
// CHECKSTYLE:OFF
private void updateDTableTreeViewer() {
if (!toExpands.isEmpty()
|| !toCollapses.isEmpty()
|| !toRefreshInViewerWithUpdateLabels.isEmpty()
|| launchGlobalRefreshWithoutUpdateLabels
|| launchGlobalRefreshWithUpdateLabels
|| !toUpdateInViewer.isEmpty()
|| !dColumnsToUpdateDirectly.isEmpty()
|| !dColumnsWidthToUpdate.isEmpty()
|| !dColumnsToRemove.isEmpty()
|| !dColumnsToAdd.isEmpty()
|| !dColumnsToVisibilityChanged.isEmpty()
|| updateHeaderColumnWidth) {
Object[] objectsToUpdateInViewer =
Sets.difference(toUpdateInViewer, toRefreshInViewerWithUpdateLabels)
.toArray(new Object[0]);
Runnable tableUIUpdaterRunnable =
new TableUIUpdaterRunnable(
dTableViewerManager,
dTableTreeViewer,
toExpands,
toCollapses,
toRefreshInViewerWithUpdateLabels,
launchGlobalRefreshWithoutUpdateLabels,
launchGlobalRefreshWithUpdateLabels,
objectsToUpdateInViewer,
dColumnsToUpdateDirectly,
dColumnsWidthToUpdate,
dColumnsToRemove,
dColumnsToAdd,
dColumnsToVisibilityChanged,
updateHeaderColumnWidth);
EclipseUIUtil.displayAsyncExec(tableUIUpdaterRunnable);
}
}
@Override
public boolean apply(Allocation allocInfo) throws MetadataException {
Context ctx = allocInfo.getContext();
NetworkGroups.lookup(
ctx.getUserFullName().asAccountFullName(), NetworkGroups.defaultNetworkName());
Set<String> networkNames = Sets.newHashSet(allocInfo.getRequest().getGroupSet());
if (networkNames.isEmpty()) {
networkNames.add(NetworkGroups.defaultNetworkName());
}
Map<String, NetworkGroup> networkRuleGroups = Maps.newHashMap();
for (String groupName : networkNames) {
NetworkGroup group =
NetworkGroups.lookup(ctx.getUserFullName().asAccountFullName(), groupName);
if (!ctx.hasAdministrativePrivileges()
&& !RestrictedTypes.filterPrivileged().apply(group)) {
throw new IllegalMetadataAccessException(
"Not authorized to use network group "
+ groupName
+ " for "
+ ctx.getUser().getName());
}
networkRuleGroups.put(groupName, group);
}
Set<String> missingNets = Sets.difference(networkNames, networkRuleGroups.keySet());
if (!missingNets.isEmpty()) {
throw new NoSuchMetadataException("Failed to find security group info for: " + missingNets);
} else {
allocInfo.setNetworkRules(networkRuleGroups);
}
return true;
}
public void setSelectedEvents(Set<Event> newEvents) {
Set<Event> oldEvents = Sets.newHashSet(selectedEvents);
if (newEvents.equals(oldEvents)) return;
// set of deselected events
Set<Event> deselectedEvents = Sets.difference(oldEvents, newEvents).immutableCopy();
// set of newly selected events
Set<Event> newlySelectedEvents = Sets.difference(newEvents, oldEvents).immutableCopy();
// XXX these two operations should really happen atomically
// (we want the end result to be that selectedEvents contains everything in newEvents)
selectedEvents.retainAll(newEvents);
selectedEvents.addAll(newEvents);
notifyEventsSelected(newlySelectedEvents, deselectedEvents);
}
@Override
public ImmutableSet<String> get() {
ImmutableSet.Builder<String> result = validateLabels(excludedSet.get());
result.addAll(getBuckConfig().getDefaultExcludedLabels());
ImmutableSet<String> allExcluded = result.build();
// If someone has included a test, then we should really run it.
return Sets.difference(allExcluded, getIncludedLabels()).immutableCopy();
}
public static <V, E> void customTraverse(
final Graph<V, E> graph, final V startNode, final TraversalCallback<V, E> handler) {
Set<V> traversedNodes = new HashSet<V>();
Queue<VertexHolder<V>> traversalQueue = new PriorityQueue<VertexHolder<V>>(16);
int counter = 0;
traversalQueue.add(new VertexHolder<V>(startNode, counter++, 0));
boolean done = false;
do {
boolean first = true;
while (!traversalQueue.isEmpty()) {
V node = traversalQueue.remove().getVertex();
VertexEdges<V, E> edges = graph.getEdges(node);
if (traversedNodes.contains(node)) {
continue;
}
Map<E, V> incomming = edges.getIncomming();
boolean hasIncomingBeenTraversed = true;
for (V val : incomming.values()) {
if (!traversedNodes.contains(val)) {
hasIncomingBeenTraversed = false;
break;
}
}
if (!first && !hasIncomingBeenTraversed) {
continue;
}
handler.handle(node, incomming);
traversedNodes.add(node);
first = false;
Map<E, V> outgoing = edges.getOutgoing();
for (V next : outgoing.values()) {
traversalQueue.add(
new VertexHolder<V>(next, counter++, graph.getEdges(next).getIncomming().size()));
}
}
Set<V> leftNodes = Sets.difference(graph.getVertices(), traversedNodes);
if (leftNodes.isEmpty()) {
done = true;
} else {
boolean added = false;
for (V node : leftNodes) {
Collection<V> incomingNodes = graph.getEdges(node).getIncomming().values();
for (V incoming : incomingNodes) {
if (traversedNodes.contains(incoming)) {
traversalQueue.add(new VertexHolder<V>(node, counter++, 0));
added = true;
break;
}
}
if (added) {
break;
}
}
}
} while (!done);
}